From 86fdde201ac0e049974afc0184b463e47eccc6e7 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Sun, 12 Jul 2026 19:16:31 +1000 Subject: [PATCH 01/17] Stuff (broken merge stuff, please fix) --- examples/tested/fiber/fiber_determinism.osp | 28 +++++++++++++++++++ examples/tested/fiber/fiber_exact_replica.osp | 17 +++++++++++ 2 files changed, 45 insertions(+) diff --git a/examples/tested/fiber/fiber_determinism.osp b/examples/tested/fiber/fiber_determinism.osp index 6f83601a..cc090e13 100644 --- a/examples/tested/fiber/fiber_determinism.osp +++ b/examples/tested/fiber/fiber_determinism.osp @@ -34,6 +34,7 @@ fn processTask2() = processTask(taskId: "task-2", dataSize: 200, priority: Mediu fn processTask3() = processTask(taskId: "task-3", dataSize: 75, priority: Urgent) fn totalProcessed(first: int, second: int, third: int) -> int = first + second + third +<<<<<<< Updated upstream fiber_set_deterministic_mode(enabled: true) handle Metrics recordSuccess taskId processed => print("✅ " + taskId + " succeeded: " + toString(processed) + " units") @@ -55,4 +56,31 @@ in { print("Total processed: " + toString(totalProcessed(result1, result2, result3)) + " units") print("=== Test Complete ===") +======= +fn main() -> Unit = { + fiber_set_deterministic_mode(enabled: true) + handle Metrics + recordSuccess taskId processed => print("✅ " + taskId + " succeeded: " + toString(processed) + " units") + in handle Logger + info msg => print("ℹ️ " + msg) + in { + print("=== Fiber Determinism Test ===") + print("This test executes tasks in spawn order 1, 2, 3") + print("The deterministic run scheduler preserves that order") + print("") + + // Spawn all three fibers + let fiber1 = spawn processTask1() + let fiber2 = spawn processTask2() + let fiber3 = spawn processTask3() + + // Await in order - but execution may be out of order + let result1 = await(fiber1) + let result2 = await(fiber2) + let result3 = await(fiber3) + + print("Total processed: " + toString(totalProcessed(result1, result2, result3)) + " units") + print("=== Test Complete ===") + } +>>>>>>> Stashed changes } diff --git a/examples/tested/fiber/fiber_exact_replica.osp b/examples/tested/fiber/fiber_exact_replica.osp index 76dd171d..e3aca06f 100644 --- a/examples/tested/fiber/fiber_exact_replica.osp +++ b/examples/tested/fiber/fiber_exact_replica.osp @@ -95,6 +95,7 @@ fn processAlphaBatch() -> int ![Logger, Metrics] = { batchTotal } +<<<<<<< Updated upstream fiber_set_deterministic_mode(enabled: true) handle Metrics recordSuccess taskId processed => print("✅ " + taskId + " succeeded: " + toString(processed) + " units") @@ -105,4 +106,20 @@ in { let results1 = processAlphaBatch() print("Total: " + toString(results1)) print("=== Test Complete ===") +======= +fn main() -> Unit = { + fiber_set_deterministic_mode(enabled: true) + handle Metrics + recordSuccess taskId processed => print("✅ " + taskId + " succeeded: " + toString(processed) + " units") + in handle Logger + info msg => print("ℹ️ " + msg) + in { + print("=== Fiber Execution Order Test ===") + + let results1 = processAlphaBatch() + + print("Total: " + toString(results1)) + print("=== Test Complete ===") + } +>>>>>>> Stashed changes } From 2f5fa6ad437f051e10f76c0e6c24583a7e743da8 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Sun, 12 Jul 2026 19:17:55 +1000 Subject: [PATCH 02/17] Resolve broken merge conflicts in fiber examples fiber_determinism.osp and fiber_exact_replica.osp carried unresolved conflict markers from an aborted stash merge. Resolve to the top-level handle...in form (matching the tested version on main); drop the stray fn main() wrapper from the stashed side. --- examples/tested/fiber/fiber_determinism.osp | 28 ------------------- examples/tested/fiber/fiber_exact_replica.osp | 17 ----------- 2 files changed, 45 deletions(-) diff --git a/examples/tested/fiber/fiber_determinism.osp b/examples/tested/fiber/fiber_determinism.osp index cc090e13..6f83601a 100644 --- a/examples/tested/fiber/fiber_determinism.osp +++ b/examples/tested/fiber/fiber_determinism.osp @@ -34,7 +34,6 @@ fn processTask2() = processTask(taskId: "task-2", dataSize: 200, priority: Mediu fn processTask3() = processTask(taskId: "task-3", dataSize: 75, priority: Urgent) fn totalProcessed(first: int, second: int, third: int) -> int = first + second + third -<<<<<<< Updated upstream fiber_set_deterministic_mode(enabled: true) handle Metrics recordSuccess taskId processed => print("✅ " + taskId + " succeeded: " + toString(processed) + " units") @@ -56,31 +55,4 @@ in { print("Total processed: " + toString(totalProcessed(result1, result2, result3)) + " units") print("=== Test Complete ===") -======= -fn main() -> Unit = { - fiber_set_deterministic_mode(enabled: true) - handle Metrics - recordSuccess taskId processed => print("✅ " + taskId + " succeeded: " + toString(processed) + " units") - in handle Logger - info msg => print("ℹ️ " + msg) - in { - print("=== Fiber Determinism Test ===") - print("This test executes tasks in spawn order 1, 2, 3") - print("The deterministic run scheduler preserves that order") - print("") - - // Spawn all three fibers - let fiber1 = spawn processTask1() - let fiber2 = spawn processTask2() - let fiber3 = spawn processTask3() - - // Await in order - but execution may be out of order - let result1 = await(fiber1) - let result2 = await(fiber2) - let result3 = await(fiber3) - - print("Total processed: " + toString(totalProcessed(result1, result2, result3)) + " units") - print("=== Test Complete ===") - } ->>>>>>> Stashed changes } diff --git a/examples/tested/fiber/fiber_exact_replica.osp b/examples/tested/fiber/fiber_exact_replica.osp index e3aca06f..76dd171d 100644 --- a/examples/tested/fiber/fiber_exact_replica.osp +++ b/examples/tested/fiber/fiber_exact_replica.osp @@ -95,7 +95,6 @@ fn processAlphaBatch() -> int ![Logger, Metrics] = { batchTotal } -<<<<<<< Updated upstream fiber_set_deterministic_mode(enabled: true) handle Metrics recordSuccess taskId processed => print("✅ " + taskId + " succeeded: " + toString(processed) + " units") @@ -106,20 +105,4 @@ in { let results1 = processAlphaBatch() print("Total: " + toString(results1)) print("=== Test Complete ===") -======= -fn main() -> Unit = { - fiber_set_deterministic_mode(enabled: true) - handle Metrics - recordSuccess taskId processed => print("✅ " + taskId + " succeeded: " + toString(processed) + " units") - in handle Logger - info msg => print("ℹ️ " + msg) - in { - print("=== Fiber Execution Order Test ===") - - let results1 = processAlphaBatch() - - print("Total: " + toString(results1)) - print("=== Test Complete ===") - } ->>>>>>> Stashed changes } From 7b08f2052ba2fb880d645373738c39dc30c1c0f6 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Sun, 12 Jul 2026 19:41:27 +1000 Subject: [PATCH 03/17] Stuff --- Cargo.lock | 8 + Cargo.toml | 2 + crates/osprey-ast/src/lib.rs | 272 +- crates/osprey-project/Cargo.toml | 14 + crates/osprey-project/src/contribution.rs | 92 + crates/osprey-project/src/lib.rs | 130 + crates/osprey-project/src/manifest.rs | 178 + crates/osprey-project/src/model.rs | 121 + crates/osprey-project/src/source.rs | 58 + crates/osprey-syntax/src/default/lower.rs | 106 +- crates/osprey-syntax/src/ml/cst.rs | 175 +- crates/osprey-syntax/src/ml/lexer.rs | 1 + crates/osprey-syntax/src/ml/lower.rs | 27 +- crates/osprey-syntax/src/ml/parser.rs | 532 +- crates/osprey-syntax/src/ml/token.rs | 30 + docs/specs/0025-ModulesAndNamespaces.md | 454 +- tree-sitter-osprey/grammar.js | 185 +- tree-sitter-osprey/src/grammar.json | 1574 +- tree-sitter-osprey/src/node-types.json | 789 +- tree-sitter-osprey/src/parser.c | 79300 ++++++++++++-------- 20 files changed, 50535 insertions(+), 33513 deletions(-) create mode 100644 crates/osprey-project/Cargo.toml create mode 100644 crates/osprey-project/src/contribution.rs create mode 100644 crates/osprey-project/src/lib.rs create mode 100644 crates/osprey-project/src/manifest.rs create mode 100644 crates/osprey-project/src/model.rs create mode 100644 crates/osprey-project/src/source.rs diff --git a/Cargo.lock b/Cargo.lock index 084c1d9c..b1a1bb41 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -427,6 +427,14 @@ dependencies = [ "tokio-util", ] +[[package]] +name = "osprey-project" +version = "0.0.0-dev" +dependencies = [ + "osprey-ast", + "osprey-syntax", +] + [[package]] name = "osprey-runtime-sys" version = "0.0.0-dev" diff --git a/Cargo.toml b/Cargo.toml index 0adbce46..dd33e434 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,6 +7,7 @@ members = [ "tree-sitter-osprey", "crates/osprey-ast", "crates/osprey-syntax", + "crates/osprey-project", "crates/osprey-types", "crates/osprey-debug", "crates/osprey-codegen", @@ -27,6 +28,7 @@ tree-sitter = "0.24" tree-sitter-language = "0.1" osprey-ast = { path = "crates/osprey-ast" } osprey-syntax = { path = "crates/osprey-syntax" } +osprey-project = { path = "crates/osprey-project" } osprey-types = { path = "crates/osprey-types" } osprey-debug = { path = "crates/osprey-debug" } osprey-codegen = { path = "crates/osprey-codegen" } diff --git a/crates/osprey-ast/src/lib.rs b/crates/osprey-ast/src/lib.rs index 7d872fc4..57fc4a17 100644 --- a/crates/osprey-ast/src/lib.rs +++ b/crates/osprey-ast/src/lib.rs @@ -23,6 +23,148 @@ pub struct Position { pub column: u32, } +/// A canonical namespace/module/member path (`Tax::Rates::standard`). +/// +/// Paths are structured at the flavor boundary so later phases never have to +/// split source spelling or confuse qualification with value member access. +#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)] +pub struct SymbolPath { + /// Path segments in source order. A well-formed source path is non-empty; + /// the empty value is useful for namespace-only imports. + pub segments: Vec, +} + +impl SymbolPath { + /// Build a path from its ordered segments. + #[must_use] + pub fn new(segments: impl IntoIterator>) -> Self { + Self { + segments: segments.into_iter().map(Into::into).collect(), + } + } + + /// Build a one-segment path. + #[must_use] + pub fn single(segment: impl Into) -> Self { + Self { + segments: vec![segment.into()], + } + } + + /// Whether this path contains no segments. + #[must_use] + pub fn is_empty(&self) -> bool { + self.segments.is_empty() + } + + /// The final segment, when present. + #[must_use] + pub fn last(&self) -> Option<&str> { + self.segments.last().map(String::as_str) + } +} + +impl std::fmt::Display for SymbolPath { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(&self.segments.join("::")) + } +} + +/// A logical namespace label. Quotedness is preserved because quoted labels +/// (notably slash labels) require an import alias before qualified use. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum NamespaceName { + /// An ordinary identifier label (`billing`). + Identifier(String), + /// A quoted opaque label (`"billing/api"`). The stored value is unquoted. + Quoted(String), +} + +impl NamespaceName { + /// The semantic label without source quotes. + #[must_use] + pub fn label(&self) -> &str { + match self { + Self::Identifier(label) | Self::Quoted(label) => label, + } + } + + /// Whether the source used the quoted namespace form. + #[must_use] + pub const fn is_quoted(&self) -> bool { + matches!(self, Self::Quoted(_)) + } +} + +/// The namespace plus optional nested path named by an import. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ImportTarget { + /// Logical namespace label (never a physical file path). + pub namespace: NamespaceName, + /// Module path inside the namespace; empty for a namespace-only import. + pub path: SymbolPath, +} + +/// One explicitly imported member and its optional local alias. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ImportMember { + /// Exported member name. + pub name: String, + /// Local name introduced by `as`, when present. + pub alias: Option, +} + +/// The surface selected from an import target. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ImportSelection { + /// Import the target namespace/module as a whole. + Whole, + /// Import only the listed exported members. + Members(Vec), + /// Import every exported member (policy-checked in project mode). + Wildcard, +} + +/// A canonical import edge as contributed by one source file. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ImportDecl { + /// Namespace/module being imported. + pub target: ImportTarget, + /// Alias for the whole target (`import billing::Tax as T`). + pub alias: Option, + /// Whole target, explicit member list, or wildcard. + pub selection: ImportSelection, + /// Source position of the `import` keyword. + pub position: Option, +} + +/// Whether a module owns ordinary declarations or durable private state. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ModuleKind { + /// A closed, stateless-by-default module boundary. + Plain, + /// A declared owner of durable private mutable state. + State, +} + +/// Visibility of a declaration inside a closed module. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Visibility { + /// Visible only inside the owning module. + Private, + /// Part of the module's public surface. + Exported, +} + +/// A module/signature ascription (`: StoreSig` / `: StoreSig + extra`). +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SignatureAscription { + /// Signature path being ascribed. + pub path: SymbolPath, + /// Whether exports beyond the signature are explicitly allowed. + pub allow_extra: bool, +} + /// A parsed program: the sequence of top-level statements. #[derive(Debug, Clone, PartialEq, Default)] pub struct Program { @@ -118,14 +260,106 @@ pub struct EffectOperation { pub return_type: String, } +/// Whether a signature type is abstract or exposes a manifest representation. +#[derive(Debug, Clone, PartialEq)] +pub enum SignatureType { + /// No representation is visible to clients. + Abstract, + /// The public representation is the given type expression. + Manifest(TypeExpr), +} + +/// One typed item in an explicit module signature. +#[derive(Debug, Clone, PartialEq)] +pub enum SignatureItem { + /// An immutable exported value (`let empty: Store`). + Value { + /// Exported value name. + name: String, + /// Declared value type. + ty: TypeExpr, + /// Source position of the item. + position: Option, + }, + /// An exported function contract. + Function { + /// Exported function name. + name: String, + /// Declared generic binders. + type_params: Vec, + /// Parameter types in call order (parameter names are not contractual). + parameters: Vec, + /// Declared result type. + return_type: TypeExpr, + /// Declared effect row. + effects: Vec, + /// Source position of the item. + position: Option, + }, + /// An abstract or manifest exported type contract. + Type { + /// Exported type name. + name: String, + /// Declared generic binders. + type_params: Vec, + /// Abstract or manifest representation. + definition: SignatureType, + /// Whether the representation stays opaque outside the module even + /// when the implementation supplies a manifest type. + opaque: bool, + /// Source position of the item. + position: Option, + }, + /// An exported algebraic-effect contract. + Effect { + /// Exported effect name. + name: String, + /// Declared generic binders. + type_params: Vec, + /// Operation contracts. + operations: Vec, + /// Source position of the item. + position: Option, + }, + /// A nested module constrained by another signature. + Module { + /// Nested module path. + path: SymbolPath, + /// Required signature and optional-extra policy. + signature: SignatureAscription, + /// Source position of the item. + position: Option, + }, +} + +/// A declaration inside a closed module, with its public-surface metadata. +#[derive(Debug, Clone, PartialEq)] +pub struct ModuleItem { + /// Private by default; `export` makes the item public. + pub visibility: Visibility, + /// Representation-hiding marker for exported type declarations. + pub opaque: bool, + /// The underlying declaration. + pub declaration: Box, +} + /// A statement: every top-level declaration and binding form, plus bare /// expressions. #[derive(Debug, Clone, PartialEq)] pub enum Stmt { - /// `import a.b.c` — a dotted module path. - Import { - /// The module path segments. - module: Vec, + /// An import edge to a logical namespace/module surface. + Import(ImportDecl), + /// A block-scoped or file-scoped logical namespace contribution. + Namespace { + /// Opaque logical namespace label. + name: NamespaceName, + /// Statements contributed to the namespace. For a file-scoped + /// declaration this contains the declarations following the semicolon. + body: Vec, + /// `true` for `namespace name;`, `false` for a brace block. + file_scoped: bool, + /// Source position of the `namespace` keyword. + position: Option, }, /// `let`/`mut` binding. Let { @@ -192,6 +426,9 @@ pub enum Stmt { type_params: Vec, /// Variants (one for a record, many for a union). variants: Vec, + /// Manifest alias representation (`type UserId = int`), when this is a + /// type alias rather than a record/union declaration. + alias: Option, /// An optional validation function name (`where`-constrained type). validation_func: Option, /// Structured documentation comment, when written ([DOC-MODEL]). @@ -213,14 +450,31 @@ pub enum Stmt { /// Source position, if recorded. position: Option, }, - /// A `module` block grouping nested statements. + /// A closed `module` / `state module` implementation boundary. Module { - /// Module name. + /// Possibly nested module path. + path: SymbolPath, + /// Plain module or durable-state owner. + kind: ModuleKind, + /// Explicit signature ascription, when present. + signature: Option, + /// Declarations and their module-local visibility metadata. + body: Vec, + /// Structured documentation comment, when written ([DOC-MODEL]). + doc: Option, + /// Source position of the `module` keyword (or leading `state`). + position: Option, + }, + /// An explicit interface contract for modules. + Signature { + /// Signature name. name: String, - /// Statements inside the module. - body: Vec, + /// Typed public-surface items. + items: Vec, /// Structured documentation comment, when written ([DOC-MODEL]). doc: Option, + /// Source position of the `signature` keyword. + position: Option, }, /// A bare expression statement. Expr { @@ -334,6 +588,8 @@ pub enum Expr { InterpolatedStr(Vec), /// A bare identifier reference. Identifier(String), + /// A namespace/module-qualified reference (`billing::Tax::addTax`). + Path(SymbolPath), /// `[a, b, c]` list literal. List(Vec), /// `{ k: v, ... }` map literal. diff --git a/crates/osprey-project/Cargo.toml b/crates/osprey-project/Cargo.toml new file mode 100644 index 00000000..4382f669 --- /dev/null +++ b/crates/osprey-project/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "osprey-project" +description = "Project loading, namespace assembly, and module resolution for Osprey" +version.workspace = true +edition.workspace = true +license.workspace = true +repository.workspace = true + +[dependencies] +osprey-ast = { workspace = true } +osprey-syntax = { workspace = true } + +[lints] +workspace = true diff --git a/crates/osprey-project/src/contribution.rs b/crates/osprey-project/src/contribution.rs new file mode 100644 index 00000000..3483aa52 --- /dev/null +++ b/crates/osprey-project/src/contribution.rs @@ -0,0 +1,92 @@ +//! Conversion from per-file syntax trees into open namespace contributions. + +use crate::{ProjectConfig, SourceFile}; +use osprey_ast::{ImportDecl, NamespaceName, Stmt}; + +/// One file's declarations contributed to one logical namespace. +#[derive(Debug, Clone)] +pub(crate) struct Contribution { + pub source: usize, + pub namespace: NamespaceName, + pub imports: Vec, + pub statements: Vec, +} + +pub(crate) fn extract(config: &ProjectConfig, sources: &[SourceFile]) -> Vec { + sources + .iter() + .enumerate() + .flat_map(|(index, source)| from_file(config, index, &source.program.statements)) + .collect() +} + +fn from_file(config: &ProjectConfig, source: usize, statements: &[Stmt]) -> Vec { + let mut out = Vec::new(); + let mut unscoped = Vec::new(); + for statement in statements { + match statement { + Stmt::Namespace { name, body, .. } => { + out.push(build(source, name.clone(), body.clone())); + } + other => unscoped.push(other.clone()), + } + } + if !unscoped.is_empty() { + out.push(build(source, default_name(config), unscoped)); + } + out +} + +fn build(source: usize, namespace: NamespaceName, statements: Vec) -> Contribution { + let mut imports = Vec::new(); + let mut declarations = Vec::new(); + for statement in statements { + match statement { + Stmt::Import(import) => imports.push(import), + other => declarations.push(other), + } + } + Contribution { + source, + namespace, + imports, + statements: declarations, + } +} + +fn default_name(config: &ProjectConfig) -> NamespaceName { + NamespaceName::Identifier( + config + .default_namespace + .clone() + .unwrap_or_else(|| config.name.clone()), + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use osprey_ast::Program; + use osprey_syntax::Flavor; + use std::path::{Path, PathBuf}; + + #[test] + fn explicit_namespaces_are_independent_of_paths() { + // Implements [MODULES-NAMESPACE], [MODULES-PATH-INDEPENDENCE]. + let source = SourceFile { + path: PathBuf::from("deep/wrong/place.osp"), + flavor: Flavor::Default, + source: String::new(), + program: Program { + statements: vec![Stmt::Namespace { + name: NamespaceName::Quoted("billing/api".into()), + body: Vec::new(), + file_scoped: true, + position: None, + }], + }, + }; + let found = extract(&ProjectConfig::for_root(Path::new("app")), &[source]); + assert_eq!(found[0].namespace.label(), "billing/api"); + } +} diff --git a/crates/osprey-project/src/lib.rs b/crates/osprey-project/src/lib.rs new file mode 100644 index 00000000..20df5071 --- /dev/null +++ b/crates/osprey-project/src/lib.rs @@ -0,0 +1,130 @@ +//! Osprey project loading and module resolution. +//! +//! The project layer is the only phase allowed to know physical source paths. +//! It parses mixed `.osp`/`.ospml` inputs, assembles logical namespace +//! contributions, resolves module imports, and emits one flavor-neutral +//! canonical program for checking and code generation. Implements +//! [MODULES-MODEL], [MODULES-PATH-INDEPENDENCE], and [MODULES-PROJECT]. + +mod contribution; +mod manifest; +mod model; +mod source; + +pub use manifest::ProjectConfig; +use osprey_syntax::Flavor; +use std::path::{Path, PathBuf}; + +/// One source file selected for project assembly. +#[derive(Debug, Clone)] +pub struct SourceFile { + /// Physical path, used only for reads and diagnostics. + pub path: PathBuf, + /// Flavor selected before parsing. + pub flavor: Flavor, + /// Original source text, retained for linking directives and diagnostics. + pub source: String, + /// Canonical parsed AST. + pub program: osprey_ast::Program, +} + +/// A project-level failure tied to a source or manifest location when known. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ProjectError { + /// Human-readable diagnostic. + pub message: String, + /// Physical file involved, when applicable. + pub path: Option, + /// One-based source line, when applicable. + pub line: Option, +} + +impl ProjectError { + fn manifest(line: usize, message: impl Into) -> Self { + Self { + message: message.into(), + path: None, + line: Some(line), + } + } + + fn io(path: &Path, error: &std::io::Error) -> Self { + Self { + message: error.to_string(), + path: Some(path.to_path_buf()), + line: None, + } + } +} + +/// Read a directory project and parse every configured source file. +pub fn load(root: &Path) -> Result<(ProjectConfig, Vec), Vec> { + let manifest_path = root.join("osprey.toml"); + let config = load_config(root, &manifest_path)?; + let paths = source::discover(root, &config).map_err(|error| vec![error])?; + parse_sources(paths, config.flavor).map(|sources| (config, sources)) +} + +fn load_config(root: &Path, manifest_path: &Path) -> Result> { + if !manifest_path.is_file() { + return Ok(ProjectConfig::for_root(root)); + } + let text = std::fs::read_to_string(manifest_path) + .map_err(|error| vec![ProjectError::io(manifest_path, &error)])?; + ProjectConfig::parse(&text, manifest_path).map_err(|mut errors| { + for error in &mut errors { + error.path = Some(manifest_path.to_path_buf()); + } + errors + }) +} + +fn parse_sources( + paths: Vec, + configured: Option, +) -> Result, Vec> { + let mut sources = Vec::new(); + let mut errors = Vec::new(); + for path in paths { + match parse_source(path, configured) { + Ok(source) => sources.push(source), + Err(mut source_errors) => errors.append(&mut source_errors), + } + } + if errors.is_empty() { + Ok(sources) + } else { + Err(errors) + } +} + +fn parse_source(path: PathBuf, configured: Option) -> Result> { + let source = std::fs::read_to_string(&path) + .map_err(|error| vec![ProjectError::io(&path, &error)])?; + let label = path.to_string_lossy(); + let flavor = osprey_syntax::resolve_flavor(configured, &label, &source).map_err(|message| { + vec![ProjectError { + message, + path: Some(path.clone()), + line: None, + }] + })?; + let parsed = osprey_syntax::parse_program_with_flavor(&source, flavor); + if !parsed.errors.is_empty() { + return Err(parsed + .errors + .into_iter() + .map(|error| ProjectError { + message: error.message, + path: Some(path.clone()), + line: usize::try_from(error.position.line).ok(), + }) + .collect()); + } + Ok(SourceFile { + path, + flavor, + source, + program: parsed.program, + }) +} diff --git a/crates/osprey-project/src/manifest.rs b/crates/osprey-project/src/manifest.rs new file mode 100644 index 00000000..dcfb5ace --- /dev/null +++ b/crates/osprey-project/src/manifest.rs @@ -0,0 +1,178 @@ +//! Minimal, dependency-free reader for the project and module sections of +//! `osprey.toml`. Unknown keys are ignored so packaging/tooling sections can +//! evolve independently of the compiler. + +use crate::ProjectError; +use osprey_syntax::Flavor; +use std::path::{Path, PathBuf}; + +/// Project assembly settings read from `osprey.toml`. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ProjectConfig { + /// Human-readable project name. + pub name: String, + /// Directories scanned for production sources, relative to the manifest. + pub source_roots: Vec, + /// Optional default namespace for files without an explicit declaration. + pub default_namespace: Option, + /// Optional entry source, relative to the manifest directory. + pub entry: Option, + /// Optional project-wide fallback flavor. + pub flavor: Option, + /// Whether `::*` imports are permitted outside scripts and tests. + pub allow_wildcard_imports: bool, +} + +impl ProjectConfig { + /// Defaults for a manifest-free directory project. + #[must_use] + pub fn for_root(root: &Path) -> Self { + let name = root + .file_name() + .and_then(|value| value.to_str()) + .unwrap_or("app") + .to_string(); + let source = if root.join("src").is_dir() { "src" } else { "." }; + Self { + default_namespace: Some(name.clone()), + name, + source_roots: vec![PathBuf::from(source)], + entry: None, + flavor: None, + allow_wildcard_imports: false, + } + } + + /// Parse the supported `osprey.toml` keys. + pub fn parse(text: &str, path: &Path) -> Result> { + let root = path.parent().unwrap_or_else(|| Path::new(".")); + let mut config = Self::for_root(root); + let mut errors = Vec::new(); + let mut section = String::new(); + for (index, raw) in text.lines().enumerate() { + parse_line(raw, index + 1, &mut section, &mut config, &mut errors); + } + if errors.is_empty() { + Ok(config) + } else { + Err(errors) + } + } +} + +fn parse_line( + raw: &str, + line: usize, + section: &mut String, + config: &mut ProjectConfig, + errors: &mut Vec, +) { + let content = raw.split('#').next().unwrap_or_default().trim(); + if content.is_empty() { + return; + } + if let Some(name) = content.strip_prefix('[').and_then(|s| s.strip_suffix(']')) { + section.clear(); + section.push_str(name.trim()); + return; + } + let Some((key, value)) = content.split_once('=') else { + errors.push(ProjectError::manifest(line, "expected `key = value`")); + return; + }; + apply_key(section, key.trim(), value.trim(), line, config, errors); +} + +fn apply_key( + section: &str, + key: &str, + value: &str, + line: usize, + config: &mut ProjectConfig, + errors: &mut Vec, +) { + let result = match (section, key) { + ("project", "name") => parse_string(value).map(|v| config.name = v), + ("project", "source_roots") => parse_list(value).map(|roots| { + config.source_roots = roots.into_iter().map(PathBuf::from).collect(); + }), + ("project", "default_namespace") => { + parse_string(value).map(|v| config.default_namespace = Some(v)) + } + ("project", "entry") => parse_string(value).map(|v| config.entry = Some(v.into())), + ("project", "flavor") => parse_flavor(value).map(|v| config.flavor = Some(v)), + ("modules", "allow_wildcard_imports") => { + parse_bool(value).map(|v| config.allow_wildcard_imports = v) + } + _ => return, + }; + if let Err(message) = result { + errors.push(ProjectError::manifest(line, message)); + } +} + +fn parse_string(value: &str) -> Result { + value + .strip_prefix('"') + .and_then(|inner| inner.strip_suffix('"')) + .map(str::to_string) + .ok_or_else(|| "expected a quoted string".to_string()) +} + +fn parse_list(value: &str) -> Result, String> { + let inner = value + .strip_prefix('[') + .and_then(|items| items.strip_suffix(']')) + .ok_or_else(|| "expected a string list".to_string())?; + if inner.trim().is_empty() { + return Ok(Vec::new()); + } + inner.split(',').map(|item| parse_string(item.trim())).collect() +} + +fn parse_bool(value: &str) -> Result { + match value { + "true" => Ok(true), + "false" => Ok(false), + _ => Err("expected `true` or `false`".to_string()), + } +} + +fn parse_flavor(value: &str) -> Result { + parse_string(value)?.parse() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parses_project_and_module_policy() { + // Implements [MODULES-PROJECT]. + let text = "[project]\nname = \"billing\"\nsource_roots = [\"src\", \"generated\"]\n\ + default_namespace = \"billing\"\nentry = \"src/main.ospml\"\nflavor = \"ml\"\n\ + [modules]\nallow_wildcard_imports = true\n"; + let config = ProjectConfig::parse(text, Path::new("/tmp/app/osprey.toml")); + let config = match config { + Ok(value) => value, + Err(errors) => panic!("unexpected manifest errors: {errors:?}"), + }; + assert_eq!(config.name, "billing"); + assert_eq!(config.source_roots.len(), 2); + assert_eq!(config.entry, Some(PathBuf::from("src/main.ospml"))); + assert_eq!(config.flavor, Some(Flavor::Ml)); + assert!(config.allow_wildcard_imports); + } + + #[test] + fn reports_bad_supported_values_and_ignores_other_sections() { + let text = "[project]\nname = bare\n[package]\nversion = nope\n\ + [modules]\nallow_wildcard_imports = maybe\n"; + let errors = ProjectConfig::parse(text, Path::new("osprey.toml")); + let errors = match errors { + Ok(value) => panic!("expected errors, got {value:?}"), + Err(errors) => errors, + }; + assert_eq!(errors.len(), 2); + } +} diff --git a/crates/osprey-project/src/model.rs b/crates/osprey-project/src/model.rs new file mode 100644 index 00000000..ee0595e2 --- /dev/null +++ b/crates/osprey-project/src/model.rs @@ -0,0 +1,121 @@ +//! Canonical names and declaration metadata used while assembling a project. + +use osprey_ast::{ModuleKind, Position, SignatureAscription, SignatureItem, Visibility}; +use std::collections::{BTreeMap, BTreeSet}; + +/// Stable logical identity of a declaration. +#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub(crate) struct SymbolKey { + pub namespace: String, + pub path: Vec, +} + +impl SymbolKey { + pub fn new(namespace: impl Into, path: Vec) -> Self { + Self { + namespace: namespace.into(), + path, + } + } + + pub fn child(&self, name: impl Into) -> Self { + let mut path = self.path.clone(); + path.push(name.into()); + Self::new(self.namespace.clone(), path) + } + + pub fn parent_path(&self) -> &[String] { + self.path + .get(..self.path.len().saturating_sub(1)) + .unwrap_or_default() + } + + pub fn source_name(&self) -> String { + std::iter::once(self.namespace.as_str()) + .chain(self.path.iter().map(String::as_str)) + .filter(|segment| !segment.is_empty()) + .collect::>() + .join("::") + } + + pub fn mangled(&self) -> String { + let mut out = String::from("__osp"); + push_hex_segment(&mut out, &self.namespace); + for segment in &self.path { + push_hex_segment(&mut out, segment); + } + out + } +} + +fn push_hex_segment(out: &mut String, segment: &str) { + use std::fmt::Write as _; + let _ = write!(out, "_{}x", segment.len()); + for byte in segment.as_bytes() { + let _ = write!(out, "{byte:02x}"); + } +} + +/// Declaration category needed for import/signature validation. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum DeclKind { + Function, + Value, + Type, + Constructor, + Effect, + Module, +} + +/// One declaration registered in the namespace graph. +#[derive(Debug, Clone)] +pub(crate) struct DeclInfo { + pub kind: DeclKind, + pub visibility: Visibility, + pub owner: Vec, + pub source: usize, + pub position: Option, + pub state_owner: bool, +} + +impl DeclInfo { + pub fn visible_from(&self, module: &[String]) -> bool { + self.visibility == Visibility::Exported || module.starts_with(&self.owner) + } +} + +/// Metadata for one closed module boundary. +#[derive(Debug, Clone)] +pub(crate) struct ModuleInfo { + pub kind: ModuleKind, + pub signature: Option, + pub exports: BTreeSet, + pub state_cells: BTreeSet, + pub effects: BTreeSet, + pub handler_functions: BTreeSet, + pub source: usize, + pub position: Option, +} + +/// Collected declarations and explicit signatures for a project. +#[derive(Debug, Default)] +pub(crate) struct ProjectGraph { + pub declarations: BTreeMap, + pub modules: BTreeMap, + pub signatures: BTreeMap>, +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn mangling_is_path_sensitive_and_identifier_safe() { + // Implements [MODULES-ABI]. + let one = SymbolKey::new("billing/api", vec!["Tax".into(), "add".into()]); + let two = SymbolKey::new("billing", vec!["api".into(), "Tax".into(), "add".into()]); + assert_ne!(one.mangled(), two.mangled()); + assert!(one.mangled().chars().all(|c| c.is_ascii_alphanumeric() || c == '_')); + assert_eq!(one.source_name(), "billing/api::Tax::add"); + } +} diff --git a/crates/osprey-project/src/source.rs b/crates/osprey-project/src/source.rs new file mode 100644 index 00000000..9eeef994 --- /dev/null +++ b/crates/osprey-project/src/source.rs @@ -0,0 +1,58 @@ +//! Deterministic source-root discovery for mixed-flavor projects. + +use crate::{ProjectConfig, ProjectError}; +use std::path::{Path, PathBuf}; + +/// Discover every `.osp` and `.ospml` source under configured roots. +pub(crate) fn discover(root: &Path, config: &ProjectConfig) -> Result, ProjectError> { + let mut paths = Vec::new(); + for source_root in &config.source_roots { + visit(&root.join(source_root), &mut paths)?; + } + paths.sort(); + paths.dedup(); + Ok(paths) +} + +fn visit(path: &Path, out: &mut Vec) -> Result<(), ProjectError> { + if path.is_file() { + if is_source(path) { + out.push(path.to_path_buf()); + } + return Ok(()); + } + let entries = std::fs::read_dir(path).map_err(|error| ProjectError::io(path, &error))?; + for entry in entries { + let entry = entry.map_err(|error| ProjectError::io(path, &error))?; + if !hidden(&entry.path()) { + visit(&entry.path(), out)?; + } + } + Ok(()) +} + +fn is_source(path: &Path) -> bool { + path.extension() + .and_then(|extension| extension.to_str()) + .is_some_and(|extension| extension == "osp" || extension == "ospml") +} + +fn hidden(path: &Path) -> bool { + path.file_name() + .and_then(|name| name.to_str()) + .is_some_and(|name| name.starts_with('.') || name == "target") +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn source_extensions_are_exact() { + assert!(is_source(Path::new("a.osp"))); + assert!(is_source(Path::new("a.ospml"))); + assert!(!is_source(Path::new("a.ospo"))); + assert!(hidden(Path::new("target"))); + assert!(hidden(Path::new(".cache"))); + } +} diff --git a/crates/osprey-syntax/src/default/lower.rs b/crates/osprey-syntax/src/default/lower.rs index 4489566c..c88c0db0 100644 --- a/crates/osprey-syntax/src/default/lower.rs +++ b/crates/osprey-syntax/src/default/lower.rs @@ -2,9 +2,12 @@ //! `effect`, `extern`, `module`), type expressions, and match patterns. use super::position_from_point; +use crate::strings::unquote; use osprey_ast::{ - DocComment, DocScope, EffectOperation, EffectRef, Expr, ExternParameter, Parameter, Pattern, - Position, Program, Stmt, TypeExpr, TypeField, TypeParam, TypeVariant, Variance, + DocComment, DocScope, EffectOperation, EffectRef, Expr, ExternParameter, ImportDecl, + ImportMember, ImportSelection, ImportTarget, ModuleItem, ModuleKind, NamespaceName, Parameter, + Pattern, Position, Program, SignatureAscription, SignatureItem, SignatureType, Stmt, + SymbolPath, TypeExpr, TypeField, TypeParam, TypeVariant, Variance, Visibility, }; use tree_sitter::Node; @@ -96,20 +99,54 @@ impl<'a> Lowerer<'a> { pub fn lower_program(&self, root: Node<'_>) -> Program { let mut statements = Vec::new(); let mut cursor = root.walk(); - for child in root.named_children(&mut cursor) { - if child.kind() == "statement" { - if let Some(stmt) = self.first_named(child).and_then(|n| self.lower_stmt(n)) { - statements.push(stmt); - } + let source_statements: Vec> = root + .named_children(&mut cursor) + .filter(|child| child.kind() == "statement") + .collect(); + let mut index = 0; + while let Some(wrapper) = source_statements.get(index).copied() { + let Some(node) = self.first_named(wrapper) else { + index += 1; + continue; + }; + // A file-scoped namespace owns every following declaration in the + // file. Canonicalise that relationship here rather than making + // later phases reinterpret source order. [MODULES-FILE-SCOPED-NAMESPACE] + if node.kind() == "namespace_declaration" + && node.child_by_field_name("body").is_none() + { + let body = source_statements[index + 1..] + .iter() + .filter_map(|s| self.first_named(*s)) + .filter_map(|s| self.lower_stmt(s)) + .collect(); + statements.push(Stmt::Namespace { + name: self.lower_namespace_name(node.child_by_field_name("name")), + body, + file_scoped: true, + position: Some(self.field_pos(node, "keyword")), + }); + break; } + if let Some(stmt) = self.lower_stmt(node) { + statements.push(stmt); + } + index += 1; } Program { statements } } pub(crate) fn lower_stmt(&self, node: Node<'_>) -> Option { Some(match node.kind() { - "import_statement" => Stmt::Import { - module: self.texts_of_kind(node, "identifier"), + "import_statement" => Stmt::Import(self.lower_import(node)), + "namespace_declaration" => Stmt::Namespace { + name: self.lower_namespace_name(node.child_by_field_name("name")), + body: node + .child_by_field_name("body") + .map(|body| self.lower_statement_children(body)) + .unwrap_or_default(), + file_scoped: node.child_by_field_name("body").is_none(), + position: Some(self.field_pos(node, "keyword")), }, "let_declaration" => Stmt::Let { name: self.field_text(node, "name"), @@ -156,14 +193,34 @@ impl<'a> Lowerer<'a> { position: Some(self.pos(node)), }, "module_declaration" => Stmt::Module { - name: self.field_text(node, "name"), + path: node + .child_by_field_name("path") + .map_or_else(SymbolPath::default, |p| self.lower_symbol_path(p)), + kind: if node.child_by_field_name("state").is_some() { + ModuleKind::State + } else { + ModuleKind::Plain + }, + signature: node + .child_by_field_name("signature") + .map(|s| self.lower_signature_ascription(s)), body: self - .named_of_kind(node, "module_statement") + .named_of_kind(node, "module_item") .iter() - .filter_map(|n| self.first_named(*n)) - .filter_map(|n| self.lower_stmt(n)) + .filter_map(|item| self.lower_module_item(*item)) .collect(), doc: self.doc_text(node), + position: Some(self.field_pos(node, "keyword")), + }, + "signature_declaration" => Stmt::Signature { + name: self.field_text(node, "name"), + items: self + .named_of_kind(node, "signature_item") + .iter() + .filter_map(|item| self.lower_signature_item(*item)) + .collect(), + doc: self.doc_text(node), + position: Some(self.field_pos(node, "keyword")), }, "expression_statement" => { let expr = self.first_named(node)?; @@ -178,7 +235,11 @@ impl<'a> Lowerer<'a> { fn lower_type_decl(&self, node: Node<'_>) -> Stmt { let def = node.child_by_field_name("definition"); - let variants = match def.map(|d| (d.kind(), d)) { + let mut alias = match def.map(|d| (d.kind(), d)) { + Some(("type_alias", d)) => self.first_named(d).map(|t| self.lower_type(t)), + _ => None, + }; + let mut variants = match def.map(|d| (d.kind(), d)) { Some(("union_type", d)) => self.map_of_kind(d, "variant", Self::lower_variant), Some(("record_type", d)) => vec![TypeVariant { name: self.field_text(node, "name"), @@ -186,10 +247,27 @@ impl<'a> Lowerer<'a> { }], _ => Vec::new(), }; + // Preserve the historical `type Color = Red` one-variant union while + // making the adoption-friendly `type UserId = int` spelling an alias. + // Osprey constructors conventionally begin uppercase; a lone lowercase + // RHS therefore has an unambiguous type-alias interpretation. + if alias.is_none() + && variants.len() == 1 + && variants[0].fields.is_empty() + && variants[0] + .name + .chars() + .next() + .is_some_and(char::is_lowercase) + { + alias = Some(TypeExpr::named(variants[0].name.clone())); + variants.clear(); + } Stmt::Type { name: self.field_text(node, "name"), type_params: self.lower_type_params(node), variants, + alias, validation_func: self .first_child_of_kind(node, "type_validation") .and_then(|tv| self.first_named(tv)) diff --git a/crates/osprey-syntax/src/ml/cst.rs b/crates/osprey-syntax/src/ml/cst.rs index 56610d78..74b6706c 100644 --- a/crates/osprey-syntax/src/ml/cst.rs +++ b/crates/osprey-syntax/src/ml/cst.rs @@ -12,9 +12,175 @@ use osprey_ast::Position; +/// A source-level namespace/module/member path. Segments are kept separate so +/// qualification can never be confused with value-level `.` access +/// ([MODULES-MODEL], [MODULES-ABI]). +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct MlSymbolPath { + /// Path segments in source order; a valid path is never empty. + pub segments: Vec, +} + +/// The first, logical namespace component of a namespace/import declaration. +/// Quoted slash labels are opaque strings, not path hierarchies +/// ([MODULES-NAMESPACE], [MODULES-PATH-INDEPENDENCE]). +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) enum MlNamespaceName { + /// An ordinary identifier label such as `billing`. + Ident(String), + /// An opaque quoted label such as `"billing/api"`. + Quoted(String), +} + +/// The selection made by one import ([MODULES-IMPORT]). +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) enum MlImportSelection { + /// Import the target namespace/module itself. + Whole, + /// Import an explicit layout list of exported members. + Members(Vec), + /// Import every exported member (policy-controlled escape hatch). + Wildcard, +} + +/// One member inside an explicit layout import list. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct MlImportMember { + /// Exported member name at the target. + pub name: String, + /// Optional local alias after `as`. + pub alias: Option, +} + +/// A parsed logical import target and its local projection. +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct MlImport { + /// Logical namespace label, independent of a physical file path. + pub namespace: MlNamespaceName, + /// Module path below the namespace (possibly empty for a namespace import). + pub path: MlSymbolPath, + /// Optional alias for a whole import. + pub alias: Option, + /// Whole target, selected members, or wildcard. + pub selection: MlImportSelection, +} + +/// Whether a module is a plain abstraction boundary or a state owner. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub(crate) enum MlModuleKind { + /// A stateless plain module. + Plain, + /// A `state Name` module owning private mutable cells. + State, +} + +/// One public requirement in a named module signature +/// ([MODULES-SIGNATURE]). +#[derive(Debug, Clone, PartialEq)] +pub(crate) enum MlSignatureItem { + /// A value/function type and optional effect row. + Value { + /// Required exported name. + name: String, + /// Declared generic binders. + type_params: Vec, + /// Required value/function type. + ty: MlType, + /// Required effect row. + effects: Vec, + /// Source position of the name. + pos: Position, + }, + /// An abstract (`type T`) or manifest (`type T = R`) type requirement. + Type { + /// Required type name. + name: String, + /// `None` for an abstract type; `Some` for a manifest representation. + manifest: Option, + /// Source position of the `type` keyword. + pos: Position, + }, + /// An effect and its operation interface. + Effect { + /// Required effect name. + name: String, + /// Declared generic binders. + type_params: Vec, + /// Required operations. + operations: Vec, + /// Source position of the `effect` keyword. + pos: Position, + }, + /// A nested module requirement ascribed to another named signature. + Module { + /// Required nested module name. + name: String, + /// Signature the nested module must satisfy. + signature: MlSymbolPath, + /// Source position of the `module` keyword. + pos: Position, + }, +} + /// A top-level item or a statement inside a layout block. #[derive(Debug, Clone, PartialEq)] pub(crate) enum MlItem { + /// A logical namespace/module import ([MODULES-IMPORT]). + Import { + /// Parsed target, alias, and member projection. + import: MlImport, + /// Source position of the `import` keyword. + pos: Position, + }, + /// A logical namespace contribution. `body: None` is file-scoped; `Some` + /// is an indented block contribution ([MODULES-FILE-SCOPED-NAMESPACE]). + Namespace { + /// Logical namespace label. + name: MlNamespaceName, + /// Optional indented contribution body. + body: Option>, + /// Source position of the `namespace` keyword. + pos: Position, + }, + /// A plain or state module with an optional named signature ascription. + Module { + /// Qualified module path. + path: MlSymbolPath, + /// Plain versus state-owning module. + kind: MlModuleKind, + /// Optional named interface controlling the complete export surface. + signature: Option, + /// Private-by-default implementation items. + body: Vec, + /// Source position of the module/state keyword. + pos: Position, + }, + /// A named module signature declaration. + ModuleSignature { + /// Signature name. + name: String, + /// Public requirements in source order. + items: Vec, + /// Source position of the `signature` keyword. + pos: Position, + }, + /// Exactly one explicitly exported declaration group. An exported value + /// signature propagates to its immediately-following bare definition. + Export { + /// Declaration carrying explicit public visibility. + item: Box, + /// Source position of the `export` keyword. + pos: Position, + }, + /// An explicitly opaque type declaration. This wrapper is valid only under + /// one [`MlItem::Export`] in an un-ascribed module; named signatures express + /// abstraction with a bare `type T` requirement instead. + Opaque { + /// Wrapped type declaration. + item: Box, + /// Source position of the `opaque` keyword. + pos: Position, + }, /// `mut? name param* = body`. Zero params ⇒ a value binding; one or more /// (including the unit marker) ⇒ a function definition. Currying is not yet /// applied — `params` is the flat surface list; `uncurried` records *which* @@ -50,7 +216,7 @@ pub(crate) enum MlItem { /// the same name that follows it. Kept in the CST so the lowerer can apply /// concrete parameter/return types (which the type checker and codegen rely /// on for curried closures and `Result` auto-unwrap). - Signature { + ValueSignature { /// The signed name. name: String, /// Declared type parameters from a `name :` binder, in order @@ -61,6 +227,8 @@ pub(crate) enum MlItem { /// The effect row from a trailing `! Ref(, Ref)*` (or `! [Ref, …]`), /// empty when the signature declares no effects ([FLAVOR-ML-EFFECT]). effects: Vec, + /// Source position of the signed name. + pos: Position, }, /// `type Name param* =` + an indented layout block of variants /// ([FLAVOR-ML-TYPE]). A union/enum lists uppercase constructor variants @@ -113,7 +281,7 @@ pub(crate) enum MlItem { }, /// A `(** … *)` documentation comment's raw text, paired by the lowerer /// with the declaration that follows it ([DOC-SIGIL-ML]) — the same - /// pairing pattern as [`MlItem::Signature`]. + /// pairing pattern as [`MlItem::ValueSignature`]. Doc(String), } @@ -240,6 +408,9 @@ pub(crate) enum MlExpr { Str(String), /// Identifier or constructor reference. Ident(String), + /// A namespace/module/member-qualified reference such as `Tax::addTax`. + /// This is distinct from [`MlExpr::Field`] so `.` remains value access. + Path(MlSymbolPath), /// Prefix unary (`-x`, `!x`). Unary { /// Operator spelling. diff --git a/crates/osprey-syntax/src/ml/lexer.rs b/crates/osprey-syntax/src/ml/lexer.rs index 5eb36afb..e717f475 100644 --- a/crates/osprey-syntax/src/ml/lexer.rs +++ b/crates/osprey-syntax/src/ml/lexer.rs @@ -391,6 +391,7 @@ fn two_char_operator(c: char, next: Option) -> Option { let next = next?; let kind = match (c, next) { (':', '=') => TokKind::ColonEq, + (':', ':') => TokKind::ColonColon, ('-', '>') => TokKind::Arrow, ('=', '>') => TokKind::FatArrow, ('=', '=') => TokKind::Op("==".to_owned()), diff --git a/crates/osprey-syntax/src/ml/lower.rs b/crates/osprey-syntax/src/ml/lower.rs index 01e90cf7..4f46957e 100644 --- a/crates/osprey-syntax/src/ml/lower.rs +++ b/crates/osprey-syntax/src/ml/lower.rs @@ -22,14 +22,17 @@ //! [`Expr::TypeConstructor`], [`Expr::Block`], and [`Expr::InterpolatedStr`]. use super::cst::{ - MlArm, MlEffectOp, MlEffectRef, MlExpr, MlExternParam, MlField, MlHandleArm, MlItem, MlParam, - MlPattern, MlType, MlTypeField, MlTypeParam, MlVariance, MlVariant, + MlArm, MlEffectOp, MlEffectRef, MlExpr, MlExternParam, MlField, MlHandleArm, MlImport, + MlImportSelection, MlItem, MlModuleKind, MlNamespaceName, MlParam, MlPattern, MlSignatureItem, + MlSymbolPath, MlType, MlTypeField, MlTypeParam, MlVariance, MlVariant, }; use crate::strings::{lower_interpolation, unquote}; use osprey_ast::{ DocComment, DocScope, EffectOperation, EffectRef, Expr, ExternParameter, FieldAssignment, - HandlerArm, MapEntry, MatchArm, Parameter, Pattern, Position, Program, Stmt, TypeExpr, - TypeField, TypeParam, TypeVariant, Variance, + HandlerArm, ImportDecl, ImportMember, ImportSelection, ImportTarget, MapEntry, MatchArm, + ModuleItem, ModuleKind, NamespaceName, Parameter, Pattern, Position, Program, + SignatureAscription, SignatureItem, SignatureType, Stmt, SymbolPath, TypeExpr, TypeField, + TypeParam, TypeVariant, Variance, Visibility, }; use std::cell::RefCell; use std::collections::HashSet; @@ -72,6 +75,13 @@ fn collect_bound_names(items: &[MlItem], out: &mut HashSet) { MlItem::Assign { value, .. } | MlItem::Expr { value, .. } => { collect_names_in_expr(value, out); } + MlItem::Namespace { + body: Some(body), .. + } + | MlItem::Module { body, .. } => collect_bound_names(body, out), + MlItem::Export { item, .. } | MlItem::Opaque { item, .. } => { + collect_bound_names(std::slice::from_ref(item.as_ref()), out); + } _ => {} } } @@ -175,7 +185,7 @@ fn lower_items(items: Vec) -> Vec { MlItem::Doc(text) => { pending_doc = Some(crate::docparse::parse_doc(&text, DocScope::Outer)); } - MlItem::Signature { + MlItem::ValueSignature { name, type_params, ty, @@ -691,6 +701,9 @@ fn lower_expr(expr: MlExpr) -> Expr { MlExpr::Bool(b) => Expr::Bool(b), MlExpr::Str(raw) => lower_string(&raw), MlExpr::Ident(name) => Expr::Identifier(name), + MlExpr::Path(path) => Expr::Path(SymbolPath { + segments: path.segments, + }), MlExpr::Paren(inner) => lower_expr(*inner), MlExpr::Unary { op, operand } => Expr::Unary { op, @@ -925,6 +938,10 @@ fn lower_application(func: MlExpr, arg: MlExpr) -> Expr { args.reverse(); let curried = match &head { MlExpr::Ident(name) => BOUND_NAMES.with(|s| s.borrow().contains(name)), + // A qualified callable's declaration lives outside this source file. + // Preserve ML's curry-by-default application spine; authors explicitly + // select a flat cross-flavor call with `(a, b)` ([FLAVOR-INTEROP]). + MlExpr::Path(_) => true, _ => true, }; if curried { diff --git a/crates/osprey-syntax/src/ml/parser.rs b/crates/osprey-syntax/src/ml/parser.rs index a8bb993e..e5bc56f4 100644 --- a/crates/osprey-syntax/src/ml/parser.rs +++ b/crates/osprey-syntax/src/ml/parser.rs @@ -37,8 +37,9 @@ //! concrete authoritative spec of layout-driven token insertion. use super::cst::{ - MlArm, MlEffectOp, MlEffectRef, MlExpr, MlExternParam, MlField, MlHandleArm, MlItem, MlParam, - MlPattern, MlType, MlTypeField, MlTypeParam, MlVariance, MlVariant, + MlArm, MlEffectOp, MlEffectRef, MlExpr, MlExternParam, MlField, MlHandleArm, MlImport, + MlImportMember, MlImportSelection, MlItem, MlModuleKind, MlNamespaceName, MlParam, MlPattern, + MlSignatureItem, MlSymbolPath, MlType, MlTypeField, MlTypeParam, MlVariance, MlVariant, }; use super::lexer::lex; use super::token::{TokKind, Token}; @@ -57,6 +58,7 @@ pub(crate) fn parse(source: &str) -> (Vec, Vec) { }; parser.program() }; + validate_module_items(&items, None, &mut errors); (items, errors) } @@ -123,6 +125,10 @@ impl Parser<'_> { fn error(&mut self, message: impl Into) { let position = self.pos(); + self.error_at(position, message); + } + + fn error_at(&mut self, position: Position, message: impl Into) { self.errors.push(SyntaxError { message: message.into(), position, @@ -180,6 +186,13 @@ impl Parser<'_> { TokKind::KwType => self.type_decl(), TokKind::KwExtern => self.extern_decl(), TokKind::KwEffect => self.effect_decl(), + TokKind::KwImport => self.import_decl(), + TokKind::KwNamespace => self.namespace_decl(), + TokKind::KwModule => self.module_decl(MlModuleKind::Plain), + TokKind::KwState => self.module_decl(MlModuleKind::State), + TokKind::KwSignature => self.module_signature_decl(), + TokKind::KwExport => self.export_decl(), + TokKind::KwOpaque => self.opaque_decl(), TokKind::Reserved(word) => { let word = word.clone(); self.error(format!( @@ -193,6 +206,350 @@ impl Parser<'_> { } } + /// `import target`, optional whole-target alias, and an optional indented + /// member projection ([MODULES-IMPORT]). ML uses layout instead of Default's + /// punctuation-heavy `::{...}` member list. + fn import_decl(&mut self) -> Option { + let pos = self.pos(); + self.advance(); // `import` + let namespace = self.namespace_name()?; + let path = self.path_tail(); + let alias = if self.eat(&TokKind::KwAs) { + self.ident() + } else { + None + }; + let selection = if self.eat(&TokKind::Indent) { + if alias.is_some() { + self.error("an aliased whole import cannot also select members"); + } + self.import_selection() + } else { + MlImportSelection::Whole + }; + Some(MlItem::Import { + import: MlImport { + namespace, + path, + alias, + selection, + }, + pos, + }) + } + + /// Parse the indented lines below an import. `*` must be the sole line; + /// named members may each carry one `as Alias`. + fn import_selection(&mut self) -> MlImportSelection { + self.skip_separators(); + if matches!(self.peek(), TokKind::Op(op) if op == "*") { + self.advance(); + self.skip_separators(); + if !matches!(self.peek(), TokKind::Dedent | TokKind::Eof) { + self.error("wildcard import '*' must be the only selected member"); + self.recover(); + } + let _ = self.eat(&TokKind::Dedent); + return MlImportSelection::Wildcard; + } + let mut members = Vec::new(); + while !self.at_block_end() { + self.skip_separators(); + if self.at_block_end() { + break; + } + let before = self.i; + if let Some(name) = self.ident() { + let alias = if self.eat(&TokKind::KwAs) { + self.ident() + } else { + None + }; + members.push(MlImportMember { name, alias }); + } else { + self.recover(); + } + if self.i == before { + self.recover(); + } + } + let _ = self.eat(&TokKind::Dedent); + MlImportSelection::Members(members) + } + + /// `namespace name`: an indented body is a block contribution; without one + /// the declaration applies to subsequent declarations in the file + /// ([MODULES-FILE-SCOPED-NAMESPACE]). + fn namespace_decl(&mut self) -> Option { + let pos = self.pos(); + self.advance(); // `namespace` + let name = self.namespace_name()?; + let body = if self.eat(&TokKind::Indent) { + Some(self.items_until_dedent()) + } else { + None + }; + Some(MlItem::Namespace { name, body, pos }) + } + + /// A layout module head. ML deliberately spells a state module `state Name` + /// rather than the redundant `state module Name` ([MODULES-STATE-MODULE]). + fn module_decl(&mut self, kind: MlModuleKind) -> Option { + let pos = self.pos(); + self.advance(); // `module` / `state` + if kind == MlModuleKind::State && matches!(self.peek(), TokKind::KwModule) { + self.error("ML state modules are written 'state Name', without redundant 'module'"); + self.advance(); + } + let path = self.symbol_path()?; + let signature = if self.eat(&TokKind::Colon) { + self.symbol_path() + } else { + None + }; + if !self.eat(&TokKind::Indent) { + self.error("module declaration requires an indented body"); + return Some(MlItem::Module { + path, + kind, + signature, + body: Vec::new(), + pos, + }); + } + let body = self.items_until_dedent(); + Some(MlItem::Module { + path, + kind, + signature, + body, + pos, + }) + } + + /// `signature Name` plus its public, export-free interface requirements. + fn module_signature_decl(&mut self) -> Option { + let pos = self.pos(); + self.advance(); // `signature` + let name = self.ident()?; + if !self.eat(&TokKind::Indent) { + self.error("signature declaration requires an indented body"); + return Some(MlItem::ModuleSignature { + name, + items: Vec::new(), + pos, + }); + } + let items = self.signature_items(); + Some(MlItem::ModuleSignature { name, items, pos }) + } + + fn signature_items(&mut self) -> Vec { + let mut items = Vec::new(); + loop { + self.skip_separators(); + if self.at_block_end() { + break; + } + let before = self.i; + match self.signature_item() { + Some(item) => items.push(item), + None => self.recover(), + } + if self.i == before { + self.recover(); + } + } + let _ = self.eat(&TokKind::Dedent); + items + } + + fn signature_item(&mut self) -> Option { + match self.peek() { + TokKind::Ident(_) => self.signature_value_item(), + TokKind::KwType => self.signature_type_item(), + TokKind::KwEffect => self.signature_effect_item(), + TokKind::KwModule => self.signature_module_item(), + TokKind::KwExport => { + self.error("signature items are public by definition; remove redundant 'export'"); + None + } + TokKind::KwOpaque => { + self.error("write 'type T' for an abstract ML signature type; 'opaque' is redundant"); + None + } + other => { + self.error(format!("unexpected token {other:?} in signature")); + None + } + } + } + + fn signature_value_item(&mut self) -> Option { + let pos = self.pos(); + let name = self.ident()?; + let type_params = self.signature_type_params(); + if !self.eat(&TokKind::Colon) { + self.error("expected ':' in signature value"); + } + let ty = self.ty(); + let effects = self.effect_row(); + Some(MlSignatureItem::Value { + name, + type_params, + ty, + effects, + pos, + }) + } + + fn signature_type_item(&mut self) -> Option { + let pos = self.pos(); + self.advance(); // `type` + let name = self.ident()?; + let manifest = if self.eat(&TokKind::Eq) { + Some(self.ty()) + } else { + None + }; + Some(MlSignatureItem::Type { + name, + manifest, + pos, + }) + } + + fn signature_effect_item(&mut self) -> Option { + let pos = self.pos(); + self.advance(); // `effect` + let name = self.ident()?; + let type_params = self.type_params(); + let operations = self.effect_operations(); + Some(MlSignatureItem::Effect { + name, + type_params, + operations, + pos, + }) + } + + fn signature_module_item(&mut self) -> Option { + let pos = self.pos(); + self.advance(); // `module` + let name = self.ident()?; + if !self.eat(&TokKind::Colon) { + self.error("expected ':' in nested module signature item"); + } + let signature = self.symbol_path()?; + Some(MlSignatureItem::Module { + name, + signature, + pos, + }) + } + + /// Wrap exactly one following declaration in explicit visibility metadata. + fn export_decl(&mut self) -> Option { + let pos = self.pos(); + self.advance(); // `export` + if self.eat(&TokKind::KwExport) { + self.error_at(pos, "duplicate 'export' is redundant"); + } + let item = self.item()?; + if !is_exportable(&item) { + self.error_at(pos, "'export' must modify a value, function, type, effect, extern, or module declaration"); + } + Some(MlItem::Export { + item: Box::new(item), + pos, + }) + } + + fn opaque_decl(&mut self) -> Option { + let pos = self.pos(); + self.advance(); // `opaque` + if !self.eat(&TokKind::KwType) { + self.error("'opaque' may modify only a type declaration"); + return None; + } + let item = self.type_decl_after_keyword(pos)?; + Some(MlItem::Opaque { + item: Box::new(item), + pos, + }) + } + + /// Parse declarations until the matching `Dedent`. Unlike expression block + /// parsing, module/namespace bodies do not reinterpret the final expression + /// as a trailing block value. + fn items_until_dedent(&mut self) -> Vec { + let mut items = Vec::new(); + loop { + self.skip_separators(); + if self.at_block_end() { + break; + } + let before = self.i; + match self.item() { + Some(item) => items.push(item), + None => self.recover(), + } + if self.i == before { + self.recover(); + } + } + let _ = self.eat(&TokKind::Dedent); + items + } + + fn namespace_name(&mut self) -> Option { + match self.peek().clone() { + TokKind::Ident(name) => { + self.advance(); + Some(MlNamespaceName::Ident(name)) + } + TokKind::Str(name) => { + self.advance(); + Some(MlNamespaceName::Quoted(name)) + } + other => { + self.error(format!("expected namespace name, found {other:?}")); + None + } + } + } + + fn symbol_path(&mut self) -> Option { + let first = self.ident()?; + let mut path = MlSymbolPath { + segments: vec![first], + }; + while self.eat(&TokKind::ColonColon) { + if let Some(segment) = self.ident() { + path.segments.push(segment); + } else { + self.error("expected path segment after '::'"); + break; + } + } + Some(path) + } + + /// Continue an import target after its namespace label. The first namespace + /// component is deliberately stored separately from the module path. + fn path_tail(&mut self) -> MlSymbolPath { + let mut segments = Vec::new(); + while self.eat(&TokKind::ColonColon) { + if let Some(segment) = self.ident() { + segments.push(segment); + } else { + self.error("expected import path segment after '::'"); + break; + } + } + MlSymbolPath { segments } + } + /// `mut name = body` → a mutable binding. fn mut_binding(&mut self) -> Option { let pos = self.pos(); @@ -218,6 +575,12 @@ impl Parser<'_> { fn type_decl(&mut self) -> Option { let pos = self.pos(); self.advance(); // `type` + self.type_decl_after_keyword(pos) + } + + /// Finish a type declaration after its `type` token has already been + /// consumed (also reused by `opaque type`). + fn type_decl_after_keyword(&mut self, pos: Position) -> Option { let name = self.ident()?; let type_params = self.type_params(); let _ = self.expect_eq(); @@ -534,6 +897,7 @@ impl Parser<'_> { /// that follows, with an optional trailing effect row `! Ref(, Ref)*` or /// `! [Ref, …]` ([FLAVOR-ML-EFFECT], [FLAVOR-ML-GENERICS]). fn signature(&mut self) -> Option { + let pos = self.pos(); let name = self.ident()?; let type_params = self.signature_type_params(); if !self.eat(&TokKind::Colon) { @@ -541,11 +905,12 @@ impl Parser<'_> { } let ty = self.ty(); let effects = self.effect_row(); - Some(MlItem::Signature { + Some(MlItem::ValueSignature { name, type_params, ty, effects, + pos, }) } @@ -578,7 +943,8 @@ impl Parser<'_> { /// angle-bracketed type arguments. fn effect_ref(&mut self) -> Option { let pos = self.pos(); - let name = self.ident()?; + let first = self.ident()?; + let name = self.qualified_name_tail(first); let args = if self.at_angle_open() { match self.ty_generic_args(name.clone()) { MlType::App { args, .. } => args, @@ -625,6 +991,7 @@ impl Parser<'_> { match self.peek().clone() { TokKind::Ident(name) => { self.advance(); + let name = self.qualified_name_tail(name); if self.at_angle_open() { self.ty_generic_args(name) } else { @@ -1055,6 +1422,19 @@ impl Parser<'_> { /// directly followed by an indented `field = value` block — a record /// literal ([FLAVOR-ML-RECORD]). fn ident_atom(&mut self, name: String) -> MlExpr { + let mut segments = vec![name]; + while self.eat(&TokKind::ColonColon) { + if let Some(segment) = self.ident() { + segments.push(segment); + } else { + self.error("expected path segment after '::'"); + break; + } + } + if segments.len() > 1 { + return MlExpr::Path(MlSymbolPath { segments }); + } + let name = segments.pop().unwrap_or_default(); if is_constructor(&name) && matches!(self.peek(), TokKind::Indent) { let fields = self.record_fields(); MlExpr::Record { @@ -1195,7 +1575,8 @@ impl Parser<'_> { fn perform_expr(&mut self) -> MlExpr { let pos = self.pos(); self.advance(); // `perform` - let effect = self.ident().unwrap_or_default(); + let first = self.ident().unwrap_or_default(); + let effect = self.qualified_name_tail(first); if !self.eat(&TokKind::Dot) { self.error("expected '.' between effect and operation in perform"); } @@ -1228,7 +1609,8 @@ impl Parser<'_> { fn handle_expr(&mut self) -> MlExpr { let pos = self.pos(); self.advance(); // `handle` - let effect = self.ident().unwrap_or_default(); + let first = self.ident().unwrap_or_default(); + let effect = self.qualified_name_tail(first); let mut arms = Vec::new(); if self.eat(&TokKind::Indent) { while !self.at_block_end() { @@ -1469,6 +1851,7 @@ impl Parser<'_> { /// `_` → wildcard; `Ctor a b` → constructor binding payload fields; a bare /// lowercase name → a binding ([FLAVOR-ML-MATCH]). fn ident_pattern(&mut self, name: String) -> MlPattern { + let name = self.qualified_name_tail(name); if name == "_" { return MlPattern::Wildcard; } @@ -1644,6 +2027,22 @@ impl Parser<'_> { } } + /// Consume zero or more `::segment` suffixes after an already-consumed + /// identifier, retaining the written qualification for canonical fields + /// which still store type/effect/constructor names as strings. + fn qualified_name_tail(&mut self, first: String) -> String { + let mut segments = vec![first]; + while self.eat(&TokKind::ColonColon) { + if let Some(segment) = self.ident() { + segments.push(segment); + } else { + self.error("expected path segment after '::'"); + break; + } + } + segments.join("::") + } + fn expect_eq(&mut self) -> bool { if self.eat(&TokKind::Eq) { true @@ -1654,6 +2053,127 @@ impl Parser<'_> { } } +/// Validate declaration-group rules which need sibling context. Keeping this +/// pass over the faithful CST makes the parser routines small while still +/// rejecting redundancy before canonical lowering ([MODULES-EXPORTS]). +fn validate_module_items( + items: &[MlItem], + module_ascribed: Option, + errors: &mut Vec, +) { + for (index, item) in items.iter().enumerate() { + match item { + MlItem::Namespace { + body: Some(body), .. + } => validate_module_items(body, None, errors), + MlItem::Namespace { body: None, .. } => {} + MlItem::Module { + signature, body, .. + } => validate_module_items(body, Some(signature.is_some()), errors), + MlItem::Export { + item: exported, + pos, + } => { + match module_ascribed { + None => push_validation_error( + errors, + *pos, + "namespace declarations are public by default; 'export' is valid only inside an un-ascribed module", + ), + Some(true) => push_validation_error( + errors, + *pos, + "an ascribed module exports exactly its signature; remove redundant 'export'", + ), + Some(false) => {} + } + if matches!(exported.as_ref(), MlItem::Binding { mutable: true, .. }) { + push_validation_error(errors, *pos, "mutable cells cannot be exported"); + } + if let MlItem::ValueSignature { name, .. } = exported.as_ref() { + validate_signature_follower(items, index, name, true, *pos, errors); + } + if let MlItem::Opaque { item, .. } = exported.as_ref() { + if !matches!(item.as_ref(), MlItem::Type { .. }) { + push_validation_error( + errors, + *pos, + "'opaque' may modify only an exported type declaration", + ); + } + } + } + MlItem::Opaque { pos, .. } => push_validation_error( + errors, + *pos, + "an opaque representation requires exactly one 'export opaque type' declaration", + ), + MlItem::ValueSignature { name, pos, .. } => { + validate_signature_follower(items, index, name, false, *pos, errors); + } + _ => {} + } + } +} + +fn validate_signature_follower( + items: &[MlItem], + index: usize, + name: &str, + exported_signature: bool, + pos: Position, + errors: &mut Vec, +) { + let follower = items.get(index.saturating_add(1)); + let matching_bare = matches!( + follower, + Some(MlItem::Binding { + name: following, + .. + }) if following == name + ); + if matching_bare { + return; + } + let matching_exported = matches!( + follower, + Some(MlItem::Export { item, .. }) + if matches!(item.as_ref(), MlItem::Binding { name: following, .. } if following == name) + ); + let message = if exported_signature && matching_exported { + format!( + "'{name}' is already exported by its signature; remove 'export' from the definition" + ) + } else { + format!("signature for '{name}' must be immediately followed by its bare definition") + }; + push_validation_error(errors, pos, message); +} + +fn push_validation_error( + errors: &mut Vec, + position: Position, + message: impl Into, +) { + errors.push(SyntaxError { + message: message.into(), + position, + }); +} + +fn is_exportable(item: &MlItem) -> bool { + matches!( + item, + MlItem::Binding { .. } + | MlItem::ValueSignature { .. } + | MlItem::Type { .. } + | MlItem::Effect { .. } + | MlItem::Extern { .. } + | MlItem::Module { .. } + | MlItem::Opaque { .. } + ) +} + /// An uppercase initial marks a constructor/type name; lowercase marks a value /// binding or variable, mirroring the Default flavor's lexical convention. fn is_constructor(name: &str) -> bool { diff --git a/crates/osprey-syntax/src/ml/token.rs b/crates/osprey-syntax/src/ml/token.rs index 24b9fc83..1f105130 100644 --- a/crates/osprey-syntax/src/ml/token.rs +++ b/crates/osprey-syntax/src/ml/token.rs @@ -67,6 +67,25 @@ pub(crate) enum TokKind { KwRecv, /// `select` — choose among ready channel arms ([FLAVOR-ML-CONCURRENCY]). KwSelect, + /// `import` — introduces a logical namespace/module dependency + /// ([MODULES-IMPORT]). + KwImport, + /// `namespace` — introduces a file- or block-scoped namespace contribution + /// ([MODULES-NAMESPACE]). + KwNamespace, + /// `module` — introduces a plain layout module ([MODULES-MODULE]). + KwModule, + /// `signature` — introduces a named module interface ([MODULES-SIGNATURE]). + KwSignature, + /// `export` — marks one declaration group as public ([MODULES-EXPORTS]). + KwExport, + /// `opaque` — hides an exported type representation ([MODULES-OPAQUE-TYPES]). + KwOpaque, + /// `state` — introduces a state-owning module; ML deliberately omits the + /// redundant second `module` keyword ([MODULES-STATE-MODULE]). + KwState, + /// `as` — introduces an import alias ([MODULES-IMPORT]). + KwAs, /// A reserved word reserved for a not-yet-implemented construct (`handler`, /// `do`). Carries its spelling so the parser can report a precise /// "not yet supported" diagnostic. @@ -77,6 +96,9 @@ pub(crate) enum TokKind { ColonEq, /// `:`. Colon, + /// `::` — namespace/module/symbol qualification; `.` remains value access + /// ([MODULES-IMPORT], [MODULES-ABI]). + ColonColon, /// `->`. Arrow, /// `=>`. @@ -128,6 +150,14 @@ pub(crate) fn keyword_or_ident(text: &str) -> TokKind { "send" => TokKind::KwSend, "recv" => TokKind::KwRecv, "select" => TokKind::KwSelect, + "import" => TokKind::KwImport, + "namespace" => TokKind::KwNamespace, + "module" => TokKind::KwModule, + "signature" => TokKind::KwSignature, + "export" => TokKind::KwExport, + "opaque" => TokKind::KwOpaque, + "state" => TokKind::KwState, + "as" => TokKind::KwAs, "handler" | "do" => TokKind::Reserved(text.to_owned()), _ => TokKind::Ident(text.to_owned()), } diff --git a/docs/specs/0025-ModulesAndNamespaces.md b/docs/specs/0025-ModulesAndNamespaces.md index 94aa1f40..1c5f0eda 100644 --- a/docs/specs/0025-ModulesAndNamespaces.md +++ b/docs/specs/0025-ModulesAndNamespaces.md @@ -13,17 +13,19 @@ it belongs to a project; it does **not** decide the names it exports. > infer semantics from `.osp` vs `.ospml` once lowering has happened. See > [Language Flavors](0023-LanguageFlavors.md). -## Status - -`import` and `module` syntax are parsed today, and module bodies are checked in a -child scope. Cross-file resolution, open namespaces, explicit exports, -signatures, module-owned state rules, and project assembly are planned. This -chapter is the normative contract for those features and supersedes the +## Status `[MODULES-STATUS]` + +The Default frontend currently parses only stub forms of dotted `import` and +`module Name { ... }`; the ML frontend has neither form yet. The stubs do not +resolve imports, expose module members, enforce privacy, or reach codegen. +Cross-file resolution, namespaces, exports, signatures, state ownership, and +project assembly therefore remain planned. This chapter is the normative +contract for that implementation and supersedes the fiber-isolated module sketch in [Fibers and Concurrency](0011-LightweightFibersAndConcurrency.md#fiber-isolated-modules-planned). -## Research Basis +## Research Basis `[MODULES-RESEARCH]` -`[MODULES-RESEARCH]` The design combines .NET-style logical named groups with +The design combines .NET-style logical named groups with ML-style abstraction boundaries and Osprey's algebraic effects. It deliberately does **not** adopt the usual .NET `Company.Product.Feature` hierarchy as an Osprey norm. @@ -78,9 +80,9 @@ These are not ornamental citations. They drive the rules below: names are logical, interfaces are explicit, abstract state does not leak, and mutable state has one owner. -## Comparative Practice +## Comparative Practice `[MODULES-COMPARATIVE-PRACTICE]` -`[MODULES-COMPARATIVE-PRACTICE]` The survey above yields concrete rules: +The survey above yields concrete rules: - **Use namespaces for logical grouping, not architecture.** .NET/F# names are a useful precedent for path-independent grouping, but Osprey does not copy the @@ -104,9 +106,9 @@ has one owner. Osprey may use similar labels for published libraries later, but app code should usually stay flat. -## Design Goals +## Design Goals `[MODULES-GOALS]` -`[MODULES-GOALS]` The module system must make the good structure the easy +The module system must make the good structure the easy structure: - **Path-independent names.** A namespace label comes from source text, not from @@ -121,22 +123,27 @@ structure: the default. - **Separate compilation by interface.** A file can be checked against imported signatures without loading every implementation detail. -- **State has a declared owner.** Top-level mutable state is forbidden outside a - state module or handler-owned state region. -- **Pure logic stays pure.** Modules expose state through effect-typed operations - or pure query/update functions, not exported cells. +- **State has a declared owner.** Namespace and plain-module mutable state is + forbidden. A state module may declare private cells, but only its algebraic- + effect handler arms may read or write them. +- **Pure logic stays pure.** State crosses a module boundary only through effect + operations. Ordinary functions may transform explicit values, but may not + inspect or mutate module-owned cells. - **Cross-flavor interop.** A `.osp` module and `.ospml` module import each other through canonical signatures. -## Canonical Project Model +## Canonical Project Model `[MODULES-MODEL]` -`[MODULES-MODEL]` The module system is a project graph. Concrete syntax is only +The module system is a project graph. Concrete syntax is only how each flavor contributes nodes and edges to that graph. The shared model contains: -- `SourceFile { path, flavor, namespace }` - a parsed file with one active - flavor and one namespace label, explicit or project-defaulted. +- `SourceFile { path, flavor, contributions }` - a parsed file with one active + flavor and one or more namespace contributions. Unscoped declarations + contribute to the project's default namespace. +- `NamespaceContribution { namespace, items, span }` - one file-scoped, + block-scoped, or project-defaulted contribution. - `Namespace { label, contributions }` - an open logical grouping of declarations from any number of files. - `Module { namespace, path, kind, exports, private_items, signature }` - a @@ -145,8 +152,8 @@ The shared model contains: - `ImportEdge { from_file, target, alias, imported_members }` - a dependency on a namespace/module/member surface, never on a physical file. - `SymbolId { namespace, path }` - the stable identity for exported declarations. -- `StateOwner { module, cells, access_paths }` - the single owner of private - durable state in a `state module`. +- `StateOwner { module, cells, installers }` - private cell declarations plus + the handler installers allowed to instantiate and access them. Every later phase consumes this model, not surface syntax: @@ -165,31 +172,39 @@ or named arguments. Those are flavor concerns described in [Syntax](0003-Syntax.md), [Language Flavors](0023-LanguageFlavors.md), and [ML Flavor Syntax](0024-MLFlavorSyntax.md). -## Surface Projection +## Surface Projection `[MODULES-FLAVOR-PROJECTION]` -`[MODULES-FLAVOR-PROJECTION]` Each flavor projects the same model into its own +Each flavor projects the same model into its own surface. The examples in this chapter are illustrative; the model above is the normative layer. | Concept | Shared model | Default flavor | ML flavor | | --- | --- | --- | --- | -| Namespace contribution | `Namespace { label }` | `namespace billing { ... }` or `namespace billing;` | `namespace billing` followed by layout declarations | +| Namespace contribution | `Namespace { label }` | `namespace billing { ... }` or `namespace billing;` | file-scoped `namespace billing`, or an indented block | | Module boundary | `Module { path, exports, private_items }` | `module Tax { ... }` | `module Tax` + indented body | -| State module | `Module { kind: state }` | `state module Store { ... }` | `state module Store` + indented body | -| Import edge | `ImportEdge` | `import billing::Tax::{addTax}` | same path form; calls use ML application | +| State module | `Module { kind: state }` | `state module Store { ... }` | `state Store` + indented body | +| Import edge | `ImportEdge` | `import billing::Tax::{addTax}` | `import billing::Tax` + indented member names | | Signature | `Signature { items }` | `signature StoreSig { ... }` | `signature StoreSig` + indented items | -| Export | exported item metadata | `export fn f(...) = ...` | `export f : ...` / `export f x = ...` | +| Export | exported item metadata | explicit `export fn f(...)` when unascribed | one `export` on a signature or inferred binding when unascribed; an ascribed module uses its signature | | Symbol path | `SymbolId { namespace, path }` | `billing::Tax::addTax` | same path; application remains whitespace | -## Namespaces +Default deliberately keeps braces, parentheses, explicit `fn`, named arguments, +and visible export markers: a C, C#, Java, Kotlin, or Dart programmer can read +the boundary without learning layout rules. ML deliberately removes structural +punctuation that layout and signatures already express. These are surface +choices only; both lower to the same graph. + +## Namespaces `[MODULES-NAMESPACE]` -`[MODULES-NAMESPACE]` A `namespace` declaration contributes declarations to an +A `namespace` declaration contributes declarations to an open logical namespace. Multiple files may contribute to the same namespace. Namespace labels are opaque. `billing`, `"billing/api"`, and `"ui/forms"` are three unrelated labels; no parent namespace is implied. ```ebnf -namespaceDecl ::= "namespace" namespaceName ("{" statement* "}" | ";") +defaultNamespaceDecl ::= "namespace" namespaceName ("{" statement* "}" | ";") +mlNamespaceDecl ::= "namespace" namespaceName + (NEWLINE INDENT statement+ DEDENT | NEWLINE) namespaceName ::= IDENT | STRING symbolPath ::= IDENT ("::" IDENT)* ``` @@ -237,7 +252,9 @@ namespace "billing/api"; The slash is part of the label. It does not create a `billing` parent namespace. -`[MODULES-FILE-SCOPED-NAMESPACE]` A file-scoped namespace declaration applies to +### File-scoped Namespaces `[MODULES-FILE-SCOPED-NAMESPACE]` + +A file-scoped namespace declaration applies to all declarations after it in the file: Default flavor: @@ -267,15 +284,22 @@ emptyInvoice id = ``` A file may contain either one file-scoped namespace declaration or any number of -block-scoped namespace declarations, not both. +block-scoped namespace declarations, not both. In ML, an indented body is a +block-scoped contribution; declarations at the namespace line's indentation make +the declaration file-scoped. Layout makes the distinction without braces or a +terminator. -`[MODULES-PATH-INDEPENDENCE]` The physical file path is never part of the +### Path Independence `[MODULES-PATH-INDEPENDENCE]` + +The physical file path is never part of the namespace identity. A file `src/weird/place/x.osp` may declare `namespace billing;` or `namespace "billing/api";`. The compiler may warn when path and namespace drift from project convention, but it must not change symbol identity or import resolution. -`[MODULES-NAMESPACE-STYLE]` Namespace style is flexible but flat-first: +### Namespace Style `[MODULES-NAMESPACE-STYLE]` + +Namespace style is flexible but flat-first: - Prefer one short lowercase label for app namespaces: `app`, `billing`, `ui`, `worker`. @@ -288,20 +312,27 @@ resolution. - Never mirror folders by default. If a team chooses folder-like slash labels, the label remains opaque and path-independent. -## Modules +## Modules `[MODULES-MODULE]` -`[MODULES-MODULE]` A `module` is a closed implementation boundary inside a -namespace. It may contain values, functions, types, effects, nested modules, and -private mutable state. It exports only declarations marked `export` or listed by -its signature. +A `module` is a closed, stateless implementation boundary inside a namespace. +It may contain immutable values, functions, types, effects, and nested plain +modules. A direct `mut` declaration is forbidden; ordinary local `mut` bindings +inside its functions and blocks retain their normal lexical semantics. An +unascribed module exports only declarations marked `export`; an ascribed module's +signature is its complete public surface. ```ebnf -moduleDecl ::= plainModuleDecl | stateModuleDecl -plainModuleDecl ::= "module" symbolPath signatureAscription? "{" moduleItem* "}" -stateModuleDecl ::= "state" "module" symbolPath signatureAscription? "{" moduleItem* "}" -signatureAscription ::= ":" symbolPath -moduleItem ::= exportDecl | statement -exportDecl ::= "export" statement +defaultModuleDecl ::= "module" symbolPath signatureAscription? + "{" defaultModuleItem* "}" +defaultStateDecl ::= "state" "module" symbolPath signatureAscription? + "{" defaultModuleItem* "}" +defaultModuleItem ::= "export"? statement +mlModuleDecl ::= "module" symbolPath signatureAscription? + NEWLINE INDENT mlModuleItem+ DEDENT +mlStateDecl ::= "state" symbolPath signatureAscription? + NEWLINE INDENT mlModuleItem+ DEDENT +mlModuleItem ::= "export"? statement +signatureAscription ::= ":" symbolPath ("+" "extra")? ``` Default flavor: @@ -326,27 +357,34 @@ module Tax defaultRate = 10 export addTax : int -> int - export addTax cents = + addTax cents = cents + cents * defaultRate / 100 ``` -`Tax.defaultRate` is private. `Tax.addTax` is exported. +`Tax::defaultRate` is private. `Tax::addTax` is exported. The `::` separator is +reserved for namespace/module paths; `.` remains value field/member access. -`[MODULES-NAMESPACE-VS-MODULE]` Namespaces are open and stateless. Modules are -closed and may own private implementation details. A namespace cannot be used as -a runtime value; a module can be referenced as a named declaration space and, -when it is a `state module`, has a runtime state owner. +### Namespaces Versus Modules `[MODULES-NAMESPACE-VS-MODULE]` -## Imports +Namespaces are open and stateless. Plain modules are closed and stateless. A +namespace cannot be used as a runtime value; a module is a named declaration +space. Only a state module declares an owner template for durable state, and that +state exists only inside an explicitly installed handler region. -`[MODULES-IMPORT]` Imports name namespaces or modules, not files. +## Imports `[MODULES-IMPORT]` + +Imports name namespaces or modules, not files. Default uses a compact braced +member list; ML uses an indented list with no braces or commas. ```ebnf -importStmt ::= "import" importTarget importTail? +defaultImportStmt ::= "import" importTarget defaultImportTail? +defaultImportTail ::= "as" IDENT + | "::" "{" importMember ("," importMember)* "}" + | "::" "*" +mlImportStmt ::= "import" importTarget + ("as" IDENT | "::" "*" + | NEWLINE INDENT importMember (NEWLINE importMember)* DEDENT)? importTarget ::= namespaceName ("::" symbolPath)? -importTail ::= "as" IDENT - | "::" "{" importMember ("," importMember)* "}" - | "::" "*" importMember ::= IDENT ("as" IDENT)? ``` @@ -366,7 +404,8 @@ ML flavor: ```osprey-ml import billing::Tax -import billing::Tax::{addTax} +import billing::Tax + addTax import billing::Tax as Tax import "billing/api" as billingApi @@ -382,8 +421,8 @@ Resolution rules: `import "billing/api" as billingApi`, then `billingApi::Tax::addTax(100)`. - `import billing::Tax` brings the exported module `Tax` into the local scope as `Tax`. -- `import billing::Tax::{x, y}` brings only listed exported members into local - scope. +- Default `import billing::Tax::{x, y}` and the equivalent ML indented member + list bring only the listed exports into local scope. - `import billing::Tax as Alias` brings `Alias` into local scope. - `import billing::Tax::*` is allowed only in examples, scripts, and tests unless the project enables `allow_wildcard_imports = true`; it is forbidden for state @@ -394,11 +433,13 @@ Resolution rules: Imports do not execute code, allocate module state, or load files by relative path. -## Exports And Visibility +## Exports And Visibility `[MODULES-EXPORTS]` -`[MODULES-EXPORTS]` Declarations are private by default inside modules and +Declarations are private by default inside modules and public by default inside namespaces. A module controls its public surface through -`export` or a signature. +`export` or a signature. In an ascribed module the signature already names every +export; ML therefore rejects redundant `export` markers there. Default may +repeat them as an explicit readability aid, but they cannot widen the signature. Default flavor: @@ -422,11 +463,13 @@ module Parser Expr | Stmt export parse : string -> Result - export parse source = + parse source = ... ``` -`[MODULES-OPAQUE-TYPES]` A module may export an opaque type, hiding its +### Opaque Types `[MODULES-OPAQUE-TYPES]` + +A module may export an opaque type, hiding its representation: Default flavor: @@ -447,11 +490,11 @@ module UserIds export opaque type UserId = int export parseUserId : string -> Result - export parseUserId raw = + parseUserId raw = ... export showUserId : UserId -> string - export showUserId id = + showUserId id = ... ``` @@ -459,14 +502,32 @@ Outside `UserIds`, `UserId` is distinct from `int`. Inside `UserIds`, the manifest representation is available. This is the Osprey form of ML abstract types and Leroy-style manifest types. -## Signatures +## Signatures `[MODULES-SIGNATURE]` -`[MODULES-SIGNATURE]` A `signature` is an explicit interface for a module. It +A `signature` is an explicit interface for a module. It lists the names, types, effects, and opacity visible to clients. ```ebnf -signatureDecl ::= "signature" IDENT "{" signatureItem* "}" -signatureItem ::= typeSpec | effectSpec | fnSpec | moduleSpec +defaultSignatureDecl ::= "signature" IDENT "{" signatureItem* "}" +mlSignatureDecl ::= "signature" IDENT NEWLINE + INDENT signatureItem+ DEDENT +signatureItem ::= abstractTypeSpec | manifestTypeSpec | valueSpec + | effectSpec | moduleSpec +abstractTypeSpec ::= "opaque" "type" IDENT /* Default */ + | "type" IDENT /* ML */ +manifestTypeSpec ::= "type" IDENT "=" typeExpr +valueSpec ::= "fn" IDENT typeParams? "(" signatureParams? ")" + ("->" typeExpr)? effectRow? /* Default */ + | IDENT ":" mlType effectRow? /* ML */ +effectSpec ::= "effect" IDENT effectSignatureBody +moduleSpec ::= "module" IDENT ":" symbolPath +signatureParams ::= signatureParam ("," signatureParam)* +signatureParam ::= IDENT ":" typeExpr +effectSignatureBody ::= "{" effectOperationSpec* "}" + | NEWLINE INDENT effectOperationSpec+ DEDENT +effectOperationSpec ::= IDENT ":" typeExpr /* Default fn type */ + | IDENT ":" mlType "=>" mlType +signatureAscription ::= ":" symbolPath ("+" "extra")? ``` Default flavor: @@ -482,7 +543,7 @@ signature StoreSig { } module MemoryStore : StoreSig { - export opaque type Store = { values: [string] } + export type Store = { values: [string] } export effect StoreFx { load : fn() -> Store save : fn(Store) -> Unit @@ -495,44 +556,53 @@ ML flavor: ```osprey-ml signature StoreSig - opaque type Store + type Store effect StoreFx load : Unit => Store save : Store => Unit empty : Unit -> Store module MemoryStore : StoreSig - export opaque type Store = + type Store = Store values : [string] - export effect StoreFx + effect StoreFx load : Unit => Store save : Store => Unit - export empty : Unit -> Store - export empty () = + empty : Unit -> Store + empty () = Store values = [] ``` +In an ML signature, bare `type Store` is abstract; repeating `opaque` would add +no information. The implementation supplies its representation, but clients see +only the abstract identity. The ascription already supplies the export list, so +the ML implementation repeats neither `export` nor signature punctuation. + Signature conformance is checked structurally: -- Every signature item must have a matching exported declaration. +- Every signature item must have a matching implementation declaration; the + ascription exports it. - Types must match after applying opacity rules. - Effect operations must match names, parameter types, return types, and effect rows. - Extra private declarations are allowed. -- Extra exported declarations are rejected unless the ascription is marked - `: StoreSig + extra`. +- Other implementation declarations stay private. `: StoreSig + extra` opts + into additionally exporting declarations explicitly marked `export`; without + `+ extra`, such extra exports are rejected. -`[MODULES-SEPARATE-CHECKING]` A compiler may type-check an importing file using +### Separate Checking `[MODULES-SEPARATE-CHECKING]` + +A compiler may type-check an importing file using only the imported module's signature. The implementation body is needed only when compiling that module or linking the final project. -## Parameterised Modules +## Parameterised Modules `[MODULES-FUNCTOR]` -`[MODULES-FUNCTOR]` A parameterised module is a module-level function from +A parameterised module is a module-level function from signatures to modules. This is planned after basic signatures. ```osprey @@ -545,30 +615,47 @@ module MakeRepo(Db: DatabaseSig, Clock: ClockSig) : RepoSig { Parameterised modules are the dependency-injection mechanism for reusable libraries. They are preferred over ambient globals. -## State Ownership +## State Ownership `[MODULES-STATE]` -`[MODULES-STATE]` Mutable state may appear only in three places: +Local mutation is unchanged: `mut` inside an ordinary function or block is a +lexical local and may be read or written by that scope. Durable module-owned +state is different. It may be declared only in a state module and may be +observed or changed only by that module's owning algebraic-effect handler arms +([EFFECTS-HANDLER-STATE](0017-AlgebraicEffects.md#handler-owned-state)). -- inside a function or block as an ordinary local `mut`; -- inside an algebraic-effect handler's owned state region - ([EFFECTS-HANDLER-STATE](0017-AlgebraicEffects.md#handler-owned-state)); -- inside a `state module`. +### Forbidden Top-level State `[MODULES-STATE-TOPLEVEL]` -Namespace-level `mut` is a compile-time error. +A direct `mut` in a namespace or plain module is a compile-time error: ```osprey namespace badState; mut count = 0 -// error [MODULES-STATE-TOPLEVEL]: -// mutable state must live in a function, handler, or state module +// error: mutable state must be local or owned by a state-module handler ``` -`[MODULES-STATE-MODULE]` A `state module` is the declared owner of durable -module state. All state cells are private, and no `mut` cell may be exported. +### State Modules `[MODULES-STATE-MODULE]` + +A state module declares private cell templates, exported effects, and one or +more handler installer functions. A cell declaration establishes its initial +value; every subsequent read or write of that cell must occur lexically inside +an operation arm of a `handle Effect ... in body` expression defined by the same +state module. The installer function itself may install that handler and invoke +the supplied body, but its ordinary code before and after the arms cannot touch +the cells. + +Default flavor keeps the complete boundary explicit: ```osprey -state module Counter { +signature CounterSig { + effect CounterFx { + next : fn() -> int + read : fn() -> int + } + fn run(action: fn() -> Unit) -> Unit +} + +state module Counter : CounterSig { mut count = 0 export effect CounterFx { @@ -576,55 +663,90 @@ state module Counter { read : fn() -> int } - export let counterHandler = handler CounterFx { - next => { - count = count + 1 - count - } - read => count - } + export fn run(action: fn() -> Unit) -> Unit = + handle CounterFx + next => { + count = count + 1 + count + } + read => count + in action() } ``` -Clients perform the effect; the module owns the cell: +The ML projection removes the redundant module keyword, braces, and exports +already supplied by the signature: + +```osprey-ml +signature CounterSig + effect CounterFx + next : Unit => int + read : Unit => int + run : (Unit -> Unit) -> Unit + +state Counter : CounterSig + mut count = 0 + + effect CounterFx + next : Unit => int + read : Unit => int + + run : (Unit -> Unit) -> Unit + run action = + handle CounterFx + next () => + count := count + 1 + count + read () => count + in action () +``` + +Clients import declarations, then explicitly invoke the installer around code +that performs the effect: ```osprey -import Counter::{CounterFx, counterHandler} +import app::Counter::{CounterFx, run} -fn allocate() -> int !CounterFx = - perform CounterFx.next() +fn allocate() -> int !CounterFx = perform CounterFx.next() -handle counterHandler in { +run(action: fn() => { print(toString(allocate())) -} +}) ``` +Each call to `run` instantiates a fresh `count` cell for that handler region. +Merely importing `Counter`, `CounterFx`, or `run` allocates nothing. First-class +handler values and reusable `install` syntax are a later ergonomic layer (plan +0016); the initial module implementation uses the existing fused +`handle Effect ... in body` form. + Rules: -- `state module` cells are private by construction. -- Exporting a `mut`, a pointer to a `mut`, or a closure that directly exposes - assignment is a compile-time error. -- A `state module` must export at least one handler, effect, or function that is - the declared access path. -- A namespace may contain at most one unannotated `state module`. Additional - state owners require `@state_boundary("reason")` and are reported by LSP and - docs tooling as architecture-visible state boundaries. -- Derived state should be expressed as pure functions over owner state. Cached - derived state is forbidden in Phase 1; a later `cache mut` feature must name - the owner state it derives from, so invalidation can be checked. +- State-module cells are private by construction. `export mut` is always an + error, as is exporting a pointer, reference, or closure that exposes a cell. +- An ordinary function, exported or private, cannot read or write a module cell. + Pure helpers remain legal when all state arrives through explicit parameters. +- A state module must export its effect surface and at least one installer that + establishes the owning handler region. +- A namespace may contain at most one unannotated state module. Additional state + owners require `@state_boundary("reason")` and are reported by LSP and docs + tooling as architecture-visible boundaries. +- Cached derived cells are forbidden in Phase 1. Derived values are computed in + handler arms or by pure helpers over explicit values. -`[MODULES-STATE-SOURCE-OF-TRUTH]` The compiler and tooling treat each state -module as a **single source of truth** for the state it owns. Cross-module writes -are impossible. Cross-module reads happen through exported pure queries or -effect operations. This is the language-level answer to scattered app state. +### Single Source of Truth `[MODULES-STATE-SOURCE-OF-TRUTH]` -## Effects And Capabilities +The compiler and tooling treat each state module as the single source of truth +for its cells. Cross-module reads and writes are both mediated by exported effect +operations; direct cell references cannot cross the boundary. -`[MODULES-EFFECTS]` Modules do not hide effects. Exported functions and handlers -carry ordinary Osprey effect rows. Importing a module never grants ambient -permission; a caller must still handle or forward every effect. +## Effects And Capabilities `[MODULES-EFFECTS]` -State modules are encouraged to expose capabilities as algebraic effects: +Modules do not hide effects. Exported functions carry ordinary Osprey effect +rows. Importing a module never grants ambient permission; a caller must still +handle or forward every effect. + +State modules expose their state capability as algebraic effects: ```osprey signature LedgerSig { @@ -638,37 +760,52 @@ signature LedgerSig { This keeps application logic pure except for explicit `!Ledger`, while the module decides whether state is in memory, SQLite, HTTP, or a test fake. -## Initialisation +## Initialisation `[MODULES-INIT]` -`[MODULES-INIT]` Imports have no runtime effect. Module initialization is explicit. +Imports have no runtime effect. Module initialization is explicit. - Pure `let` declarations may be evaluated at compile time or lowered as constants. -- Effectful setup must live in an exported `init` function or handler factory. -- `state module` initial state is allocated only when its handler or instance is - explicitly constructed. +- Effectful setup for a plain module must live in an exported function. +- A state module's cell initializers run only when an installer creates its + handler region; each installation receives fresh cells. - Cyclic initialization between state modules is a compile-time error. ```osprey state module DbStore { mut conn = None - export fn init(path: string) -> Unit !Database = - conn = Some(perform Database.open(path)) + export effect DbStoreFx { + connect : fn(string) -> Unit + } + + export fn run(path: string, action: fn() -> Unit) -> Unit = + handle DbStoreFx + connect requestedPath => { + conn = Some(perform Database.open(requestedPath)) + } + in { + perform DbStoreFx.connect(path) + action() + } } ``` -## Project Assembly +Here the exported installer never accesses `conn` directly; only its `connect` +handler arm does. + +## Project Assembly `[MODULES-PROJECT]` -`[MODULES-PROJECT]` A project compile scans configured source roots, parses every +A project compile scans configured source roots, parses every `.osp` and `.ospml` file, resolves each file's flavor, and builds one project namespace graph. ```toml [project] name = "billing" -source_roots = ["src", "tests"] +source_roots = ["src"] default_namespace = "billing" +entry = "src/main.osp" [modules] allow_wildcard_imports = false @@ -683,14 +820,18 @@ Single-file mode remains valid for scripts and examples. Project mode adds: - duplicate-name and ambiguity diagnostics; - one entry point. -`[MODULES-ENTRYPOINT]` In project mode, executable top-level statements are +### Entry Point `[MODULES-ENTRYPOINT]` + +In project mode, executable top-level statements are allowed only in the designated entry file or in `fn main()`. Library files must contain declarations only. This avoids hidden initialization order and makes -multi-file apps deterministic. +multi-file apps deterministic. `entry` is relative to the manifest and must name +a file under one source root. Test source roots belong to a separate test +configuration; a normal build does not silently compile them. -## Cycles +## Cycles `[MODULES-CYCLES]` -`[MODULES-CYCLES]` Namespace declarations may be mutually visible after merging, +Namespace declarations may be mutually visible after merging, but module implementation cycles are restricted. - Pure type/function cycles are allowed only when ordinary Osprey recursion rules @@ -703,9 +844,9 @@ but module implementation cycles are restricted. Recursive modules are a later feature and must require explicit signatures, as in the ML literature. -## Name Mangling And ABI +## Name Mangling And ABI `[MODULES-ABI]` -`[MODULES-ABI]` Canonical symbol names include the namespace label and `::` path: +Canonical symbol names include the namespace label and `::` path: ```text billing::Tax::addTax @@ -718,9 +859,9 @@ stack traces use source-level names. Cross-flavor exports use the same ABI rules as [Cross-Flavor Interop](0023-LanguageFlavors.md#cross-flavor-interop). -## Diagnostics +## Diagnostics `[MODULES-DIAG]` -`[MODULES-DIAG]` Module diagnostics must be architecture-facing: +Module diagnostics must be architecture-facing: - unknown import: show candidate namespaces from the project graph; - ambiguous import: show all providers and suggest aliases; @@ -730,9 +871,9 @@ Cross-flavor exports use the same ABI rules as - top-level mutable state: suggest `state module` or handler-owned state; - path drift: warn, never change semantics. -## Examples +## Examples `[MODULES-EXAMPLES]` -### Multi-file, Path-Independent Namespace +### Multi-file, Path-Independent Namespace `[MODULES-EXAMPLE-MULTIFILE]` `src/a.osp`: @@ -769,7 +910,7 @@ import "app/http" as httpApp let root = httpApp::route() ``` -### Centralised State +### Centralised State `[MODULES-EXAMPLE-STATE]` ```osprey namespace app; @@ -782,17 +923,20 @@ state module SessionStore { count : fn() -> int } - export let liveSessions = handler Sessions { - add id => { sessions = listAppend(sessions, id) } - count => listLength(sessions) - } + export fn run(action: fn() -> Unit) -> Unit = + handle Sessions + add id => { sessions = listAppend(sessions, id) } + count => listLength(sessions) + in action() } fn login(id: string) -> Unit !Sessions = perform Sessions.add(id) ``` -Application code cannot mutate `sessions`. It can only perform `Sessions`. +Application code invokes `SessionStore::run` around a body that performs +`Sessions`. It cannot access `sessions`, and importing the module creates no +session store. ## References diff --git a/tree-sitter-osprey/grammar.js b/tree-sitter-osprey/grammar.js index 5d394212..46589c66 100644 --- a/tree-sitter-osprey/grammar.js +++ b/tree-sitter-osprey/grammar.js @@ -65,6 +65,14 @@ module.exports = grammar({ // `Name [` / `Name <` — array/generic type vs a bare type identifier. [$.array_type, $.type_identifier], [$.generic_type, $.type_identifier], + // A single bare identifier remains an identifier; qualified paths require + // at least one `::`, so these only overlap while the lexer has not yet seen + // the separator. + [$.qualified_path, $.primary_expression], + // `type Alias = Name` is intentionally kept as the historical one-variant + // union spelling. Unambiguous function/generic/array aliases use type_alias; + // opaque aliases are disambiguated by their module-item prefix. + [$.union_type, $.type_alias], ], rules: { @@ -74,6 +82,7 @@ module.exports = grammar({ statement: ($) => choice( $.import_statement, + $.namespace_declaration, $.let_declaration, $.assignment, $.function_declaration, @@ -81,11 +90,60 @@ module.exports = grammar({ $.type_declaration, $.effect_declaration, $.module_declaration, + $.signature_declaration, $.expression_statement, ), import_statement: ($) => - seq('import', sep1('.', $.identifier)), + seq( + 'import', + choice( + // Compatibility with the original Default spelling. It lowers to + // the same namespace + SymbolPath model as `::` imports. + field('legacy_target', $.legacy_import_path), + seq( + field('target', $.import_target), + optional(field('tail', $.import_tail)), + ), + ), + ), + + legacy_import_path: ($) => + seq($.identifier, repeat1(seq('.', $.identifier))), + + import_target: ($) => + prec.right( + seq( + field('namespace', $.namespace_name), + repeat(seq('::', field('segment', $.identifier))), + ), + ), + + import_tail: ($) => + choice( + seq('as', field('alias', $.identifier)), + seq('::', '{', optional($.import_member_list), '}'), + seq('::', '*'), + ), + + import_member_list: ($) => sep1(',', $.import_member), + import_member: ($) => + seq( + field('name', $.identifier), + optional(seq('as', field('alias', $.identifier))), + ), + + namespace_name: ($) => choice($.identifier, $.string), + + namespace_declaration: ($) => + seq( + optional($.doc_comment), + 'namespace', + field('name', $.namespace_name), + choice(';', field('body', $.namespace_body)), + ), + + namespace_body: ($) => seq('{', repeat($.statement), '}'), // ---------- DECLARATIONS ---------- let_declaration: ($) => @@ -146,7 +204,7 @@ module.exports = grammar({ field('name', $.identifier), optional(seq('<', field('type_parameters', $.type_parameter_list), '>')), '=', - field('definition', choice($.union_type, $.record_type)), + field('definition', choice($.record_type, $.union_type, $.type_alias)), optional($.type_validation), ), @@ -159,8 +217,9 @@ module.exports = grammar({ seq(optional(field('variance', choice('in', 'out'))), field('name', $.identifier)), union_type: ($) => prec.right(sep1('|', $.variant)), + type_alias: ($) => prec.dynamic(-1, $._type), variant: ($) => - prec.right(seq(field('name', $.identifier), optional(seq('{', $.field_declarations, '}')))), + prec.right(1, seq(field('name', choice($.qualified_path, $.identifier)), optional(seq('{', $.field_declarations, '}')))), record_type: ($) => seq('{', $.field_declarations, '}'), @@ -199,7 +258,7 @@ module.exports = grammar({ seq('!', '[', $.effect_list, ']'), ), effect_list: ($) => sep1(',', $.effect_ref), - effect_ref: ($) => seq(field('name', $.identifier), optional($.type_arguments)), + effect_ref: ($) => seq(field('name', choice($.qualified_path, $.identifier)), optional($.type_arguments)), // ---------- TYPES ---------- _type: ($) => @@ -216,9 +275,9 @@ module.exports = grammar({ seq('fn', '(', optional($.type_list), ')', '->', $._type), ), generic_type: ($) => - seq(field('name', $.identifier), '<', $.type_list, '>'), - array_type: ($) => seq(field('name', $.identifier), '[', $._type, ']'), - type_identifier: ($) => $.identifier, + seq(field('name', choice($.qualified_path, $.identifier)), '<', $.type_list, '>'), + array_type: ($) => seq(field('name', choice($.qualified_path, $.identifier)), '[', $._type, ']'), + type_identifier: ($) => choice($.qualified_path, $.identifier), type_list: ($) => sep1(',', $._type), // ---------- EXPRESSIONS ---------- @@ -271,7 +330,7 @@ module.exports = grammar({ ), handler_expression: ($) => - prec.right(seq('handle', field('effect', $.identifier), repeat1($.handler_arm), 'in', field('body', $.expression))), + prec.right(seq('handle', field('effect', choice($.qualified_path, $.identifier)), repeat1($.handler_arm), 'in', field('body', $.expression))), handler_arm: ($) => seq(field('operation', $.identifier), optional($.handler_params), '=>', field('body', $.expression)), handler_params: ($) => repeat1($.identifier), @@ -361,6 +420,7 @@ module.exports = grammar({ $.object_literal, $.literal, $.lambda_expression, + $.qualified_path, $.identifier, seq('(', $.expression, ')'), ), @@ -371,7 +431,7 @@ module.exports = grammar({ send_call: ($) => seq('send', '(', $.expression, ',', $.expression, ')'), recv_call: ($) => seq('recv', '(', $.expression, ')'), perform_expression: ($) => - seq('perform', field('effect', $.identifier), '.', field('operation', $.identifier), '(', optional($.argument_list), ')'), + seq('perform', field('effect', choice($.qualified_path, $.identifier)), '.', field('operation', $.identifier), '(', optional($.argument_list), ')'), // `resume(v)` resumes the performer's delimited continuation with `v`; // `resume()` resumes with Unit. Only legal inside a handler arm body. // Implements [EFFECTS-RESUME]. @@ -379,7 +439,7 @@ module.exports = grammar({ seq('resume', '(', field('value', optional($.expression)), ')'), type_constructor: ($) => - prec.dynamic(1, seq(field('name', $.identifier), optional($.type_arguments), '{', $.field_assignments, '}')), + prec.dynamic(1, seq(field('name', choice($.qualified_path, $.identifier)), optional($.type_arguments), '{', $.field_assignments, '}')), type_arguments: ($) => seq('<', $.type_list, '>'), update_expression: ($) => @@ -418,8 +478,8 @@ module.exports = grammar({ $.integer, $.float, $.string, $.interpolated_string, $.boolean, // 0, 1.5, "x", true prec.right(seq(field('operator', choice('-', '+')), choice($.integer, $.float))), // -1, +42 $.list_pattern, // [], [x], [a, b], [head, ...tail] - seq(field('name', $.identifier), '{', $.field_pattern, '}'), // Ok { value } - seq(field('name', $.identifier), '(', sep1(',', $.pattern), ')'), // Some(x) + seq(field('name', choice($.qualified_path, $.identifier)), '{', $.field_pattern, '}'), // Ok { value } + seq(field('name', choice($.qualified_path, $.identifier)), '(', sep1(',', $.pattern), ')'), // Some(x) seq(field('name', $.identifier), ':', '{', $.field_pattern, '}'), // p: { x, y } seq(field('name', $.identifier), ':', field('type', $._type)), // value: Int seq(field('name', $.identifier), optional(field('binding', $.identifier))), // bare var / capture @@ -444,9 +504,104 @@ module.exports = grammar({ // ---------- MODULES ---------- module_declaration: ($) => - seq(optional($.doc_comment), 'module', field('name', $.identifier), '{', repeat($.module_statement), '}'), - module_statement: ($) => - choice($.let_declaration, $.function_declaration, $.type_declaration), + seq( + optional($.doc_comment), + optional(field('state', 'state')), + 'module', + field('path', $.symbol_path), + optional(field('signature', $.signature_ascription)), + '{', + repeat($.module_item), + '}', + ), + + signature_ascription: ($) => + seq( + ':', + field('path', $.symbol_path), + optional(seq('+', field('extra', 'extra'))), + ), + + module_item: ($) => + choice($.export_declaration, $._module_declaration), + + export_declaration: ($) => + seq( + optional($.doc_comment), + 'export', + choice( + seq(field('opaque', 'opaque'), field('declaration', $.type_declaration)), + field('declaration', $._module_declaration), + ), + ), + + _module_declaration: ($) => + choice( + $.let_declaration, + $.function_declaration, + $.extern_declaration, + $.type_declaration, + $.effect_declaration, + $.module_declaration, + $.signature_declaration, + ), + + // ---------- SIGNATURES ---------- + signature_declaration: ($) => + seq( + optional($.doc_comment), + 'signature', + field('name', $.identifier), + '{', + repeat($.signature_item), + '}', + ), + + signature_item: ($) => + choice( + $.signature_value, + $.signature_function, + $.signature_type, + $.effect_declaration, + $.signature_module, + ), + + signature_value: ($) => + seq('let', field('name', $.identifier), ':', field('type', $._type)), + + signature_function: ($) => + seq( + 'fn', + field('name', $.identifier), + optional(seq('<', field('type_parameters', $.type_parameter_list), '>')), + '(', + optional(field('parameters', $.extern_parameter_list)), + ')', + optional(seq('->', field('return_type', $._type))), + optional(field('effects', $.effect_set)), + ), + + signature_type: ($) => + seq( + optional(field('opaque', 'opaque')), + 'type', + field('name', $.identifier), + optional(seq('<', field('type_parameters', $.type_parameter_list), '>')), + optional(seq('=', field('definition', $._type))), + ), + + signature_module: ($) => + seq( + 'module', + field('path', $.symbol_path), + field('signature', $.signature_ascription), + ), + + // One-or-more `::` separators distinguishes an expression/type path from + // an ordinary identifier without flavor-dependent semantic lookahead. + qualified_path: ($) => + seq($.identifier, repeat1(seq('::', $.identifier))), + symbol_path: ($) => sep1('::', $.identifier), // ---------- TERMINALS ---------- boolean: ($) => choice('true', 'false'), diff --git a/tree-sitter-osprey/src/grammar.json b/tree-sitter-osprey/src/grammar.json index 91f06b3d..0d46e20a 100644 --- a/tree-sitter-osprey/src/grammar.json +++ b/tree-sitter-osprey/src/grammar.json @@ -17,6 +17,10 @@ "type": "SYMBOL", "name": "import_statement" }, + { + "type": "SYMBOL", + "name": "namespace_declaration" + }, { "type": "SYMBOL", "name": "let_declaration" @@ -45,6 +49,10 @@ "type": "SYMBOL", "name": "module_declaration" }, + { + "type": "SYMBOL", + "name": "signature_declaration" + }, { "type": "SYMBOL", "name": "expression_statement" @@ -59,159 +67,203 @@ "value": "import" }, { - "type": "SEQ", + "type": "CHOICE", "members": [ { - "type": "SYMBOL", - "name": "identifier" + "type": "FIELD", + "name": "legacy_target", + "content": { + "type": "SYMBOL", + "name": "legacy_import_path" + } }, { - "type": "REPEAT", - "content": { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "." - }, - { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "target", + "content": { "type": "SYMBOL", - "name": "identifier" + "name": "import_target" } - ] - } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "tail", + "content": { + "type": "SYMBOL", + "name": "import_tail" + } + }, + { + "type": "BLANK" + } + ] + } + ] } ] } ] }, - "let_declaration": { + "legacy_import_path": { "type": "SEQ", "members": [ { - "type": "CHOICE", - "members": [ - { - "type": "SYMBOL", - "name": "doc_comment" - }, - { - "type": "BLANK" - } - ] + "type": "SYMBOL", + "name": "identifier" }, { - "type": "FIELD", - "name": "keyword", + "type": "REPEAT1", "content": { - "type": "CHOICE", + "type": "SEQ", "members": [ { "type": "STRING", - "value": "let" + "value": "." }, { - "type": "STRING", - "value": "mut" + "type": "SYMBOL", + "name": "identifier" } ] } - }, - { - "type": "FIELD", - "name": "name", - "content": { - "type": "SYMBOL", - "name": "identifier" - } - }, - { - "type": "CHOICE", - "members": [ - { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": ":" - }, - { - "type": "FIELD", - "name": "type", - "content": { - "type": "SYMBOL", - "name": "_type" - } - } - ] - }, - { - "type": "BLANK" - } - ] - }, - { - "type": "STRING", - "value": "=" - }, - { - "type": "FIELD", - "name": "value", - "content": { - "type": "SYMBOL", - "name": "expression" - } } ] }, - "assignment": { - "type": "PREC", - "value": -1, + "import_target": { + "type": "PREC_RIGHT", + "value": 0, "content": { "type": "SEQ", "members": [ { "type": "FIELD", - "name": "name", + "name": "namespace", "content": { "type": "SYMBOL", - "name": "identifier" + "name": "namespace_name" } }, { - "type": "STRING", - "value": "=" - }, - { - "type": "FIELD", - "name": "value", + "type": "REPEAT", "content": { - "type": "SYMBOL", - "name": "expression" + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "::" + }, + { + "type": "FIELD", + "name": "segment", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] } } ] } }, - "function_declaration": { - "type": "SEQ", + "import_tail": { + "type": "CHOICE", "members": [ { - "type": "CHOICE", + "type": "SEQ", "members": [ { - "type": "SYMBOL", - "name": "doc_comment" + "type": "STRING", + "value": "as" }, { - "type": "BLANK" + "type": "FIELD", + "name": "alias", + "content": { + "type": "SYMBOL", + "name": "identifier" + } } ] }, { - "type": "STRING", - "value": "fn" + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "::" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "import_member_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "::" + }, + { + "type": "STRING", + "value": "*" + } + ] + } + ] + }, + "import_member_list": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "import_member" }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "import_member" + } + ] + } + } + ] + }, + "import_member": { + "type": "SEQ", + "members": [ { "type": "FIELD", "name": "name", @@ -228,19 +280,15 @@ "members": [ { "type": "STRING", - "value": "<" + "value": "as" }, { "type": "FIELD", - "name": "type_parameters", + "name": "alias", "content": { "type": "SYMBOL", - "name": "type_parameter_list" + "name": "identifier" } - }, - { - "type": "STRING", - "value": ">" } ] }, @@ -248,21 +296,31 @@ "type": "BLANK" } ] - }, + } + ] + }, + "namespace_name": { + "type": "CHOICE", + "members": [ { - "type": "STRING", - "value": "(" + "type": "SYMBOL", + "name": "identifier" }, + { + "type": "SYMBOL", + "name": "string" + } + ] + }, + "namespace_declaration": { + "type": "SEQ", + "members": [ { "type": "CHOICE", "members": [ { - "type": "FIELD", - "name": "parameters", - "content": { - "type": "SYMBOL", - "name": "parameter_list" - } + "type": "SYMBOL", + "name": "doc_comment" }, { "type": "BLANK" @@ -271,10 +329,245 @@ }, { "type": "STRING", - "value": ")" + "value": "namespace" }, { - "type": "CHOICE", + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "namespace_name" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": ";" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "SYMBOL", + "name": "namespace_body" + } + } + ] + } + ] + }, + "namespace_body": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "statement" + } + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "let_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "doc_comment" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "FIELD", + "name": "keyword", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "let" + }, + { + "type": "STRING", + "value": "mut" + } + ] + } + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ":" + }, + { + "type": "FIELD", + "name": "type", + "content": { + "type": "SYMBOL", + "name": "_type" + } + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + }, + "assignment": { + "type": "PREC", + "value": -1, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + } + }, + "function_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "doc_comment" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "fn" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "<" + }, + { + "type": "FIELD", + "name": "type_parameters", + "content": { + "type": "SYMBOL", + "name": "type_parameter_list" + } + }, + { + "type": "STRING", + "value": ">" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "parameters", + "content": { + "type": "SYMBOL", + "name": "parameter_list" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "CHOICE", "members": [ { "type": "SEQ", @@ -607,13 +900,17 @@ "content": { "type": "CHOICE", "members": [ + { + "type": "SYMBOL", + "name": "record_type" + }, { "type": "SYMBOL", "name": "union_type" }, { "type": "SYMBOL", - "name": "record_type" + "name": "type_alias" } ] } @@ -724,9 +1021,17 @@ ] } }, + "type_alias": { + "type": "PREC_DYNAMIC", + "value": -1, + "content": { + "type": "SYMBOL", + "name": "_type" + } + }, "variant": { "type": "PREC_RIGHT", - "value": 0, + "value": 1, "content": { "type": "SEQ", "members": [ @@ -734,8 +1039,17 @@ "type": "FIELD", "name": "name", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -1036,8 +1350,17 @@ "type": "FIELD", "name": "name", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -1157,8 +1480,17 @@ "type": "FIELD", "name": "name", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -1182,8 +1514,17 @@ "type": "FIELD", "name": "name", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -1201,8 +1542,17 @@ ] }, "type_identifier": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] }, "type_list": { "type": "SEQ", @@ -1428,8 +1778,17 @@ "type": "FIELD", "name": "effect", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -2395,6 +2754,10 @@ "type": "SYMBOL", "name": "lambda_expression" }, + { + "type": "SYMBOL", + "name": "qualified_path" + }, { "type": "SYMBOL", "name": "identifier" @@ -2542,8 +2905,17 @@ "type": "FIELD", "name": "effect", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -2623,8 +2995,17 @@ "type": "FIELD", "name": "name", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -3140,8 +3521,17 @@ "type": "FIELD", "name": "name", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -3165,8 +3555,17 @@ "type": "FIELD", "name": "name", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "qualified_path" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } }, { @@ -3199,124 +3598,713 @@ ] }, { - "type": "STRING", - "value": ")" + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "field_pattern" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "FIELD", + "name": "type", + "content": { + "type": "SYMBOL", + "name": "_type" + } + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "binding", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "field_pattern" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + { + "type": "STRING", + "value": "_" + } + ] + }, + "list_pattern": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "element", + "content": { + "type": "SYMBOL", + "name": "pattern" + } + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "FIELD", + "name": "element", + "content": { + "type": "SYMBOL", + "name": "pattern" + } + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "STRING", + "value": "..." + }, + { + "type": "FIELD", + "name": "rest", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "field_pattern": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + } + ] + }, + "module_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "doc_comment" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "state", + "content": { + "type": "STRING", + "value": "state" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "module" + }, + { + "type": "FIELD", + "name": "path", + "content": { + "type": "SYMBOL", + "name": "symbol_path" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "signature", + "content": { + "type": "SYMBOL", + "name": "signature_ascription" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "module_item" + } + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "signature_ascription": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ":" + }, + { + "type": "FIELD", + "name": "path", + "content": { + "type": "SYMBOL", + "name": "symbol_path" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "+" + }, + { + "type": "FIELD", + "name": "extra", + "content": { + "type": "STRING", + "value": "extra" + } + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "module_item": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "export_declaration" + }, + { + "type": "SYMBOL", + "name": "_module_declaration" + } + ] + }, + "export_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "doc_comment" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "export" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "opaque", + "content": { + "type": "STRING", + "value": "opaque" + } + }, + { + "type": "FIELD", + "name": "declaration", + "content": { + "type": "SYMBOL", + "name": "type_declaration" + } + } + ] + }, + { + "type": "FIELD", + "name": "declaration", + "content": { + "type": "SYMBOL", + "name": "_module_declaration" + } + } + ] + } + ] + }, + "_module_declaration": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "let_declaration" + }, + { + "type": "SYMBOL", + "name": "function_declaration" + }, + { + "type": "SYMBOL", + "name": "extern_declaration" + }, + { + "type": "SYMBOL", + "name": "type_declaration" + }, + { + "type": "SYMBOL", + "name": "effect_declaration" + }, + { + "type": "SYMBOL", + "name": "module_declaration" + }, + { + "type": "SYMBOL", + "name": "signature_declaration" + } + ] + }, + "signature_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "doc_comment" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "signature" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "signature_item" + } + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "signature_item": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "signature_value" + }, + { + "type": "SYMBOL", + "name": "signature_function" + }, + { + "type": "SYMBOL", + "name": "signature_type" + }, + { + "type": "SYMBOL", + "name": "effect_declaration" + }, + { + "type": "SYMBOL", + "name": "signature_module" + } + ] + }, + "signature_value": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "let" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "FIELD", + "name": "type", + "content": { + "type": "SYMBOL", + "name": "_type" + } + } + ] + }, + "signature_function": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "fn" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "<" + }, + { + "type": "FIELD", + "name": "type_parameters", + "content": { + "type": "SYMBOL", + "name": "type_parameter_list" + } + }, + { + "type": "STRING", + "value": ">" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "parameters", + "content": { + "type": "SYMBOL", + "name": "extern_parameter_list" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "->" + }, + { + "type": "FIELD", + "name": "return_type", + "content": { + "type": "SYMBOL", + "name": "_type" + } + } + ] + }, + { + "type": "BLANK" } ] }, { - "type": "SEQ", + "type": "CHOICE", "members": [ { "type": "FIELD", - "name": "name", + "name": "effects", "content": { "type": "SYMBOL", - "name": "identifier" + "name": "effect_set" } }, { - "type": "STRING", - "value": ":" - }, - { - "type": "STRING", - "value": "{" - }, - { - "type": "SYMBOL", - "name": "field_pattern" - }, - { - "type": "STRING", - "value": "}" + "type": "BLANK" } ] - }, + } + ] + }, + "signature_type": { + "type": "SEQ", + "members": [ { - "type": "SEQ", + "type": "CHOICE", "members": [ { "type": "FIELD", - "name": "name", + "name": "opaque", "content": { - "type": "SYMBOL", - "name": "identifier" + "type": "STRING", + "value": "opaque" } }, { - "type": "STRING", - "value": ":" - }, - { - "type": "FIELD", - "name": "type", - "content": { - "type": "SYMBOL", - "name": "_type" - } + "type": "BLANK" } ] }, { - "type": "SEQ", + "type": "STRING", + "value": "type" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "CHOICE", "members": [ { - "type": "FIELD", - "name": "name", - "content": { - "type": "SYMBOL", - "name": "identifier" - } - }, - { - "type": "CHOICE", + "type": "SEQ", "members": [ + { + "type": "STRING", + "value": "<" + }, { "type": "FIELD", - "name": "binding", + "name": "type_parameters", "content": { "type": "SYMBOL", - "name": "identifier" + "name": "type_parameter_list" } }, { - "type": "BLANK" + "type": "STRING", + "value": ">" } ] - } - ] - }, - { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "{" - }, - { - "type": "SYMBOL", - "name": "field_pattern" }, { - "type": "STRING", - "value": "}" + "type": "BLANK" } ] }, - { - "type": "STRING", - "value": "_" - } - ] - }, - "list_pattern": { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "[" - }, { "type": "CHOICE", "members": [ @@ -3324,61 +4312,16 @@ "type": "SEQ", "members": [ { - "type": "FIELD", - "name": "element", - "content": { - "type": "SYMBOL", - "name": "pattern" - } + "type": "STRING", + "value": "=" }, { - "type": "REPEAT", + "type": "FIELD", + "name": "definition", "content": { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "," - }, - { - "type": "FIELD", - "name": "element", - "content": { - "type": "SYMBOL", - "name": "pattern" - } - } - ] + "type": "SYMBOL", + "name": "_type" } - }, - { - "type": "CHOICE", - "members": [ - { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "," - }, - { - "type": "STRING", - "value": "..." - }, - { - "type": "FIELD", - "name": "rest", - "content": { - "type": "SYMBOL", - "name": "identifier" - } - } - ] - }, - { - "type": "BLANK" - } - ] } ] }, @@ -3386,14 +4329,35 @@ "type": "BLANK" } ] - }, + } + ] + }, + "signature_module": { + "type": "SEQ", + "members": [ { "type": "STRING", - "value": "]" + "value": "module" + }, + { + "type": "FIELD", + "name": "path", + "content": { + "type": "SYMBOL", + "name": "symbol_path" + } + }, + { + "type": "FIELD", + "name": "signature", + "content": { + "type": "SYMBOL", + "name": "signature_ascription" + } } ] }, - "field_pattern": { + "qualified_path": { "type": "SEQ", "members": [ { @@ -3401,13 +4365,13 @@ "name": "identifier" }, { - "type": "REPEAT", + "type": "REPEAT1", "content": { "type": "SEQ", "members": [ { "type": "STRING", - "value": "," + "value": "::" }, { "type": "SYMBOL", @@ -3418,64 +4382,28 @@ } ] }, - "module_declaration": { + "symbol_path": { "type": "SEQ", "members": [ { - "type": "CHOICE", - "members": [ - { - "type": "SYMBOL", - "name": "doc_comment" - }, - { - "type": "BLANK" - } - ] - }, - { - "type": "STRING", - "value": "module" - }, - { - "type": "FIELD", - "name": "name", - "content": { - "type": "SYMBOL", - "name": "identifier" - } - }, - { - "type": "STRING", - "value": "{" + "type": "SYMBOL", + "name": "identifier" }, { "type": "REPEAT", "content": { - "type": "SYMBOL", - "name": "module_statement" + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "::" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] } - }, - { - "type": "STRING", - "value": "}" - } - ] - }, - "module_statement": { - "type": "CHOICE", - "members": [ - { - "type": "SYMBOL", - "name": "let_declaration" - }, - { - "type": "SYMBOL", - "name": "function_declaration" - }, - { - "type": "SYMBOL", - "name": "type_declaration" } ] }, @@ -3712,6 +4640,14 @@ [ "generic_type", "type_identifier" + ], + [ + "qualified_path", + "primary_expression" + ], + [ + "union_type", + "type_alias" ] ], "precedences": [], diff --git a/tree-sitter-osprey/src/node-types.json b/tree-sitter-osprey/src/node-types.json index 08c311f4..c2d80c64 100644 --- a/tree-sitter-osprey/src/node-types.json +++ b/tree-sitter-osprey/src/node-types.json @@ -29,6 +29,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] } @@ -322,6 +326,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] } @@ -356,6 +364,66 @@ ] } }, + { + "type": "export_declaration", + "named": true, + "fields": { + "declaration": { + "multiple": false, + "required": true, + "types": [ + { + "type": "effect_declaration", + "named": true + }, + { + "type": "extern_declaration", + "named": true + }, + { + "type": "function_declaration", + "named": true + }, + { + "type": "let_declaration", + "named": true + }, + { + "type": "module_declaration", + "named": true + }, + { + "type": "signature_declaration", + "named": true + }, + { + "type": "type_declaration", + "named": true + } + ] + }, + "opaque": { + "multiple": false, + "required": false, + "types": [ + { + "type": "opaque", + "named": false + } + ] + } + }, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "doc_comment", + "named": true + } + ] + } + }, { "type": "expression", "named": true, @@ -786,6 +854,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] } @@ -858,6 +930,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] } @@ -929,7 +1005,33 @@ } }, { - "type": "import_statement", + "type": "import_member", + "named": true, + "fields": { + "alias": { + "multiple": false, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + } + }, + { + "type": "import_member_list", "named": true, "fields": {}, "children": { @@ -937,12 +1039,100 @@ "required": true, "types": [ { - "type": "identifier", + "type": "import_member", + "named": true + } + ] + } + }, + { + "type": "import_statement", + "named": true, + "fields": { + "legacy_target": { + "multiple": false, + "required": false, + "types": [ + { + "type": "legacy_import_path", + "named": true + } + ] + }, + "tail": { + "multiple": false, + "required": false, + "types": [ + { + "type": "import_tail", + "named": true + } + ] + }, + "target": { + "multiple": false, + "required": false, + "types": [ + { + "type": "import_target", + "named": true + } + ] + } + } + }, + { + "type": "import_tail", + "named": true, + "fields": { + "alias": { + "multiple": false, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "import_member_list", "named": true } ] } }, + { + "type": "import_target", + "named": true, + "fields": { + "namespace": { + "multiple": false, + "required": true, + "types": [ + { + "type": "namespace_name", + "named": true + } + ] + }, + "segment": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + } + }, { "type": "lambda_expression", "named": true, @@ -985,6 +1175,21 @@ ] } }, + { + "type": "legacy_import_path", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, { "type": "let_declaration", "named": true, @@ -1234,15 +1439,35 @@ "type": "module_declaration", "named": true, "fields": { - "name": { + "path": { "multiple": false, "required": true, "types": [ { - "type": "identifier", + "type": "symbol_path", + "named": true + } + ] + }, + "signature": { + "multiple": false, + "required": false, + "types": [ + { + "type": "signature_ascription", "named": true } ] + }, + "state": { + "multiple": false, + "required": false, + "types": [ + { + "type": "state", + "named": false + } + ] } }, "children": { @@ -1254,20 +1479,32 @@ "named": true }, { - "type": "module_statement", + "type": "module_item", "named": true } ] } }, { - "type": "module_statement", + "type": "module_item", "named": true, "fields": {}, "children": { "multiple": false, "required": true, "types": [ + { + "type": "effect_declaration", + "named": true + }, + { + "type": "export_declaration", + "named": true + }, + { + "type": "extern_declaration", + "named": true + }, { "type": "function_declaration", "named": true @@ -1276,6 +1513,14 @@ "type": "let_declaration", "named": true }, + { + "type": "module_declaration", + "named": true + }, + { + "type": "signature_declaration", + "named": true + }, { "type": "type_declaration", "named": true @@ -1325,66 +1570,136 @@ } }, { - "type": "object_literal", + "type": "namespace_body", "named": true, "fields": {}, "children": { - "multiple": false, - "required": true, + "multiple": true, + "required": false, "types": [ { - "type": "field_assignments", + "type": "statement", "named": true } ] } }, { - "type": "operation_declaration", + "type": "namespace_declaration", "named": true, "fields": { - "name": { + "body": { "multiple": false, - "required": true, + "required": false, "types": [ { - "type": "identifier", + "type": "namespace_body", "named": true } ] }, - "type": { + "name": { "multiple": false, "required": true, "types": [ { - "type": "array_type", - "named": true - }, - { - "type": "function_type", - "named": true - }, - { - "type": "generic_type", - "named": true - }, - { - "type": "type_identifier", + "type": "namespace_name", "named": true } ] } + }, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "doc_comment", + "named": true + } + ] } }, { - "type": "parameter", + "type": "namespace_name", "named": true, - "fields": { - "name": { - "multiple": false, - "required": true, - "types": [ + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "string", + "named": true + } + ] + } + }, + { + "type": "object_literal", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "field_assignments", + "named": true + } + ] + } + }, + { + "type": "operation_declaration", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "type": { + "multiple": false, + "required": true, + "types": [ + { + "type": "array_type", + "named": true + }, + { + "type": "function_type", + "named": true + }, + { + "type": "generic_type", + "named": true + }, + { + "type": "type_identifier", + "named": true + } + ] + } + } + }, + { + "type": "parameter", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ { "type": "identifier", "named": true @@ -1451,6 +1766,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] }, @@ -1541,6 +1860,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] }, @@ -1632,6 +1955,10 @@ "type": "perform_expression", "named": true }, + { + "type": "qualified_path", + "named": true + }, { "type": "recv_call", "named": true @@ -1663,6 +1990,21 @@ ] } }, + { + "type": "qualified_path", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, { "type": "record_type", "named": true, @@ -1765,6 +2107,283 @@ ] } }, + { + "type": "signature_ascription", + "named": true, + "fields": { + "extra": { + "multiple": false, + "required": false, + "types": [ + { + "type": "extra", + "named": false + } + ] + }, + "path": { + "multiple": false, + "required": true, + "types": [ + { + "type": "symbol_path", + "named": true + } + ] + } + } + }, + { + "type": "signature_declaration", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "doc_comment", + "named": true + }, + { + "type": "signature_item", + "named": true + } + ] + } + }, + { + "type": "signature_function", + "named": true, + "fields": { + "effects": { + "multiple": false, + "required": false, + "types": [ + { + "type": "effect_set", + "named": true + } + ] + }, + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "parameters": { + "multiple": false, + "required": false, + "types": [ + { + "type": "extern_parameter_list", + "named": true + } + ] + }, + "return_type": { + "multiple": false, + "required": false, + "types": [ + { + "type": "array_type", + "named": true + }, + { + "type": "function_type", + "named": true + }, + { + "type": "generic_type", + "named": true + }, + { + "type": "type_identifier", + "named": true + } + ] + }, + "type_parameters": { + "multiple": false, + "required": false, + "types": [ + { + "type": "type_parameter_list", + "named": true + } + ] + } + } + }, + { + "type": "signature_item", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "effect_declaration", + "named": true + }, + { + "type": "signature_function", + "named": true + }, + { + "type": "signature_module", + "named": true + }, + { + "type": "signature_type", + "named": true + }, + { + "type": "signature_value", + "named": true + } + ] + } + }, + { + "type": "signature_module", + "named": true, + "fields": { + "path": { + "multiple": false, + "required": true, + "types": [ + { + "type": "symbol_path", + "named": true + } + ] + }, + "signature": { + "multiple": false, + "required": true, + "types": [ + { + "type": "signature_ascription", + "named": true + } + ] + } + } + }, + { + "type": "signature_type", + "named": true, + "fields": { + "definition": { + "multiple": false, + "required": false, + "types": [ + { + "type": "array_type", + "named": true + }, + { + "type": "function_type", + "named": true + }, + { + "type": "generic_type", + "named": true + }, + { + "type": "type_identifier", + "named": true + } + ] + }, + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "opaque": { + "multiple": false, + "required": false, + "types": [ + { + "type": "opaque", + "named": false + } + ] + }, + "type_parameters": { + "multiple": false, + "required": false, + "types": [ + { + "type": "type_parameter_list", + "named": true + } + ] + } + } + }, + { + "type": "signature_value", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "type": { + "multiple": false, + "required": true, + "types": [ + { + "type": "array_type", + "named": true + }, + { + "type": "function_type", + "named": true + }, + { + "type": "generic_type", + "named": true + }, + { + "type": "type_identifier", + "named": true + } + ] + } + } + }, { "type": "source_file", "named": true, @@ -1836,6 +2455,14 @@ "type": "module_declaration", "named": true }, + { + "type": "namespace_declaration", + "named": true + }, + { + "type": "signature_declaration", + "named": true + }, { "type": "type_declaration", "named": true @@ -1843,6 +2470,21 @@ ] } }, + { + "type": "symbol_path", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, { "type": "ternary_expression", "named": true, @@ -1893,6 +2535,33 @@ ] } }, + { + "type": "type_alias", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "array_type", + "named": true + }, + { + "type": "function_type", + "named": true + }, + { + "type": "generic_type", + "named": true + }, + { + "type": "type_identifier", + "named": true + } + ] + } + }, { "type": "type_arguments", "named": true, @@ -1919,6 +2588,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] } @@ -1950,6 +2623,10 @@ "type": "record_type", "named": true }, + { + "type": "type_alias", + "named": true + }, { "type": "union_type", "named": true @@ -2003,6 +2680,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] } @@ -2184,6 +2865,10 @@ { "type": "identifier", "named": true + }, + { + "type": "qualified_path", + "named": true } ] } @@ -2274,6 +2959,14 @@ "type": ":", "named": false }, + { + "type": "::", + "named": false + }, + { + "type": ";", + "named": false + }, { "type": "<", "named": false @@ -2318,6 +3011,10 @@ "type": "_", "named": false }, + { + "type": "as", + "named": false + }, { "type": "await", "named": false @@ -2330,10 +3027,18 @@ "type": "else", "named": false }, + { + "type": "export", + "named": false + }, { "type": "extern", "named": false }, + { + "type": "extra", + "named": false + }, { "type": "false", "named": false @@ -2394,6 +3099,14 @@ "type": "mut", "named": false }, + { + "type": "namespace", + "named": false + }, + { + "type": "opaque", + "named": false + }, { "type": "out", "named": false @@ -2418,10 +3131,18 @@ "type": "send", "named": false }, + { + "type": "signature", + "named": false + }, { "type": "spawn", "named": false }, + { + "type": "state", + "named": false + }, { "type": "string", "named": true diff --git a/tree-sitter-osprey/src/parser.c b/tree-sitter-osprey/src/parser.c index 1c77a5a8..c6ddae65 100644 --- a/tree-sitter-osprey/src/parser.c +++ b/tree-sitter-osprey/src/parser.c @@ -5,180 +5,213 @@ #endif #define LANGUAGE_VERSION 14 -#define STATE_COUNT 1442 -#define LARGE_STATE_COUNT 20 -#define SYMBOL_COUNT 164 +#define STATE_COUNT 1795 +#define LARGE_STATE_COUNT 24 +#define SYMBOL_COUNT 197 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 65 +#define TOKEN_COUNT 74 #define EXTERNAL_TOKEN_COUNT 0 -#define FIELD_COUNT 31 +#define FIELD_COUNT 43 #define MAX_ALIAS_SEQUENCE_LENGTH 14 -#define PRODUCTION_ID_COUNT 120 +#define PRODUCTION_ID_COUNT 163 enum ts_symbol_identifiers { sym_identifier = 1, anon_sym_import = 2, anon_sym_DOT = 3, - anon_sym_let = 4, - anon_sym_mut = 5, - anon_sym_COLON = 6, - anon_sym_EQ = 7, - anon_sym_fn = 8, - anon_sym_LT = 9, - anon_sym_GT = 10, - anon_sym_LPAREN = 11, - anon_sym_RPAREN = 12, - anon_sym_DASH_GT = 13, - anon_sym_extern = 14, - anon_sym_COMMA = 15, - anon_sym_type = 16, - anon_sym_in = 17, - anon_sym_out = 18, - anon_sym_PIPE = 19, - anon_sym_LBRACE = 20, - anon_sym_RBRACE = 21, - anon_sym_where = 22, - anon_sym_effect = 23, - anon_sym_BANG = 24, - anon_sym_LBRACK = 25, - anon_sym_RBRACK = 26, - anon_sym_match = 27, - anon_sym_EQ_GT = 28, - anon_sym_if = 29, - anon_sym_else = 30, - anon_sym_handle = 31, - anon_sym_select = 32, - anon_sym_QMARK = 33, - anon_sym_PIPE_PIPE = 34, - anon_sym_AMP_AMP = 35, - anon_sym_EQ_EQ = 36, - anon_sym_BANG_EQ = 37, - anon_sym_LT_EQ = 38, - anon_sym_GT_EQ = 39, - anon_sym_PLUS = 40, - anon_sym_DASH = 41, - anon_sym_STAR = 42, - anon_sym_SLASH = 43, - anon_sym_PERCENT = 44, - anon_sym_await = 45, - anon_sym_PIPE_GT = 46, - anon_sym_LBRACK2 = 47, - anon_sym_spawn = 48, - anon_sym_yield = 49, - anon_sym_send = 50, - anon_sym_recv = 51, - anon_sym_perform = 52, - anon_sym_resume = 53, - anon_sym__ = 54, - anon_sym_DOT_DOT_DOT = 55, - anon_sym_module = 56, - anon_sym_true = 57, - anon_sym_false = 58, - sym_float = 59, - sym_integer = 60, - sym_string = 61, - sym_interpolated_string = 62, - sym__doc_comment_line = 63, - sym_line_comment = 64, - sym_source_file = 65, - sym_statement = 66, - sym_import_statement = 67, - sym_let_declaration = 68, - sym_assignment = 69, - sym_function_declaration = 70, - sym_extern_declaration = 71, - sym_extern_parameter_list = 72, - sym_extern_parameter = 73, - sym_parameter_list = 74, - sym_parameter = 75, - sym_type_declaration = 76, - sym_type_parameter_list = 77, - sym_type_parameter = 78, - sym_union_type = 79, - sym_variant = 80, - sym_record_type = 81, - sym_field_declarations = 82, - sym_field_declaration = 83, - sym_type_validation = 84, - sym_effect_declaration = 85, - sym_operation_declaration = 86, - sym_effect_set = 87, - sym_effect_list = 88, - sym_effect_ref = 89, - sym__type = 90, - sym_function_type = 91, - sym_generic_type = 92, - sym_array_type = 93, - sym_type_identifier = 94, - sym_type_list = 95, - sym_expression_statement = 96, - sym_expression = 97, - sym_match_expression = 98, - sym_match_arm = 99, - sym_if_expression = 100, - sym_handler_expression = 101, - sym_handler_arm = 102, - sym_handler_params = 103, - sym_select_expression = 104, - sym_select_arm = 105, - sym_ternary_expression = 106, - sym_binary_expression = 107, - sym_unary_expression = 108, - sym_pipe_expression = 109, - sym_call_expression = 110, - sym_argument_list = 111, - sym_named_argument_list = 112, - sym_named_argument = 113, - sym_primary_expression = 114, - sym_spawn_expression = 115, - sym_yield_expression = 116, - sym_await_call = 117, - sym_send_call = 118, - sym_recv_call = 119, - sym_perform_expression = 120, - sym_resume_expression = 121, - sym_type_constructor = 122, - sym_type_arguments = 123, - sym_update_expression = 124, - sym_field_assignments = 125, - sym_field_assignment = 126, - sym_block = 127, - sym_object_literal = 128, - sym_lambda_expression = 129, - sym_literal = 130, - sym_list_literal = 131, - sym_map_literal = 132, - sym_map_entry = 133, - sym_pattern = 134, - sym_list_pattern = 135, - sym_field_pattern = 136, - sym_module_declaration = 137, - sym_module_statement = 138, - sym_boolean = 139, - sym_doc_comment = 140, - aux_sym_source_file_repeat1 = 141, - aux_sym_import_statement_repeat1 = 142, - aux_sym_extern_parameter_list_repeat1 = 143, - aux_sym_parameter_list_repeat1 = 144, - aux_sym_type_parameter_list_repeat1 = 145, - aux_sym_union_type_repeat1 = 146, - aux_sym_field_declarations_repeat1 = 147, - aux_sym_effect_declaration_repeat1 = 148, - aux_sym_effect_list_repeat1 = 149, - aux_sym_type_list_repeat1 = 150, - aux_sym_match_expression_repeat1 = 151, - aux_sym_handler_expression_repeat1 = 152, - aux_sym_handler_params_repeat1 = 153, - aux_sym_select_expression_repeat1 = 154, - aux_sym_argument_list_repeat1 = 155, - aux_sym_named_argument_list_repeat1 = 156, - aux_sym_field_assignments_repeat1 = 157, - aux_sym_map_literal_repeat1 = 158, - aux_sym_pattern_repeat1 = 159, - aux_sym_list_pattern_repeat1 = 160, - aux_sym_field_pattern_repeat1 = 161, - aux_sym_module_declaration_repeat1 = 162, - aux_sym_doc_comment_repeat1 = 163, + anon_sym_COLON_COLON = 4, + anon_sym_as = 5, + anon_sym_LBRACE = 6, + anon_sym_RBRACE = 7, + anon_sym_STAR = 8, + anon_sym_COMMA = 9, + anon_sym_namespace = 10, + anon_sym_SEMI = 11, + anon_sym_let = 12, + anon_sym_mut = 13, + anon_sym_COLON = 14, + anon_sym_EQ = 15, + anon_sym_fn = 16, + anon_sym_LT = 17, + anon_sym_GT = 18, + anon_sym_LPAREN = 19, + anon_sym_RPAREN = 20, + anon_sym_DASH_GT = 21, + anon_sym_extern = 22, + anon_sym_type = 23, + anon_sym_in = 24, + anon_sym_out = 25, + anon_sym_PIPE = 26, + anon_sym_where = 27, + anon_sym_effect = 28, + anon_sym_BANG = 29, + anon_sym_LBRACK = 30, + anon_sym_RBRACK = 31, + anon_sym_match = 32, + anon_sym_EQ_GT = 33, + anon_sym_if = 34, + anon_sym_else = 35, + anon_sym_handle = 36, + anon_sym_select = 37, + anon_sym_QMARK = 38, + anon_sym_PIPE_PIPE = 39, + anon_sym_AMP_AMP = 40, + anon_sym_EQ_EQ = 41, + anon_sym_BANG_EQ = 42, + anon_sym_LT_EQ = 43, + anon_sym_GT_EQ = 44, + anon_sym_PLUS = 45, + anon_sym_DASH = 46, + anon_sym_SLASH = 47, + anon_sym_PERCENT = 48, + anon_sym_await = 49, + anon_sym_PIPE_GT = 50, + anon_sym_LBRACK2 = 51, + anon_sym_spawn = 52, + anon_sym_yield = 53, + anon_sym_send = 54, + anon_sym_recv = 55, + anon_sym_perform = 56, + anon_sym_resume = 57, + anon_sym__ = 58, + anon_sym_DOT_DOT_DOT = 59, + anon_sym_state = 60, + anon_sym_module = 61, + anon_sym_extra = 62, + anon_sym_export = 63, + anon_sym_opaque = 64, + anon_sym_signature = 65, + anon_sym_true = 66, + anon_sym_false = 67, + sym_float = 68, + sym_integer = 69, + sym_string = 70, + sym_interpolated_string = 71, + sym__doc_comment_line = 72, + sym_line_comment = 73, + sym_source_file = 74, + sym_statement = 75, + sym_import_statement = 76, + sym_legacy_import_path = 77, + sym_import_target = 78, + sym_import_tail = 79, + sym_import_member_list = 80, + sym_import_member = 81, + sym_namespace_name = 82, + sym_namespace_declaration = 83, + sym_namespace_body = 84, + sym_let_declaration = 85, + sym_assignment = 86, + sym_function_declaration = 87, + sym_extern_declaration = 88, + sym_extern_parameter_list = 89, + sym_extern_parameter = 90, + sym_parameter_list = 91, + sym_parameter = 92, + sym_type_declaration = 93, + sym_type_parameter_list = 94, + sym_type_parameter = 95, + sym_union_type = 96, + sym_type_alias = 97, + sym_variant = 98, + sym_record_type = 99, + sym_field_declarations = 100, + sym_field_declaration = 101, + sym_type_validation = 102, + sym_effect_declaration = 103, + sym_operation_declaration = 104, + sym_effect_set = 105, + sym_effect_list = 106, + sym_effect_ref = 107, + sym__type = 108, + sym_function_type = 109, + sym_generic_type = 110, + sym_array_type = 111, + sym_type_identifier = 112, + sym_type_list = 113, + sym_expression_statement = 114, + sym_expression = 115, + sym_match_expression = 116, + sym_match_arm = 117, + sym_if_expression = 118, + sym_handler_expression = 119, + sym_handler_arm = 120, + sym_handler_params = 121, + sym_select_expression = 122, + sym_select_arm = 123, + sym_ternary_expression = 124, + sym_binary_expression = 125, + sym_unary_expression = 126, + sym_pipe_expression = 127, + sym_call_expression = 128, + sym_argument_list = 129, + sym_named_argument_list = 130, + sym_named_argument = 131, + sym_primary_expression = 132, + sym_spawn_expression = 133, + sym_yield_expression = 134, + sym_await_call = 135, + sym_send_call = 136, + sym_recv_call = 137, + sym_perform_expression = 138, + sym_resume_expression = 139, + sym_type_constructor = 140, + sym_type_arguments = 141, + sym_update_expression = 142, + sym_field_assignments = 143, + sym_field_assignment = 144, + sym_block = 145, + sym_object_literal = 146, + sym_lambda_expression = 147, + sym_literal = 148, + sym_list_literal = 149, + sym_map_literal = 150, + sym_map_entry = 151, + sym_pattern = 152, + sym_list_pattern = 153, + sym_field_pattern = 154, + sym_module_declaration = 155, + sym_signature_ascription = 156, + sym_module_item = 157, + sym_export_declaration = 158, + sym__module_declaration = 159, + sym_signature_declaration = 160, + sym_signature_item = 161, + sym_signature_value = 162, + sym_signature_function = 163, + sym_signature_type = 164, + sym_signature_module = 165, + sym_qualified_path = 166, + sym_symbol_path = 167, + sym_boolean = 168, + sym_doc_comment = 169, + aux_sym_source_file_repeat1 = 170, + aux_sym_legacy_import_path_repeat1 = 171, + aux_sym_import_target_repeat1 = 172, + aux_sym_import_member_list_repeat1 = 173, + aux_sym_extern_parameter_list_repeat1 = 174, + aux_sym_parameter_list_repeat1 = 175, + aux_sym_type_parameter_list_repeat1 = 176, + aux_sym_union_type_repeat1 = 177, + aux_sym_field_declarations_repeat1 = 178, + aux_sym_effect_declaration_repeat1 = 179, + aux_sym_effect_list_repeat1 = 180, + aux_sym_type_list_repeat1 = 181, + aux_sym_match_expression_repeat1 = 182, + aux_sym_handler_expression_repeat1 = 183, + aux_sym_handler_params_repeat1 = 184, + aux_sym_select_expression_repeat1 = 185, + aux_sym_argument_list_repeat1 = 186, + aux_sym_named_argument_list_repeat1 = 187, + aux_sym_field_assignments_repeat1 = 188, + aux_sym_map_literal_repeat1 = 189, + aux_sym_pattern_repeat1 = 190, + aux_sym_list_pattern_repeat1 = 191, + aux_sym_field_pattern_repeat1 = 192, + aux_sym_module_declaration_repeat1 = 193, + aux_sym_signature_declaration_repeat1 = 194, + aux_sym_qualified_path_repeat1 = 195, + aux_sym_doc_comment_repeat1 = 196, }; static const char * const ts_symbol_names[] = { @@ -186,6 +219,14 @@ static const char * const ts_symbol_names[] = { [sym_identifier] = "identifier", [anon_sym_import] = "import", [anon_sym_DOT] = ".", + [anon_sym_COLON_COLON] = "::", + [anon_sym_as] = "as", + [anon_sym_LBRACE] = "{", + [anon_sym_RBRACE] = "}", + [anon_sym_STAR] = "*", + [anon_sym_COMMA] = ",", + [anon_sym_namespace] = "namespace", + [anon_sym_SEMI] = ";", [anon_sym_let] = "let", [anon_sym_mut] = "mut", [anon_sym_COLON] = ":", @@ -197,13 +238,10 @@ static const char * const ts_symbol_names[] = { [anon_sym_RPAREN] = ")", [anon_sym_DASH_GT] = "->", [anon_sym_extern] = "extern", - [anon_sym_COMMA] = ",", [anon_sym_type] = "type", [anon_sym_in] = "in", [anon_sym_out] = "out", [anon_sym_PIPE] = "|", - [anon_sym_LBRACE] = "{", - [anon_sym_RBRACE] = "}", [anon_sym_where] = "where", [anon_sym_effect] = "effect", [anon_sym_BANG] = "!", @@ -224,7 +262,6 @@ static const char * const ts_symbol_names[] = { [anon_sym_GT_EQ] = ">=", [anon_sym_PLUS] = "+", [anon_sym_DASH] = "-", - [anon_sym_STAR] = "*", [anon_sym_SLASH] = "/", [anon_sym_PERCENT] = "%", [anon_sym_await] = "await", @@ -238,7 +275,12 @@ static const char * const ts_symbol_names[] = { [anon_sym_resume] = "resume", [anon_sym__] = "_", [anon_sym_DOT_DOT_DOT] = "...", + [anon_sym_state] = "state", [anon_sym_module] = "module", + [anon_sym_extra] = "extra", + [anon_sym_export] = "export", + [anon_sym_opaque] = "opaque", + [anon_sym_signature] = "signature", [anon_sym_true] = "true", [anon_sym_false] = "false", [sym_float] = "float", @@ -250,6 +292,14 @@ static const char * const ts_symbol_names[] = { [sym_source_file] = "source_file", [sym_statement] = "statement", [sym_import_statement] = "import_statement", + [sym_legacy_import_path] = "legacy_import_path", + [sym_import_target] = "import_target", + [sym_import_tail] = "import_tail", + [sym_import_member_list] = "import_member_list", + [sym_import_member] = "import_member", + [sym_namespace_name] = "namespace_name", + [sym_namespace_declaration] = "namespace_declaration", + [sym_namespace_body] = "namespace_body", [sym_let_declaration] = "let_declaration", [sym_assignment] = "assignment", [sym_function_declaration] = "function_declaration", @@ -262,6 +312,7 @@ static const char * const ts_symbol_names[] = { [sym_type_parameter_list] = "type_parameter_list", [sym_type_parameter] = "type_parameter", [sym_union_type] = "union_type", + [sym_type_alias] = "type_alias", [sym_variant] = "variant", [sym_record_type] = "record_type", [sym_field_declarations] = "field_declarations", @@ -320,11 +371,24 @@ static const char * const ts_symbol_names[] = { [sym_list_pattern] = "list_pattern", [sym_field_pattern] = "field_pattern", [sym_module_declaration] = "module_declaration", - [sym_module_statement] = "module_statement", + [sym_signature_ascription] = "signature_ascription", + [sym_module_item] = "module_item", + [sym_export_declaration] = "export_declaration", + [sym__module_declaration] = "_module_declaration", + [sym_signature_declaration] = "signature_declaration", + [sym_signature_item] = "signature_item", + [sym_signature_value] = "signature_value", + [sym_signature_function] = "signature_function", + [sym_signature_type] = "signature_type", + [sym_signature_module] = "signature_module", + [sym_qualified_path] = "qualified_path", + [sym_symbol_path] = "symbol_path", [sym_boolean] = "boolean", [sym_doc_comment] = "doc_comment", [aux_sym_source_file_repeat1] = "source_file_repeat1", - [aux_sym_import_statement_repeat1] = "import_statement_repeat1", + [aux_sym_legacy_import_path_repeat1] = "legacy_import_path_repeat1", + [aux_sym_import_target_repeat1] = "import_target_repeat1", + [aux_sym_import_member_list_repeat1] = "import_member_list_repeat1", [aux_sym_extern_parameter_list_repeat1] = "extern_parameter_list_repeat1", [aux_sym_parameter_list_repeat1] = "parameter_list_repeat1", [aux_sym_type_parameter_list_repeat1] = "type_parameter_list_repeat1", @@ -345,6 +409,8 @@ static const char * const ts_symbol_names[] = { [aux_sym_list_pattern_repeat1] = "list_pattern_repeat1", [aux_sym_field_pattern_repeat1] = "field_pattern_repeat1", [aux_sym_module_declaration_repeat1] = "module_declaration_repeat1", + [aux_sym_signature_declaration_repeat1] = "signature_declaration_repeat1", + [aux_sym_qualified_path_repeat1] = "qualified_path_repeat1", [aux_sym_doc_comment_repeat1] = "doc_comment_repeat1", }; @@ -353,6 +419,14 @@ static const TSSymbol ts_symbol_map[] = { [sym_identifier] = sym_identifier, [anon_sym_import] = anon_sym_import, [anon_sym_DOT] = anon_sym_DOT, + [anon_sym_COLON_COLON] = anon_sym_COLON_COLON, + [anon_sym_as] = anon_sym_as, + [anon_sym_LBRACE] = anon_sym_LBRACE, + [anon_sym_RBRACE] = anon_sym_RBRACE, + [anon_sym_STAR] = anon_sym_STAR, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_namespace] = anon_sym_namespace, + [anon_sym_SEMI] = anon_sym_SEMI, [anon_sym_let] = anon_sym_let, [anon_sym_mut] = anon_sym_mut, [anon_sym_COLON] = anon_sym_COLON, @@ -364,13 +438,10 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_RPAREN] = anon_sym_RPAREN, [anon_sym_DASH_GT] = anon_sym_DASH_GT, [anon_sym_extern] = anon_sym_extern, - [anon_sym_COMMA] = anon_sym_COMMA, [anon_sym_type] = anon_sym_type, [anon_sym_in] = anon_sym_in, [anon_sym_out] = anon_sym_out, [anon_sym_PIPE] = anon_sym_PIPE, - [anon_sym_LBRACE] = anon_sym_LBRACE, - [anon_sym_RBRACE] = anon_sym_RBRACE, [anon_sym_where] = anon_sym_where, [anon_sym_effect] = anon_sym_effect, [anon_sym_BANG] = anon_sym_BANG, @@ -391,7 +462,6 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_GT_EQ] = anon_sym_GT_EQ, [anon_sym_PLUS] = anon_sym_PLUS, [anon_sym_DASH] = anon_sym_DASH, - [anon_sym_STAR] = anon_sym_STAR, [anon_sym_SLASH] = anon_sym_SLASH, [anon_sym_PERCENT] = anon_sym_PERCENT, [anon_sym_await] = anon_sym_await, @@ -405,7 +475,12 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_resume] = anon_sym_resume, [anon_sym__] = anon_sym__, [anon_sym_DOT_DOT_DOT] = anon_sym_DOT_DOT_DOT, + [anon_sym_state] = anon_sym_state, [anon_sym_module] = anon_sym_module, + [anon_sym_extra] = anon_sym_extra, + [anon_sym_export] = anon_sym_export, + [anon_sym_opaque] = anon_sym_opaque, + [anon_sym_signature] = anon_sym_signature, [anon_sym_true] = anon_sym_true, [anon_sym_false] = anon_sym_false, [sym_float] = sym_float, @@ -417,6 +492,14 @@ static const TSSymbol ts_symbol_map[] = { [sym_source_file] = sym_source_file, [sym_statement] = sym_statement, [sym_import_statement] = sym_import_statement, + [sym_legacy_import_path] = sym_legacy_import_path, + [sym_import_target] = sym_import_target, + [sym_import_tail] = sym_import_tail, + [sym_import_member_list] = sym_import_member_list, + [sym_import_member] = sym_import_member, + [sym_namespace_name] = sym_namespace_name, + [sym_namespace_declaration] = sym_namespace_declaration, + [sym_namespace_body] = sym_namespace_body, [sym_let_declaration] = sym_let_declaration, [sym_assignment] = sym_assignment, [sym_function_declaration] = sym_function_declaration, @@ -429,6 +512,7 @@ static const TSSymbol ts_symbol_map[] = { [sym_type_parameter_list] = sym_type_parameter_list, [sym_type_parameter] = sym_type_parameter, [sym_union_type] = sym_union_type, + [sym_type_alias] = sym_type_alias, [sym_variant] = sym_variant, [sym_record_type] = sym_record_type, [sym_field_declarations] = sym_field_declarations, @@ -487,11 +571,24 @@ static const TSSymbol ts_symbol_map[] = { [sym_list_pattern] = sym_list_pattern, [sym_field_pattern] = sym_field_pattern, [sym_module_declaration] = sym_module_declaration, - [sym_module_statement] = sym_module_statement, + [sym_signature_ascription] = sym_signature_ascription, + [sym_module_item] = sym_module_item, + [sym_export_declaration] = sym_export_declaration, + [sym__module_declaration] = sym__module_declaration, + [sym_signature_declaration] = sym_signature_declaration, + [sym_signature_item] = sym_signature_item, + [sym_signature_value] = sym_signature_value, + [sym_signature_function] = sym_signature_function, + [sym_signature_type] = sym_signature_type, + [sym_signature_module] = sym_signature_module, + [sym_qualified_path] = sym_qualified_path, + [sym_symbol_path] = sym_symbol_path, [sym_boolean] = sym_boolean, [sym_doc_comment] = sym_doc_comment, [aux_sym_source_file_repeat1] = aux_sym_source_file_repeat1, - [aux_sym_import_statement_repeat1] = aux_sym_import_statement_repeat1, + [aux_sym_legacy_import_path_repeat1] = aux_sym_legacy_import_path_repeat1, + [aux_sym_import_target_repeat1] = aux_sym_import_target_repeat1, + [aux_sym_import_member_list_repeat1] = aux_sym_import_member_list_repeat1, [aux_sym_extern_parameter_list_repeat1] = aux_sym_extern_parameter_list_repeat1, [aux_sym_parameter_list_repeat1] = aux_sym_parameter_list_repeat1, [aux_sym_type_parameter_list_repeat1] = aux_sym_type_parameter_list_repeat1, @@ -512,6 +609,8 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_list_pattern_repeat1] = aux_sym_list_pattern_repeat1, [aux_sym_field_pattern_repeat1] = aux_sym_field_pattern_repeat1, [aux_sym_module_declaration_repeat1] = aux_sym_module_declaration_repeat1, + [aux_sym_signature_declaration_repeat1] = aux_sym_signature_declaration_repeat1, + [aux_sym_qualified_path_repeat1] = aux_sym_qualified_path_repeat1, [aux_sym_doc_comment_repeat1] = aux_sym_doc_comment_repeat1, }; @@ -532,6 +631,38 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_COLON_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_as] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_namespace] = { + .visible = true, + .named = false, + }, + [anon_sym_SEMI] = { + .visible = true, + .named = false, + }, [anon_sym_let] = { .visible = true, .named = false, @@ -576,10 +707,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, - [anon_sym_COMMA] = { - .visible = true, - .named = false, - }, [anon_sym_type] = { .visible = true, .named = false, @@ -596,14 +723,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, - [anon_sym_LBRACE] = { - .visible = true, - .named = false, - }, - [anon_sym_RBRACE] = { - .visible = true, - .named = false, - }, [anon_sym_where] = { .visible = true, .named = false, @@ -684,10 +803,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, - [anon_sym_STAR] = { - .visible = true, - .named = false, - }, [anon_sym_SLASH] = { .visible = true, .named = false, @@ -740,10 +855,30 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_state] = { + .visible = true, + .named = false, + }, [anon_sym_module] = { .visible = true, .named = false, }, + [anon_sym_extra] = { + .visible = true, + .named = false, + }, + [anon_sym_export] = { + .visible = true, + .named = false, + }, + [anon_sym_opaque] = { + .visible = true, + .named = false, + }, + [anon_sym_signature] = { + .visible = true, + .named = false, + }, [anon_sym_true] = { .visible = true, .named = false, @@ -788,6 +923,38 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_legacy_import_path] = { + .visible = true, + .named = true, + }, + [sym_import_target] = { + .visible = true, + .named = true, + }, + [sym_import_tail] = { + .visible = true, + .named = true, + }, + [sym_import_member_list] = { + .visible = true, + .named = true, + }, + [sym_import_member] = { + .visible = true, + .named = true, + }, + [sym_namespace_name] = { + .visible = true, + .named = true, + }, + [sym_namespace_declaration] = { + .visible = true, + .named = true, + }, + [sym_namespace_body] = { + .visible = true, + .named = true, + }, [sym_let_declaration] = { .visible = true, .named = true, @@ -836,6 +1003,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_type_alias] = { + .visible = true, + .named = true, + }, [sym_variant] = { .visible = true, .named = true, @@ -1068,7 +1239,51 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_module_statement] = { + [sym_signature_ascription] = { + .visible = true, + .named = true, + }, + [sym_module_item] = { + .visible = true, + .named = true, + }, + [sym_export_declaration] = { + .visible = true, + .named = true, + }, + [sym__module_declaration] = { + .visible = false, + .named = true, + }, + [sym_signature_declaration] = { + .visible = true, + .named = true, + }, + [sym_signature_item] = { + .visible = true, + .named = true, + }, + [sym_signature_value] = { + .visible = true, + .named = true, + }, + [sym_signature_function] = { + .visible = true, + .named = true, + }, + [sym_signature_type] = { + .visible = true, + .named = true, + }, + [sym_signature_module] = { + .visible = true, + .named = true, + }, + [sym_qualified_path] = { + .visible = true, + .named = true, + }, + [sym_symbol_path] = { .visible = true, .named = true, }, @@ -1084,7 +1299,15 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = false, }, - [aux_sym_import_statement_repeat1] = { + [aux_sym_legacy_import_path_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_import_target_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_import_member_list_repeat1] = { .visible = false, .named = false, }, @@ -1168,6 +1391,14 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = false, }, + [aux_sym_signature_declaration_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_qualified_path_repeat1] = { + .visible = false, + .named = false, + }, [aux_sym_doc_comment_repeat1] = { .visible = false, .named = false, @@ -1175,67 +1406,91 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { }; enum ts_field_identifiers { - field_alternative = 1, - field_binding = 2, - field_body = 3, - field_callee = 4, - field_condition = 5, - field_consequence = 6, - field_definition = 7, - field_effect = 8, - field_effects = 9, - field_element = 10, - field_else = 11, - field_index = 12, - field_key = 13, - field_keyword = 14, - field_left = 15, - field_member = 16, - field_name = 17, - field_operand = 18, - field_operation = 19, - field_operator = 20, - field_parameters = 21, - field_pattern = 22, - field_record = 23, - field_rest = 24, - field_return_type = 25, - field_right = 26, - field_then = 27, - field_type = 28, - field_type_parameters = 29, - field_value = 30, - field_variance = 31, + field_alias = 1, + field_alternative = 2, + field_binding = 3, + field_body = 4, + field_callee = 5, + field_condition = 6, + field_consequence = 7, + field_declaration = 8, + field_definition = 9, + field_effect = 10, + field_effects = 11, + field_element = 12, + field_else = 13, + field_extra = 14, + field_index = 15, + field_key = 16, + field_keyword = 17, + field_left = 18, + field_legacy_target = 19, + field_member = 20, + field_name = 21, + field_namespace = 22, + field_opaque = 23, + field_operand = 24, + field_operation = 25, + field_operator = 26, + field_parameters = 27, + field_path = 28, + field_pattern = 29, + field_record = 30, + field_rest = 31, + field_return_type = 32, + field_right = 33, + field_segment = 34, + field_signature = 35, + field_state = 36, + field_tail = 37, + field_target = 38, + field_then = 39, + field_type = 40, + field_type_parameters = 41, + field_value = 42, + field_variance = 43, }; static const char * const ts_field_names[] = { [0] = NULL, + [field_alias] = "alias", [field_alternative] = "alternative", [field_binding] = "binding", [field_body] = "body", [field_callee] = "callee", [field_condition] = "condition", [field_consequence] = "consequence", + [field_declaration] = "declaration", [field_definition] = "definition", [field_effect] = "effect", [field_effects] = "effects", [field_element] = "element", [field_else] = "else", + [field_extra] = "extra", [field_index] = "index", [field_key] = "key", [field_keyword] = "keyword", [field_left] = "left", + [field_legacy_target] = "legacy_target", [field_member] = "member", [field_name] = "name", + [field_namespace] = "namespace", + [field_opaque] = "opaque", [field_operand] = "operand", [field_operation] = "operation", [field_operator] = "operator", [field_parameters] = "parameters", + [field_path] = "path", [field_pattern] = "pattern", [field_record] = "record", [field_rest] = "rest", [field_return_type] = "return_type", [field_right] = "right", + [field_segment] = "segment", + [field_signature] = "signature", + [field_state] = "state", + [field_tail] = "tail", + [field_target] = "target", [field_then] = "then", [field_type] = "type", [field_type_parameters] = "type_parameters", @@ -1245,605 +1500,791 @@ static const char * const ts_field_names[] = { static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [1] = {.index = 0, .length = 1}, - [2] = {.index = 1, .length = 2}, - [3] = {.index = 3, .length = 2}, - [4] = {.index = 5, .length = 2}, - [5] = {.index = 7, .length = 3}, - [6] = {.index = 10, .length = 1}, - [7] = {.index = 11, .length = 2}, - [8] = {.index = 13, .length = 3}, - [9] = {.index = 16, .length = 2}, - [10] = {.index = 18, .length = 1}, - [11] = {.index = 19, .length = 2}, - [12] = {.index = 21, .length = 2}, - [13] = {.index = 23, .length = 1}, - [14] = {.index = 24, .length = 1}, - [15] = {.index = 25, .length = 1}, - [16] = {.index = 26, .length = 2}, - [17] = {.index = 28, .length = 1}, - [18] = {.index = 29, .length = 1}, - [19] = {.index = 30, .length = 2}, + [2] = {.index = 1, .length = 1}, + [3] = {.index = 2, .length = 1}, + [4] = {.index = 3, .length = 1}, + [5] = {.index = 4, .length = 2}, + [6] = {.index = 6, .length = 2}, + [7] = {.index = 8, .length = 2}, + [8] = {.index = 10, .length = 1}, + [9] = {.index = 11, .length = 2}, + [10] = {.index = 13, .length = 2}, + [11] = {.index = 15, .length = 2}, + [12] = {.index = 17, .length = 3}, + [13] = {.index = 20, .length = 1}, + [14] = {.index = 21, .length = 2}, + [15] = {.index = 23, .length = 1}, + [16] = {.index = 24, .length = 1}, + [17] = {.index = 25, .length = 2}, + [18] = {.index = 27, .length = 2}, + [19] = {.index = 29, .length = 3}, [20] = {.index = 32, .length = 2}, [21] = {.index = 34, .length = 1}, [22] = {.index = 35, .length = 2}, - [23] = {.index = 37, .length = 2}, - [24] = {.index = 39, .length = 1}, - [25] = {.index = 40, .length = 2}, - [26] = {.index = 42, .length = 2}, - [27] = {.index = 44, .length = 1}, - [28] = {.index = 45, .length = 2}, - [29] = {.index = 47, .length = 3}, - [30] = {.index = 50, .length = 3}, - [31] = {.index = 53, .length = 2}, - [32] = {.index = 55, .length = 4}, - [33] = {.index = 59, .length = 1}, - [34] = {.index = 60, .length = 2}, - [35] = {.index = 62, .length = 3}, - [36] = {.index = 65, .length = 3}, - [37] = {.index = 68, .length = 2}, - [38] = {.index = 70, .length = 2}, - [39] = {.index = 72, .length = 2}, - [40] = {.index = 74, .length = 2}, - [41] = {.index = 76, .length = 2}, - [42] = {.index = 78, .length = 2}, - [43] = {.index = 80, .length = 1}, - [44] = {.index = 81, .length = 1}, - [45] = {.index = 82, .length = 3}, - [46] = {.index = 85, .length = 3}, - [47] = {.index = 88, .length = 3}, - [48] = {.index = 91, .length = 4}, - [49] = {.index = 95, .length = 2}, - [50] = {.index = 97, .length = 3}, - [51] = {.index = 100, .length = 2}, - [52] = {.index = 102, .length = 3}, - [53] = {.index = 105, .length = 4}, - [54] = {.index = 109, .length = 2}, - [55] = {.index = 111, .length = 3}, - [56] = {.index = 114, .length = 3}, - [57] = {.index = 117, .length = 2}, - [58] = {.index = 119, .length = 1}, - [59] = {.index = 120, .length = 3}, - [60] = {.index = 123, .length = 3}, - [61] = {.index = 126, .length = 4}, - [62] = {.index = 130, .length = 4}, - [63] = {.index = 134, .length = 4}, - [64] = {.index = 138, .length = 3}, - [65] = {.index = 141, .length = 2}, - [66] = {.index = 143, .length = 1}, - [67] = {.index = 144, .length = 3}, - [68] = {.index = 147, .length = 3}, - [69] = {.index = 150, .length = 3}, - [70] = {.index = 153, .length = 4}, - [71] = {.index = 157, .length = 2}, - [72] = {.index = 159, .length = 3}, - [73] = {.index = 162, .length = 2}, - [74] = {.index = 164, .length = 3}, - [75] = {.index = 167, .length = 4}, - [76] = {.index = 171, .length = 4}, - [77] = {.index = 175, .length = 4}, - [78] = {.index = 179, .length = 4}, - [79] = {.index = 183, .length = 5}, - [80] = {.index = 188, .length = 3}, - [81] = {.index = 191, .length = 3}, - [82] = {.index = 194, .length = 3}, - [83] = {.index = 197, .length = 3}, - [84] = {.index = 200, .length = 4}, - [85] = {.index = 204, .length = 4}, - [86] = {.index = 208, .length = 4}, - [87] = {.index = 212, .length = 3}, - [88] = {.index = 215, .length = 4}, - [89] = {.index = 219, .length = 4}, - [90] = {.index = 223, .length = 4}, - [91] = {.index = 227, .length = 5}, - [92] = {.index = 232, .length = 5}, - [93] = {.index = 237, .length = 3}, - [94] = {.index = 240, .length = 4}, - [95] = {.index = 244, .length = 4}, - [96] = {.index = 248, .length = 4}, - [97] = {.index = 252, .length = 4}, - [98] = {.index = 256, .length = 5}, - [99] = {.index = 261, .length = 4}, - [100] = {.index = 265, .length = 5}, - [101] = {.index = 270, .length = 5}, - [102] = {.index = 275, .length = 5}, - [103] = {.index = 280, .length = 4}, - [104] = {.index = 284, .length = 4}, - [105] = {.index = 288, .length = 4}, - [106] = {.index = 292, .length = 5}, - [107] = {.index = 297, .length = 5}, - [108] = {.index = 302, .length = 5}, - [109] = {.index = 307, .length = 5}, - [110] = {.index = 312, .length = 6}, - [111] = {.index = 318, .length = 4}, - [112] = {.index = 322, .length = 5}, - [113] = {.index = 327, .length = 5}, - [114] = {.index = 332, .length = 5}, - [115] = {.index = 337, .length = 6}, - [116] = {.index = 343, .length = 5}, - [117] = {.index = 348, .length = 5}, - [118] = {.index = 353, .length = 6}, - [119] = {.index = 359, .length = 6}, + [23] = {.index = 37, .length = 1}, + [24] = {.index = 38, .length = 1}, + [25] = {.index = 39, .length = 2}, + [26] = {.index = 41, .length = 1}, + [27] = {.index = 42, .length = 1}, + [28] = {.index = 43, .length = 1}, + [29] = {.index = 44, .length = 2}, + [30] = {.index = 46, .length = 2}, + [31] = {.index = 48, .length = 1}, + [32] = {.index = 49, .length = 2}, + [33] = {.index = 51, .length = 1}, + [34] = {.index = 52, .length = 2}, + [35] = {.index = 54, .length = 2}, + [36] = {.index = 56, .length = 2}, + [37] = {.index = 58, .length = 2}, + [38] = {.index = 60, .length = 1}, + [39] = {.index = 61, .length = 2}, + [40] = {.index = 63, .length = 2}, + [41] = {.index = 65, .length = 1}, + [42] = {.index = 66, .length = 2}, + [43] = {.index = 68, .length = 3}, + [44] = {.index = 71, .length = 3}, + [45] = {.index = 74, .length = 2}, + [46] = {.index = 76, .length = 1}, + [47] = {.index = 77, .length = 4}, + [48] = {.index = 81, .length = 1}, + [49] = {.index = 82, .length = 2}, + [50] = {.index = 84, .length = 3}, + [51] = {.index = 87, .length = 3}, + [52] = {.index = 90, .length = 2}, + [53] = {.index = 92, .length = 2}, + [54] = {.index = 94, .length = 2}, + [55] = {.index = 96, .length = 2}, + [56] = {.index = 98, .length = 2}, + [57] = {.index = 100, .length = 3}, + [58] = {.index = 103, .length = 2}, + [59] = {.index = 105, .length = 1}, + [60] = {.index = 106, .length = 2}, + [61] = {.index = 108, .length = 2}, + [62] = {.index = 110, .length = 2}, + [63] = {.index = 112, .length = 1}, + [64] = {.index = 113, .length = 2}, + [65] = {.index = 115, .length = 2}, + [66] = {.index = 117, .length = 2}, + [67] = {.index = 119, .length = 1}, + [68] = {.index = 120, .length = 3}, + [69] = {.index = 123, .length = 3}, + [70] = {.index = 126, .length = 3}, + [71] = {.index = 129, .length = 4}, + [72] = {.index = 133, .length = 2}, + [73] = {.index = 135, .length = 3}, + [74] = {.index = 138, .length = 2}, + [75] = {.index = 140, .length = 3}, + [76] = {.index = 143, .length = 2}, + [77] = {.index = 145, .length = 2}, + [78] = {.index = 147, .length = 4}, + [79] = {.index = 151, .length = 2}, + [80] = {.index = 153, .length = 3}, + [81] = {.index = 156, .length = 3}, + [82] = {.index = 159, .length = 2}, + [83] = {.index = 161, .length = 3}, + [84] = {.index = 164, .length = 1}, + [85] = {.index = 165, .length = 3}, + [86] = {.index = 168, .length = 3}, + [87] = {.index = 171, .length = 4}, + [88] = {.index = 175, .length = 4}, + [89] = {.index = 179, .length = 4}, + [90] = {.index = 183, .length = 3}, + [91] = {.index = 186, .length = 2}, + [92] = {.index = 188, .length = 2}, + [93] = {.index = 190, .length = 2}, + [94] = {.index = 192, .length = 3}, + [95] = {.index = 195, .length = 1}, + [96] = {.index = 196, .length = 3}, + [97] = {.index = 199, .length = 3}, + [98] = {.index = 202, .length = 3}, + [99] = {.index = 205, .length = 4}, + [100] = {.index = 209, .length = 2}, + [101] = {.index = 211, .length = 3}, + [102] = {.index = 214, .length = 2}, + [103] = {.index = 216, .length = 3}, + [104] = {.index = 219, .length = 4}, + [105] = {.index = 223, .length = 4}, + [106] = {.index = 227, .length = 4}, + [107] = {.index = 231, .length = 4}, + [108] = {.index = 235, .length = 5}, + [109] = {.index = 240, .length = 3}, + [110] = {.index = 243, .length = 3}, + [111] = {.index = 246, .length = 2}, + [112] = {.index = 248, .length = 3}, + [113] = {.index = 251, .length = 3}, + [114] = {.index = 254, .length = 3}, + [115] = {.index = 257, .length = 3}, + [116] = {.index = 260, .length = 4}, + [117] = {.index = 264, .length = 4}, + [118] = {.index = 268, .length = 4}, + [119] = {.index = 272, .length = 3}, + [120] = {.index = 275, .length = 4}, + [121] = {.index = 279, .length = 4}, + [122] = {.index = 283, .length = 4}, + [123] = {.index = 287, .length = 5}, + [124] = {.index = 292, .length = 5}, + [125] = {.index = 297, .length = 3}, + [126] = {.index = 300, .length = 3}, + [127] = {.index = 303, .length = 3}, + [128] = {.index = 306, .length = 4}, + [129] = {.index = 310, .length = 4}, + [130] = {.index = 314, .length = 4}, + [131] = {.index = 318, .length = 4}, + [132] = {.index = 322, .length = 5}, + [133] = {.index = 327, .length = 4}, + [134] = {.index = 331, .length = 5}, + [135] = {.index = 336, .length = 5}, + [136] = {.index = 341, .length = 5}, + [137] = {.index = 346, .length = 3}, + [138] = {.index = 349, .length = 3}, + [139] = {.index = 352, .length = 4}, + [140] = {.index = 356, .length = 4}, + [141] = {.index = 360, .length = 4}, + [142] = {.index = 364, .length = 4}, + [143] = {.index = 368, .length = 4}, + [144] = {.index = 372, .length = 5}, + [145] = {.index = 377, .length = 5}, + [146] = {.index = 382, .length = 5}, + [147] = {.index = 387, .length = 5}, + [148] = {.index = 392, .length = 6}, + [149] = {.index = 398, .length = 3}, + [150] = {.index = 401, .length = 4}, + [151] = {.index = 405, .length = 4}, + [152] = {.index = 409, .length = 5}, + [153] = {.index = 414, .length = 5}, + [154] = {.index = 419, .length = 5}, + [155] = {.index = 424, .length = 6}, + [156] = {.index = 430, .length = 4}, + [157] = {.index = 434, .length = 4}, + [158] = {.index = 438, .length = 5}, + [159] = {.index = 443, .length = 5}, + [160] = {.index = 448, .length = 6}, + [161] = {.index = 454, .length = 5}, + [162] = {.index = 459, .length = 6}, }; static const TSFieldMapEntry ts_field_map_entries[] = { [0] = - {field_name, 0}, + {field_legacy_target, 1}, [1] = + {field_target, 1}, + [2] = + {field_namespace, 0}, + [3] = + {field_name, 0}, + [4] = {field_operand, 1}, {field_operator, 0}, - [3] = + [6] = + {field_tail, 2}, + {field_target, 1}, + [8] = + {field_namespace, 0}, + {field_segment, 1, .inherited = true}, + [10] = + {field_name, 1}, + [11] = + {field_body, 2}, + {field_name, 1}, + [13] = {field_name, 0}, {field_value, 2}, - [5] = + [15] = {field_callee, 0}, {field_member, 2}, - [7] = + [17] = {field_left, 0}, {field_operator, 1}, {field_right, 2}, - [10] = + [20] = {field_callee, 0}, - [11] = + [21] = {field_left, 0}, {field_right, 2}, - [13] = + [23] = + {field_alias, 1}, + [24] = + {field_segment, 1}, + [25] = + {field_segment, 0, .inherited = true}, + {field_segment, 1, .inherited = true}, + [27] = + {field_key, 0}, + {field_value, 2}, + [29] = {field_keyword, 0}, {field_name, 1}, {field_value, 3}, - [16] = + [32] = {field_definition, 3}, {field_name, 1}, - [18] = + [34] = {field_body, 3}, - [19] = + [35] = {field_name, 0}, {field_type, 2}, - [21] = - {field_key, 0}, - {field_value, 2}, - [23] = - {field_name, 1}, - [24] = + [37] = {field_value, 1}, - [25] = + [38] = {field_operator, 0}, - [26] = + [39] = {field_binding, 1}, {field_name, 0}, - [28] = + [41] = {field_value, 2}, - [29] = + [42] = + {field_path, 1}, + [43] = {field_record, 0}, - [30] = + [44] = {field_condition, 0}, {field_else, 3}, - [32] = + [46] = {field_callee, 0}, {field_index, 2}, - [34] = + [48] = + {field_name, 2}, + [49] = + {field_body, 3}, + {field_name, 2}, + [51] = {field_body, 4}, - [35] = + [52] = {field_name, 1}, {field_variance, 0}, - [37] = + [54] = {field_body, 4}, {field_name, 1}, - [39] = - {field_name, 2}, - [40] = + [56] = {field_body, 2}, {field_operation, 0}, - [42] = + [58] = {field_body, 4}, {field_effect, 1}, - [44] = + [60] = {field_element, 1}, - [45] = + [61] = {field_body, 2}, {field_pattern, 0}, - [47] = + [63] = + {field_path, 2}, + {field_state, 0}, + [65] = + {field_declaration, 1}, + [66] = + {field_path, 1}, + {field_signature, 2}, + [68] = {field_condition, 0}, {field_else, 4}, {field_then, 2}, - [50] = + [71] = {field_keyword, 1}, {field_name, 2}, {field_value, 4}, - [53] = + [74] = {field_definition, 4}, {field_name, 2}, - [55] = + [76] = + {field_path, 2}, + [77] = {field_keyword, 0}, {field_name, 1}, {field_type, 3}, {field_value, 5}, - [59] = + [81] = {field_body, 5}, - [60] = + [82] = {field_body, 5}, {field_name, 1}, - [62] = + [84] = {field_body, 5}, {field_effects, 4}, {field_name, 1}, - [65] = + [87] = {field_body, 5}, {field_name, 1}, {field_parameters, 3}, - [68] = + [90] = {field_name, 2}, {field_parameters, 4}, - [70] = + [92] = {field_body, 3}, {field_operation, 0}, - [72] = + [94] = {field_element, 1}, {field_element, 2, .inherited = true}, - [74] = + [96] = {field_element, 0, .inherited = true}, {field_element, 1, .inherited = true}, - [76] = + [98] = {field_effect, 1}, {field_operation, 3}, - [78] = + [100] = + {field_path, 2}, + {field_signature, 3}, + {field_state, 0}, + [103] = + {field_declaration, 2}, + {field_opaque, 1}, + [105] = + {field_declaration, 2}, + [106] = + {field_extra, 3}, + {field_path, 1}, + [108] = + {field_name, 2}, + {field_opaque, 0}, + [110] = {field_body, 5}, {field_name, 2}, - [80] = + [112] = {field_name, 3}, - [81] = + [113] = + {field_path, 3}, + {field_state, 1}, + [115] = + {field_path, 2}, + {field_signature, 3}, + [117] = + {field_alias, 2}, + {field_name, 0}, + [119] = {field_body, 6}, - [82] = + [120] = {field_body, 6}, {field_name, 1}, {field_return_type, 5}, - [85] = + [123] = {field_body, 6}, {field_effects, 4}, {field_name, 1}, - [88] = + [126] = {field_body, 6}, {field_name, 1}, {field_parameters, 3}, - [91] = + [129] = {field_body, 6}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [95] = + [133] = {field_name, 2}, {field_return_type, 6}, - [97] = + [135] = {field_definition, 6}, {field_name, 1}, {field_type_parameters, 3}, - [100] = + [138] = {field_name, 1}, {field_type_parameters, 3}, - [102] = + [140] = {field_alternative, 6}, {field_condition, 1}, {field_consequence, 3}, - [105] = + [143] = + {field_declaration, 3}, + {field_opaque, 2}, + [145] = + {field_name, 1}, + {field_type, 3}, + [147] = {field_keyword, 1}, {field_name, 2}, {field_type, 4}, {field_value, 6}, - [109] = + [151] = {field_body, 6}, {field_name, 2}, - [111] = + [153] = {field_body, 6}, {field_effects, 5}, {field_name, 2}, - [114] = + [156] = {field_body, 6}, {field_name, 2}, {field_parameters, 4}, - [117] = + [159] = {field_name, 3}, {field_parameters, 5}, - [119] = + [161] = + {field_path, 3}, + {field_signature, 4}, + {field_state, 1}, + [164] = {field_body, 7}, - [120] = + [165] = {field_body, 7}, {field_name, 1}, {field_type_parameters, 3}, - [123] = + [168] = {field_body, 7}, {field_name, 1}, {field_return_type, 5}, - [126] = + [171] = {field_body, 7}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [130] = + [175] = {field_body, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [134] = + [179] = {field_body, 7}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [138] = + [183] = {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [141] = + [186] = {field_element, 1}, {field_rest, 4}, - [143] = + [188] = + {field_effects, 4}, + {field_name, 1}, + [190] = + {field_name, 1}, + {field_parameters, 3}, + [192] = + {field_definition, 4}, + {field_name, 2}, + {field_opaque, 0}, + [195] = {field_condition, 0}, - [144] = + [196] = {field_body, 7}, {field_name, 2}, {field_return_type, 6}, - [147] = + [199] = {field_body, 7}, {field_effects, 5}, {field_name, 2}, - [150] = + [202] = {field_body, 7}, {field_name, 2}, {field_parameters, 4}, - [153] = + [205] = {field_body, 7}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [157] = + [209] = {field_name, 3}, {field_return_type, 7}, - [159] = + [211] = {field_definition, 7}, {field_name, 2}, {field_type_parameters, 4}, - [162] = + [214] = {field_name, 2}, {field_type_parameters, 4}, - [164] = + [216] = {field_body, 8}, {field_name, 1}, {field_type_parameters, 3}, - [167] = + [219] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [171] = + [223] = {field_body, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [175] = + [227] = {field_body, 8}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [179] = + [231] = {field_body, 8}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [183] = + [235] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [188] = + [240] = {field_alternative, 7}, {field_condition, 1}, {field_consequence, 3}, - [191] = + [243] = {field_element, 1}, {field_element, 2, .inherited = true}, {field_rest, 5}, - [194] = + [246] = + {field_name, 1}, + {field_return_type, 5}, + [248] = + {field_effects, 5}, + {field_name, 1}, + {field_parameters, 3}, + [251] = + {field_name, 2}, + {field_opaque, 0}, + {field_type_parameters, 4}, + [254] = {field_body, 8}, {field_name, 2}, {field_type_parameters, 4}, - [197] = + [257] = {field_body, 8}, {field_name, 2}, {field_return_type, 6}, - [200] = + [260] = {field_body, 8}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [204] = + [264] = {field_body, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [208] = + [268] = {field_body, 8}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [212] = + [272] = {field_name, 3}, {field_parameters, 5}, {field_return_type, 8}, - [215] = + [275] = {field_body, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [219] = + [279] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [223] = + [283] = {field_body, 9}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [227] = + [287] = {field_body, 9}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [232] = + [292] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [237] = + [297] = + {field_effects, 6}, + {field_name, 1}, + {field_return_type, 5}, + [300] = + {field_name, 1}, + {field_parameters, 3}, + {field_return_type, 6}, + [303] = {field_body, 9}, {field_name, 2}, {field_type_parameters, 4}, - [240] = + [306] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [244] = + [310] = {field_body, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [248] = + [314] = {field_body, 9}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [252] = + [318] = {field_body, 9}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [256] = + [322] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [261] = + [327] = {field_body, 10}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [265] = + [331] = {field_body, 10}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [270] = + [336] = {field_body, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [275] = + [341] = {field_body, 10}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [280] = + [346] = + {field_effects, 7}, + {field_name, 1}, + {field_type_parameters, 3}, + [349] = + {field_name, 1}, + {field_parameters, 6}, + {field_type_parameters, 3}, + [352] = + {field_effects, 7}, + {field_name, 1}, + {field_parameters, 3}, + {field_return_type, 6}, + [356] = + {field_definition, 7}, + {field_name, 2}, + {field_opaque, 0}, + {field_type_parameters, 4}, + [360] = {field_body, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [284] = + [364] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [288] = + [368] = {field_body, 10}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [292] = + [372] = {field_body, 10}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [297] = + [377] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [302] = + [382] = {field_body, 11}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [307] = + [387] = {field_body, 11}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [312] = + [392] = {field_body, 11}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [318] = + [398] = + {field_name, 1}, + {field_return_type, 8}, + {field_type_parameters, 3}, + [401] = + {field_effects, 8}, + {field_name, 1}, + {field_parameters, 6}, + {field_type_parameters, 3}, + [405] = {field_body, 11}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [322] = + [409] = {field_body, 11}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [327] = + [414] = {field_body, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [332] = + [419] = {field_body, 11}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [337] = + [424] = {field_body, 12}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [343] = + [430] = + {field_effects, 9}, + {field_name, 1}, + {field_return_type, 8}, + {field_type_parameters, 3}, + [434] = + {field_name, 1}, + {field_parameters, 6}, + {field_return_type, 9}, + {field_type_parameters, 3}, + [438] = {field_body, 12}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [348] = + [443] = {field_body, 12}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [353] = + [448] = {field_body, 12}, {field_effects, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [359] = + [454] = + {field_effects, 10}, + {field_name, 1}, + {field_parameters, 6}, + {field_return_type, 9}, + {field_type_parameters, 3}, + [459] = {field_body, 13}, {field_effects, 11}, {field_name, 2}, @@ -1864,44 +2305,44 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [0] = 0, [1] = 1, [2] = 2, - [3] = 3, - [4] = 3, - [5] = 3, - [6] = 2, - [7] = 7, + [3] = 2, + [4] = 2, + [5] = 5, + [6] = 6, + [7] = 6, [8] = 8, - [9] = 8, + [9] = 9, [10] = 10, [11] = 11, - [12] = 2, - [13] = 7, - [14] = 7, - [15] = 11, - [16] = 7, - [17] = 7, - [18] = 11, - [19] = 2, - [20] = 20, - [21] = 21, - [22] = 21, - [23] = 20, - [24] = 21, - [25] = 20, + [12] = 12, + [13] = 8, + [14] = 6, + [15] = 9, + [16] = 11, + [17] = 10, + [18] = 6, + [19] = 5, + [20] = 6, + [21] = 11, + [22] = 5, + [23] = 5, + [24] = 24, + [25] = 25, [26] = 26, - [27] = 26, - [28] = 28, - [29] = 29, + [27] = 27, + [28] = 26, + [29] = 25, [30] = 30, - [31] = 30, + [31] = 25, [32] = 32, [33] = 26, - [34] = 30, - [35] = 32, - [36] = 26, + [34] = 34, + [35] = 34, + [36] = 36, [37] = 32, - [38] = 29, - [39] = 29, - [40] = 40, + [38] = 24, + [39] = 39, + [40] = 30, [41] = 41, [42] = 42, [43] = 43, @@ -1918,40 +2359,40 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [54] = 54, [55] = 55, [56] = 56, - [57] = 57, + [57] = 39, [58] = 58, [59] = 59, [60] = 60, - [61] = 61, + [61] = 36, [62] = 62, [63] = 63, [64] = 64, [65] = 65, [66] = 66, - [67] = 67, + [67] = 65, [68] = 68, [69] = 69, - [70] = 70, - [71] = 71, + [70] = 69, + [71] = 47, [72] = 72, [73] = 73, [74] = 74, [75] = 75, [76] = 76, - [77] = 77, + [77] = 65, [78] = 78, [79] = 79, - [80] = 80, + [80] = 69, [81] = 81, - [82] = 82, + [82] = 47, [83] = 83, [84] = 84, [85] = 85, - [86] = 86, + [86] = 47, [87] = 87, [88] = 88, - [89] = 89, - [90] = 90, + [89] = 88, + [90] = 88, [91] = 91, [92] = 92, [93] = 93, @@ -1961,276 +2402,276 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [97] = 97, [98] = 98, [99] = 99, - [100] = 41, - [101] = 43, + [100] = 100, + [101] = 101, [102] = 102, [103] = 103, [104] = 104, [105] = 105, [106] = 106, - [107] = 44, - [108] = 46, - [109] = 48, - [110] = 52, - [111] = 53, - [112] = 54, - [113] = 55, - [114] = 56, - [115] = 61, - [116] = 62, - [117] = 63, - [118] = 64, - [119] = 65, - [120] = 66, - [121] = 67, - [122] = 68, - [123] = 70, - [124] = 71, - [125] = 72, - [126] = 73, - [127] = 74, - [128] = 75, - [129] = 77, - [130] = 78, - [131] = 79, - [132] = 80, - [133] = 81, - [134] = 82, - [135] = 83, - [136] = 84, - [137] = 85, - [138] = 86, - [139] = 87, - [140] = 88, - [141] = 89, - [142] = 90, - [143] = 91, - [144] = 92, - [145] = 93, - [146] = 94, - [147] = 95, - [148] = 96, - [149] = 97, - [150] = 99, - [151] = 41, - [152] = 43, - [153] = 102, - [154] = 103, - [155] = 104, - [156] = 105, - [157] = 106, - [158] = 44, - [159] = 46, + [107] = 107, + [108] = 108, + [109] = 109, + [110] = 110, + [111] = 111, + [112] = 112, + [113] = 113, + [114] = 114, + [115] = 115, + [116] = 116, + [117] = 92, + [118] = 118, + [119] = 119, + [120] = 120, + [121] = 121, + [122] = 122, + [123] = 123, + [124] = 124, + [125] = 125, + [126] = 126, + [127] = 127, + [128] = 128, + [129] = 129, + [130] = 130, + [131] = 131, + [132] = 132, + [133] = 133, + [134] = 134, + [135] = 135, + [136] = 136, + [137] = 137, + [138] = 138, + [139] = 139, + [140] = 140, + [141] = 141, + [142] = 142, + [143] = 143, + [144] = 144, + [145] = 145, + [146] = 146, + [147] = 147, + [148] = 148, + [149] = 149, + [150] = 150, + [151] = 151, + [152] = 152, + [153] = 153, + [154] = 46, + [155] = 78, + [156] = 60, + [157] = 62, + [158] = 158, + [159] = 48, [160] = 160, - [161] = 52, - [162] = 53, - [163] = 54, - [164] = 55, - [165] = 56, - [166] = 61, - [167] = 62, - [168] = 63, - [169] = 64, - [170] = 65, - [171] = 66, - [172] = 67, - [173] = 68, - [174] = 70, - [175] = 71, - [176] = 72, - [177] = 73, - [178] = 74, - [179] = 75, - [180] = 77, - [181] = 78, - [182] = 79, - [183] = 80, - [184] = 81, - [185] = 82, - [186] = 83, - [187] = 84, - [188] = 85, - [189] = 86, - [190] = 87, - [191] = 88, - [192] = 89, - [193] = 90, - [194] = 91, - [195] = 92, - [196] = 93, + [161] = 161, + [162] = 68, + [163] = 163, + [164] = 164, + [165] = 165, + [166] = 91, + [167] = 167, + [168] = 168, + [169] = 96, + [170] = 97, + [171] = 99, + [172] = 100, + [173] = 173, + [174] = 55, + [175] = 56, + [176] = 58, + [177] = 153, + [178] = 63, + [179] = 158, + [180] = 64, + [181] = 66, + [182] = 72, + [183] = 183, + [184] = 184, + [185] = 73, + [186] = 186, + [187] = 187, + [188] = 188, + [189] = 189, + [190] = 74, + [191] = 75, + [192] = 76, + [193] = 193, + [194] = 194, + [195] = 79, + [196] = 81, [197] = 94, - [198] = 95, - [199] = 96, - [200] = 97, - [201] = 99, - [202] = 41, + [198] = 83, + [199] = 199, + [200] = 85, + [201] = 87, + [202] = 42, [203] = 43, - [204] = 102, + [204] = 204, [205] = 103, - [206] = 104, - [207] = 106, - [208] = 44, - [209] = 46, - [210] = 48, - [211] = 52, - [212] = 55, - [213] = 61, - [214] = 66, - [215] = 70, - [216] = 102, - [217] = 57, - [218] = 103, - [219] = 219, - [220] = 45, - [221] = 104, - [222] = 222, - [223] = 223, - [224] = 224, - [225] = 57, - [226] = 219, - [227] = 219, - [228] = 45, - [229] = 229, - [230] = 105, - [231] = 231, - [232] = 232, - [233] = 106, - [234] = 57, - [235] = 219, - [236] = 45, - [237] = 98, - [238] = 99, - [239] = 160, - [240] = 40, - [241] = 229, - [242] = 232, - [243] = 223, - [244] = 50, - [245] = 60, - [246] = 69, - [247] = 40, - [248] = 229, - [249] = 232, - [250] = 223, - [251] = 50, - [252] = 60, - [253] = 69, - [254] = 60, - [255] = 224, - [256] = 224, - [257] = 231, - [258] = 258, - [259] = 231, - [260] = 260, - [261] = 160, - [262] = 48, - [263] = 263, - [264] = 264, - [265] = 264, - [266] = 263, - [267] = 267, - [268] = 268, - [269] = 269, - [270] = 270, - [271] = 271, - [272] = 272, - [273] = 273, - [274] = 274, - [275] = 275, - [276] = 276, - [277] = 277, - [278] = 278, - [279] = 273, - [280] = 280, - [281] = 281, - [282] = 282, - [283] = 283, - [284] = 284, - [285] = 285, - [286] = 286, - [287] = 287, - [288] = 288, - [289] = 289, - [290] = 290, - [291] = 291, - [292] = 267, - [293] = 293, - [294] = 294, - [295] = 295, - [296] = 296, - [297] = 297, - [298] = 298, - [299] = 270, - [300] = 271, - [301] = 274, - [302] = 277, - [303] = 298, - [304] = 304, - [305] = 305, - [306] = 306, - [307] = 307, - [308] = 291, - [309] = 304, - [310] = 310, - [311] = 278, - [312] = 306, - [313] = 281, - [314] = 314, - [315] = 310, - [316] = 304, - [317] = 317, - [318] = 318, - [319] = 319, - [320] = 275, - [321] = 269, - [322] = 322, - [323] = 323, - [324] = 324, - [325] = 294, - [326] = 295, - [327] = 276, - [328] = 286, - [329] = 296, - [330] = 297, + [206] = 44, + [207] = 45, + [208] = 104, + [209] = 105, + [210] = 210, + [211] = 106, + [212] = 108, + [213] = 41, + [214] = 214, + [215] = 49, + [216] = 216, + [217] = 113, + [218] = 218, + [219] = 114, + [220] = 115, + [221] = 50, + [222] = 51, + [223] = 118, + [224] = 119, + [225] = 225, + [226] = 120, + [227] = 121, + [228] = 122, + [229] = 52, + [230] = 53, + [231] = 125, + [232] = 126, + [233] = 127, + [234] = 234, + [235] = 128, + [236] = 129, + [237] = 130, + [238] = 238, + [239] = 132, + [240] = 133, + [241] = 134, + [242] = 135, + [243] = 136, + [244] = 54, + [245] = 137, + [246] = 138, + [247] = 139, + [248] = 140, + [249] = 141, + [250] = 142, + [251] = 143, + [252] = 144, + [253] = 145, + [254] = 146, + [255] = 147, + [256] = 148, + [257] = 149, + [258] = 150, + [259] = 151, + [260] = 152, + [261] = 261, + [262] = 167, + [263] = 168, + [264] = 96, + [265] = 97, + [266] = 99, + [267] = 100, + [268] = 153, + [269] = 158, + [270] = 186, + [271] = 193, + [272] = 94, + [273] = 103, + [274] = 104, + [275] = 105, + [276] = 106, + [277] = 108, + [278] = 113, + [279] = 114, + [280] = 115, + [281] = 118, + [282] = 119, + [283] = 120, + [284] = 121, + [285] = 122, + [286] = 125, + [287] = 126, + [288] = 127, + [289] = 128, + [290] = 129, + [291] = 130, + [292] = 132, + [293] = 133, + [294] = 134, + [295] = 135, + [296] = 136, + [297] = 137, + [298] = 138, + [299] = 139, + [300] = 140, + [301] = 141, + [302] = 142, + [303] = 143, + [304] = 144, + [305] = 145, + [306] = 146, + [307] = 147, + [308] = 148, + [309] = 149, + [310] = 150, + [311] = 151, + [312] = 152, + [313] = 313, + [314] = 167, + [315] = 168, + [316] = 96, + [317] = 97, + [318] = 99, + [319] = 100, + [320] = 158, + [321] = 186, + [322] = 193, + [323] = 94, + [324] = 103, + [325] = 106, + [326] = 113, + [327] = 120, + [328] = 125, + [329] = 329, + [330] = 91, [331] = 331, - [332] = 332, - [333] = 282, - [334] = 285, - [335] = 317, - [336] = 323, - [337] = 318, - [338] = 338, - [339] = 268, - [340] = 340, - [341] = 332, - [342] = 338, - [343] = 283, - [344] = 344, - [345] = 280, - [346] = 305, - [347] = 347, - [348] = 348, - [349] = 349, - [350] = 272, - [351] = 351, - [352] = 348, - [353] = 289, - [354] = 354, - [355] = 324, - [356] = 356, - [357] = 357, - [358] = 331, - [359] = 359, - [360] = 360, - [361] = 361, - [362] = 362, - [363] = 340, - [364] = 364, - [365] = 365, - [366] = 344, + [332] = 124, + [333] = 331, + [334] = 186, + [335] = 165, + [336] = 329, + [337] = 329, + [338] = 331, + [339] = 124, + [340] = 167, + [341] = 168, + [342] = 193, + [343] = 329, + [344] = 91, + [345] = 331, + [346] = 199, + [347] = 173, + [348] = 313, + [349] = 101, + [350] = 98, + [351] = 112, + [352] = 123, + [353] = 199, + [354] = 173, + [355] = 313, + [356] = 101, + [357] = 98, + [358] = 112, + [359] = 123, + [360] = 112, + [361] = 116, + [362] = 116, + [363] = 261, + [364] = 261, + [365] = 92, + [366] = 84, [367] = 367, [368] = 368, - [369] = 369, + [369] = 368, [370] = 370, [371] = 371, [372] = 372, @@ -2244,451 +2685,451 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [380] = 380, [381] = 381, [382] = 382, - [383] = 383, + [383] = 370, [384] = 384, - [385] = 385, + [385] = 204, [386] = 386, [387] = 387, - [388] = 388, + [388] = 374, [389] = 389, - [390] = 390, - [391] = 391, - [392] = 392, - [393] = 393, + [390] = 373, + [391] = 218, + [392] = 375, + [393] = 376, [394] = 394, [395] = 395, - [396] = 396, - [397] = 395, + [396] = 382, + [397] = 387, [398] = 398, - [399] = 354, - [400] = 356, - [401] = 398, - [402] = 359, - [403] = 360, - [404] = 284, - [405] = 361, - [406] = 362, - [407] = 364, - [408] = 365, - [409] = 367, - [410] = 368, - [411] = 369, - [412] = 370, - [413] = 371, - [414] = 287, - [415] = 372, - [416] = 288, - [417] = 373, - [418] = 290, - [419] = 374, - [420] = 375, - [421] = 376, - [422] = 377, - [423] = 378, - [424] = 379, - [425] = 380, - [426] = 381, - [427] = 382, - [428] = 383, - [429] = 385, - [430] = 386, - [431] = 387, - [432] = 388, - [433] = 389, - [434] = 390, - [435] = 391, - [436] = 392, - [437] = 396, - [438] = 393, - [439] = 293, - [440] = 347, - [441] = 349, - [442] = 351, - [443] = 307, - [444] = 314, - [445] = 384, - [446] = 357, - [447] = 319, - [448] = 384, - [449] = 384, - [450] = 384, - [451] = 394, - [452] = 322, - [453] = 357, - [454] = 454, - [455] = 455, + [399] = 394, + [400] = 395, + [401] = 401, + [402] = 398, + [403] = 401, + [404] = 371, + [405] = 405, + [406] = 406, + [407] = 372, + [408] = 408, + [409] = 405, + [410] = 410, + [411] = 406, + [412] = 412, + [413] = 367, + [414] = 414, + [415] = 415, + [416] = 416, + [417] = 417, + [418] = 408, + [419] = 419, + [420] = 420, + [421] = 421, + [422] = 422, + [423] = 389, + [424] = 424, + [425] = 410, + [426] = 412, + [427] = 216, + [428] = 414, + [429] = 415, + [430] = 416, + [431] = 417, + [432] = 419, + [433] = 420, + [434] = 421, + [435] = 422, + [436] = 436, + [437] = 161, + [438] = 379, + [439] = 225, + [440] = 377, + [441] = 378, + [442] = 163, + [443] = 424, + [444] = 164, + [445] = 183, + [446] = 446, + [447] = 184, + [448] = 214, + [449] = 380, + [450] = 381, + [451] = 187, + [452] = 188, + [453] = 446, + [454] = 189, + [455] = 371, [456] = 456, - [457] = 457, - [458] = 458, - [459] = 459, - [460] = 460, - [461] = 461, - [462] = 462, - [463] = 463, - [464] = 460, - [465] = 455, - [466] = 466, - [467] = 456, - [468] = 462, - [469] = 466, - [470] = 470, - [471] = 454, - [472] = 457, - [473] = 459, + [457] = 446, + [458] = 456, + [459] = 446, + [460] = 446, + [461] = 234, + [462] = 384, + [463] = 386, + [464] = 210, + [465] = 194, + [466] = 238, + [467] = 436, + [468] = 30, + [469] = 24, + [470] = 36, + [471] = 471, + [472] = 472, + [473] = 473, [474] = 474, - [475] = 458, + [475] = 475, [476] = 476, - [477] = 470, - [478] = 478, + [477] = 24, + [478] = 30, [479] = 479, [480] = 480, - [481] = 481, + [481] = 480, [482] = 482, [483] = 483, [484] = 484, - [485] = 485, + [485] = 483, [486] = 486, [487] = 487, [488] = 488, - [489] = 463, + [489] = 473, [490] = 490, [491] = 491, [492] = 492, [493] = 493, [494] = 494, - [495] = 490, - [496] = 474, - [497] = 476, - [498] = 498, + [495] = 494, + [496] = 496, + [497] = 497, + [498] = 36, [499] = 499, - [500] = 500, - [501] = 461, - [502] = 502, + [500] = 497, + [501] = 501, + [502] = 471, [503] = 503, - [504] = 494, + [504] = 504, [505] = 505, [506] = 506, [507] = 507, - [508] = 508, - [509] = 509, + [508] = 506, + [509] = 492, [510] = 510, [511] = 511, [512] = 512, [513] = 513, - [514] = 488, + [514] = 514, [515] = 515, [516] = 516, [517] = 517, [518] = 518, - [519] = 487, + [519] = 519, [520] = 520, - [521] = 521, + [521] = 487, [522] = 522, [523] = 523, - [524] = 492, + [524] = 524, [525] = 525, [526] = 526, - [527] = 499, + [527] = 527, [528] = 528, [529] = 529, [530] = 530, - [531] = 531, - [532] = 508, + [531] = 490, + [532] = 532, [533] = 533, [534] = 534, - [535] = 523, - [536] = 525, + [535] = 535, + [536] = 536, [537] = 537, - [538] = 538, + [538] = 479, [539] = 539, - [540] = 540, - [541] = 507, - [542] = 480, - [543] = 485, - [544] = 500, + [540] = 528, + [541] = 536, + [542] = 542, + [543] = 543, + [544] = 544, [545] = 545, [546] = 546, [547] = 547, - [548] = 521, - [549] = 478, + [548] = 548, + [549] = 549, [550] = 550, - [551] = 533, - [552] = 502, - [553] = 482, + [551] = 482, + [552] = 552, + [553] = 553, [554] = 554, [555] = 555, [556] = 556, - [557] = 540, + [557] = 539, [558] = 558, - [559] = 491, - [560] = 493, - [561] = 498, - [562] = 554, - [563] = 531, - [564] = 503, - [565] = 565, - [566] = 558, - [567] = 505, - [568] = 565, + [559] = 559, + [560] = 560, + [561] = 561, + [562] = 562, + [563] = 563, + [564] = 564, + [565] = 561, + [566] = 563, + [567] = 567, + [568] = 568, [569] = 569, - [570] = 509, + [570] = 491, [571] = 571, [572] = 572, - [573] = 510, - [574] = 511, - [575] = 512, - [576] = 513, - [577] = 515, - [578] = 516, - [579] = 579, - [580] = 517, + [573] = 573, + [574] = 574, + [575] = 575, + [576] = 576, + [577] = 484, + [578] = 486, + [579] = 576, + [580] = 580, [581] = 581, - [582] = 518, - [583] = 572, - [584] = 520, - [585] = 522, - [586] = 526, - [587] = 528, - [588] = 529, - [589] = 530, - [590] = 506, - [591] = 479, - [592] = 555, - [593] = 481, - [594] = 483, - [595] = 484, - [596] = 268, - [597] = 579, - [598] = 486, - [599] = 581, - [600] = 263, + [582] = 582, + [583] = 583, + [584] = 584, + [585] = 585, + [586] = 586, + [587] = 587, + [588] = 588, + [589] = 589, + [590] = 590, + [591] = 591, + [592] = 592, + [593] = 593, + [594] = 594, + [595] = 595, + [596] = 472, + [597] = 597, + [598] = 598, + [599] = 599, + [600] = 501, [601] = 601, - [602] = 601, - [603] = 603, - [604] = 545, - [605] = 546, - [606] = 547, - [607] = 556, - [608] = 569, - [609] = 277, - [610] = 539, - [611] = 295, - [612] = 277, - [613] = 295, - [614] = 537, - [615] = 603, - [616] = 534, - [617] = 550, - [618] = 538, - [619] = 571, - [620] = 296, - [621] = 275, - [622] = 338, - [623] = 269, - [624] = 322, - [625] = 290, - [626] = 331, - [627] = 291, - [628] = 347, - [629] = 277, - [630] = 344, - [631] = 282, - [632] = 348, - [633] = 332, - [634] = 283, - [635] = 293, - [636] = 284, - [637] = 278, - [638] = 273, - [639] = 294, - [640] = 295, - [641] = 349, - [642] = 285, - [643] = 314, - [644] = 317, - [645] = 272, - [646] = 323, - [647] = 287, - [648] = 310, - [649] = 297, - [650] = 351, - [651] = 280, - [652] = 270, - [653] = 276, - [654] = 271, - [655] = 286, - [656] = 318, - [657] = 274, - [658] = 267, - [659] = 319, - [660] = 281, - [661] = 340, - [662] = 298, - [663] = 288, - [664] = 306, - [665] = 307, - [666] = 305, - [667] = 324, - [668] = 289, - [669] = 669, - [670] = 670, - [671] = 284, - [672] = 393, - [673] = 287, - [674] = 288, - [675] = 289, - [676] = 290, - [677] = 293, - [678] = 307, - [679] = 314, - [680] = 319, - [681] = 322, - [682] = 324, - [683] = 331, - [684] = 340, - [685] = 344, - [686] = 347, - [687] = 349, - [688] = 351, - [689] = 396, - [690] = 398, - [691] = 354, - [692] = 356, - [693] = 359, - [694] = 360, - [695] = 361, - [696] = 362, - [697] = 364, - [698] = 365, - [699] = 368, - [700] = 369, - [701] = 370, - [702] = 371, - [703] = 372, - [704] = 373, - [705] = 374, - [706] = 375, - [707] = 376, - [708] = 377, - [709] = 378, - [710] = 379, - [711] = 380, - [712] = 381, - [713] = 382, - [714] = 383, - [715] = 385, - [716] = 386, - [717] = 387, - [718] = 388, - [719] = 389, - [720] = 390, - [721] = 391, - [722] = 392, - [723] = 367, - [724] = 724, - [725] = 725, - [726] = 726, - [727] = 727, - [728] = 726, - [729] = 729, - [730] = 726, - [731] = 731, - [732] = 732, - [733] = 733, - [734] = 734, - [735] = 735, - [736] = 736, - [737] = 737, - [738] = 738, - [739] = 737, - [740] = 737, - [741] = 741, - [742] = 742, - [743] = 743, - [744] = 743, - [745] = 745, - [746] = 746, - [747] = 738, - [748] = 748, - [749] = 749, - [750] = 748, - [751] = 742, - [752] = 752, - [753] = 753, - [754] = 754, - [755] = 748, - [756] = 749, - [757] = 749, - [758] = 753, - [759] = 745, - [760] = 738, - [761] = 741, - [762] = 742, - [763] = 743, - [764] = 738, - [765] = 742, - [766] = 741, - [767] = 753, - [768] = 752, - [769] = 754, - [770] = 752, - [771] = 754, - [772] = 745, - [773] = 773, - [774] = 774, - [775] = 774, - [776] = 776, - [777] = 776, - [778] = 778, - [779] = 776, - [780] = 774, - [781] = 778, - [782] = 778, - [783] = 783, - [784] = 783, - [785] = 785, - [786] = 786, - [787] = 786, - [788] = 786, - [789] = 783, - [790] = 790, - [791] = 791, - [792] = 791, - [793] = 791, - [794] = 794, - [795] = 795, - [796] = 796, - [797] = 797, - [798] = 798, - [799] = 799, - [800] = 487, - [801] = 801, - [802] = 802, - [803] = 803, - [804] = 804, - [805] = 805, - [806] = 805, - [807] = 802, - [808] = 803, - [809] = 801, - [810] = 545, - [811] = 569, - [812] = 547, - [813] = 546, - [814] = 556, - [815] = 815, - [816] = 816, - [817] = 816, - [818] = 816, - [819] = 815, - [820] = 815, - [821] = 821, - [822] = 822, - [823] = 821, - [824] = 824, + [602] = 599, + [603] = 488, + [604] = 476, + [605] = 597, + [606] = 510, + [607] = 507, + [608] = 475, + [609] = 598, + [610] = 601, + [611] = 474, + [612] = 612, + [613] = 503, + [614] = 612, + [615] = 504, + [616] = 616, + [617] = 617, + [618] = 618, + [619] = 619, + [620] = 620, + [621] = 621, + [622] = 617, + [623] = 621, + [624] = 624, + [625] = 616, + [626] = 626, + [627] = 627, + [628] = 628, + [629] = 618, + [630] = 619, + [631] = 620, + [632] = 632, + [633] = 512, + [634] = 634, + [635] = 560, + [636] = 543, + [637] = 627, + [638] = 628, + [639] = 632, + [640] = 634, + [641] = 583, + [642] = 624, + [643] = 517, + [644] = 496, + [645] = 595, + [646] = 567, + [647] = 584, + [648] = 587, + [649] = 499, + [650] = 529, + [651] = 548, + [652] = 652, + [653] = 544, + [654] = 530, + [655] = 545, + [656] = 556, + [657] = 592, + [658] = 594, + [659] = 516, + [660] = 519, + [661] = 520, + [662] = 514, + [663] = 522, + [664] = 523, + [665] = 524, + [666] = 525, + [667] = 527, + [668] = 532, + [669] = 533, + [670] = 511, + [671] = 553, + [672] = 76, + [673] = 568, + [674] = 580, + [675] = 581, + [676] = 582, + [677] = 585, + [678] = 588, + [679] = 590, + [680] = 591, + [681] = 593, + [682] = 513, + [683] = 558, + [684] = 554, + [685] = 550, + [686] = 505, + [687] = 574, + [688] = 571, + [689] = 586, + [690] = 535, + [691] = 552, + [692] = 562, + [693] = 572, + [694] = 626, + [695] = 589, + [696] = 518, + [697] = 493, + [698] = 534, + [699] = 547, + [700] = 569, + [701] = 575, + [702] = 526, + [703] = 537, + [704] = 542, + [705] = 546, + [706] = 549, + [707] = 652, + [708] = 555, + [709] = 515, + [710] = 559, + [711] = 573, + [712] = 55, + [713] = 76, + [714] = 55, + [715] = 564, + [716] = 24, + [717] = 30, + [718] = 32, + [719] = 36, + [720] = 46, + [721] = 39, + [722] = 184, + [723] = 78, + [724] = 60, + [725] = 62, + [726] = 161, + [727] = 68, + [728] = 163, + [729] = 164, + [730] = 55, + [731] = 56, + [732] = 58, + [733] = 63, + [734] = 64, + [735] = 66, + [736] = 72, + [737] = 183, + [738] = 73, + [739] = 187, + [740] = 188, + [741] = 189, + [742] = 74, + [743] = 75, + [744] = 76, + [745] = 194, + [746] = 79, + [747] = 81, + [748] = 83, + [749] = 84, + [750] = 85, + [751] = 87, + [752] = 42, + [753] = 43, + [754] = 204, + [755] = 44, + [756] = 45, + [757] = 210, + [758] = 41, + [759] = 214, + [760] = 49, + [761] = 216, + [762] = 218, + [763] = 50, + [764] = 51, + [765] = 225, + [766] = 52, + [767] = 53, + [768] = 234, + [769] = 238, + [770] = 54, + [771] = 48, + [772] = 406, + [773] = 163, + [774] = 456, + [775] = 372, + [776] = 380, + [777] = 381, + [778] = 164, + [779] = 384, + [780] = 386, + [781] = 368, + [782] = 374, + [783] = 389, + [784] = 373, + [785] = 375, + [786] = 376, + [787] = 370, + [788] = 382, + [789] = 387, + [790] = 394, + [791] = 395, + [792] = 398, + [793] = 401, + [794] = 405, + [795] = 377, + [796] = 378, + [797] = 410, + [798] = 412, + [799] = 367, + [800] = 414, + [801] = 415, + [802] = 416, + [803] = 417, + [804] = 419, + [805] = 420, + [806] = 421, + [807] = 422, + [808] = 436, + [809] = 183, + [810] = 184, + [811] = 187, + [812] = 188, + [813] = 189, + [814] = 194, + [815] = 204, + [816] = 210, + [817] = 214, + [818] = 216, + [819] = 218, + [820] = 225, + [821] = 234, + [822] = 238, + [823] = 161, + [824] = 408, [825] = 825, [826] = 826, - [827] = 821, + [827] = 827, [828] = 828, [829] = 829, [830] = 830, @@ -2696,385 +3137,385 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [832] = 832, [833] = 833, [834] = 834, - [835] = 832, - [836] = 833, + [835] = 835, + [836] = 836, [837] = 837, [838] = 838, - [839] = 838, + [839] = 827, [840] = 840, [841] = 841, [842] = 842, - [843] = 832, + [843] = 843, [844] = 844, - [845] = 845, - [846] = 846, - [847] = 847, - [848] = 848, - [849] = 838, - [850] = 850, - [851] = 837, - [852] = 831, - [853] = 848, - [854] = 854, - [855] = 829, - [856] = 834, + [845] = 844, + [846] = 832, + [847] = 835, + [848] = 829, + [849] = 831, + [850] = 843, + [851] = 828, + [852] = 830, + [853] = 837, + [854] = 838, + [855] = 840, + [856] = 833, [857] = 857, - [858] = 845, - [859] = 854, - [860] = 860, - [861] = 828, - [862] = 841, - [863] = 847, - [864] = 864, - [865] = 844, - [866] = 857, + [858] = 858, + [859] = 841, + [860] = 842, + [861] = 858, + [862] = 862, + [863] = 863, + [864] = 862, + [865] = 862, + [866] = 866, [867] = 867, [868] = 868, - [869] = 850, - [870] = 867, - [871] = 864, - [872] = 848, - [873] = 829, - [874] = 860, - [875] = 828, - [876] = 868, - [877] = 845, - [878] = 854, - [879] = 860, - [880] = 847, - [881] = 864, - [882] = 844, - [883] = 857, - [884] = 867, - [885] = 868, - [886] = 850, - [887] = 829, - [888] = 860, + [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] = 876, + [886] = 879, + [887] = 882, + [888] = 883, [889] = 889, - [890] = 841, - [891] = 891, + [890] = 890, + [891] = 890, [892] = 892, - [893] = 893, - [894] = 893, - [895] = 895, - [896] = 895, - [897] = 897, - [898] = 898, - [899] = 899, - [900] = 899, - [901] = 901, - [902] = 902, - [903] = 903, - [904] = 897, - [905] = 901, - [906] = 898, - [907] = 902, - [908] = 908, - [909] = 908, - [910] = 895, - [911] = 911, - [912] = 902, - [913] = 901, - [914] = 898, - [915] = 908, + [893] = 884, + [894] = 889, + [895] = 875, + [896] = 878, + [897] = 884, + [898] = 876, + [899] = 879, + [900] = 882, + [901] = 883, + [902] = 889, + [903] = 890, + [904] = 892, + [905] = 875, + [906] = 878, + [907] = 889, + [908] = 875, + [909] = 880, + [910] = 881, + [911] = 880, + [912] = 881, + [913] = 892, + [914] = 914, + [915] = 915, [916] = 916, - [917] = 897, - [918] = 916, - [919] = 899, + [917] = 914, + [918] = 918, + [919] = 915, [920] = 916, - [921] = 921, + [921] = 483, [922] = 922, [923] = 923, - [924] = 924, - [925] = 925, - [926] = 926, + [924] = 922, + [925] = 473, + [926] = 922, [927] = 927, - [928] = 928, - [929] = 929, - [930] = 930, - [931] = 927, - [932] = 926, - [933] = 933, + [928] = 915, + [929] = 916, + [930] = 914, + [931] = 931, + [932] = 931, + [933] = 931, [934] = 934, [935] = 935, - [936] = 928, + [936] = 936, [937] = 937, - [938] = 922, - [939] = 923, - [940] = 924, - [941] = 921, - [942] = 925, - [943] = 927, - [944] = 928, - [945] = 929, - [946] = 946, - [947] = 923, - [948] = 929, - [949] = 925, + [938] = 936, + [939] = 939, + [940] = 934, + [941] = 937, + [942] = 942, + [943] = 935, + [944] = 944, + [945] = 945, + [946] = 536, + [947] = 576, + [948] = 948, + [949] = 30, [950] = 950, [951] = 951, - [952] = 946, - [953] = 953, - [954] = 937, - [955] = 933, - [956] = 922, - [957] = 953, - [958] = 950, - [959] = 934, - [960] = 937, - [961] = 951, - [962] = 935, - [963] = 930, - [964] = 921, - [965] = 930, - [966] = 924, - [967] = 967, + [952] = 473, + [953] = 24, + [954] = 36, + [955] = 955, + [956] = 956, + [957] = 957, + [958] = 957, + [959] = 959, + [960] = 959, + [961] = 957, + [962] = 955, + [963] = 959, + [964] = 956, + [965] = 955, + [966] = 956, + [967] = 536, [968] = 968, - [969] = 969, - [970] = 970, - [971] = 971, - [972] = 972, + [969] = 612, + [970] = 601, + [971] = 598, + [972] = 599, [973] = 973, [974] = 974, [975] = 975, [976] = 976, - [977] = 977, - [978] = 978, + [977] = 474, + [978] = 472, [979] = 979, - [980] = 980, - [981] = 981, + [980] = 488, + [981] = 475, [982] = 982, - [983] = 983, + [983] = 476, [984] = 984, [985] = 985, - [986] = 971, - [987] = 987, + [986] = 986, + [987] = 985, [988] = 988, - [989] = 989, + [989] = 988, [990] = 990, - [991] = 991, + [991] = 985, [992] = 992, - [993] = 993, + [993] = 988, [994] = 994, [995] = 995, - [996] = 996, - [997] = 967, + [996] = 985, + [997] = 988, [998] = 998, - [999] = 976, - [1000] = 980, - [1001] = 993, - [1002] = 969, - [1003] = 982, + [999] = 999, + [1000] = 1000, + [1001] = 1001, + [1002] = 1002, + [1003] = 1003, [1004] = 1004, - [1005] = 975, + [1005] = 1005, [1006] = 1006, - [1007] = 967, - [1008] = 1006, - [1009] = 998, - [1010] = 976, - [1011] = 971, + [1007] = 1007, + [1008] = 1008, + [1009] = 1008, + [1010] = 1010, + [1011] = 1006, [1012] = 1012, - [1013] = 969, + [1013] = 1013, [1014] = 1014, - [1015] = 1015, - [1016] = 998, - [1017] = 982, - [1018] = 1015, - [1019] = 994, - [1020] = 975, - [1021] = 985, - [1022] = 1022, + [1015] = 1006, + [1016] = 1013, + [1017] = 1017, + [1018] = 1018, + [1019] = 1019, + [1020] = 1020, + [1021] = 1021, + [1022] = 1021, [1023] = 1023, [1024] = 1024, - [1025] = 998, - [1026] = 976, - [1027] = 1027, - [1028] = 1028, - [1029] = 981, + [1025] = 1025, + [1026] = 1026, + [1027] = 1021, + [1028] = 1019, + [1029] = 1029, [1030] = 1030, [1031] = 1031, - [1032] = 979, + [1032] = 1032, [1033] = 1033, [1034] = 1034, - [1035] = 1030, - [1036] = 1023, - [1037] = 971, + [1035] = 1035, + [1036] = 1036, + [1037] = 1037, [1038] = 1038, [1039] = 1039, - [1040] = 1040, - [1041] = 1041, + [1040] = 1035, + [1041] = 1026, [1042] = 1042, [1043] = 1043, - [1044] = 1040, + [1044] = 1026, [1045] = 1045, [1046] = 1046, [1047] = 1047, - [1048] = 1048, - [1049] = 1042, - [1050] = 1050, - [1051] = 1051, - [1052] = 1052, - [1053] = 1043, - [1054] = 1047, + [1048] = 1033, + [1049] = 1035, + [1050] = 1036, + [1051] = 1038, + [1052] = 1038, + [1053] = 1053, + [1054] = 1054, [1055] = 1055, - [1056] = 1056, + [1056] = 1033, [1057] = 1057, [1058] = 1058, - [1059] = 1048, - [1060] = 1060, - [1061] = 1061, - [1062] = 1055, + [1059] = 1031, + [1060] = 1029, + [1061] = 1058, + [1062] = 1054, [1063] = 1063, - [1064] = 1064, - [1065] = 1065, + [1064] = 1039, + [1065] = 1021, [1066] = 1066, [1067] = 1067, - [1068] = 1068, - [1069] = 1058, + [1068] = 1046, + [1069] = 1017, [1070] = 1070, - [1071] = 1071, - [1072] = 1041, - [1073] = 1073, + [1071] = 1025, + [1072] = 1045, + [1073] = 1063, [1074] = 1074, - [1075] = 1075, - [1076] = 1046, - [1077] = 1045, - [1078] = 1047, - [1079] = 1079, - [1080] = 1045, - [1081] = 1048, - [1082] = 1073, - [1083] = 1083, - [1084] = 1084, - [1085] = 1039, - [1086] = 1068, - [1087] = 1043, - [1088] = 1083, - [1089] = 1058, - [1090] = 1050, + [1075] = 1058, + [1076] = 1019, + [1077] = 1031, + [1078] = 1036, + [1079] = 1029, + [1080] = 1032, + [1081] = 1054, + [1082] = 1063, + [1083] = 1039, + [1084] = 1066, + [1085] = 1085, + [1086] = 1046, + [1087] = 1017, + [1088] = 1070, + [1089] = 1025, + [1090] = 1045, [1091] = 1091, - [1092] = 1079, - [1093] = 1093, - [1094] = 1039, - [1095] = 1095, - [1096] = 1064, - [1097] = 1097, + [1092] = 1031, + [1093] = 1054, + [1094] = 1066, + [1095] = 1019, + [1096] = 1026, + [1097] = 1070, [1098] = 1098, - [1099] = 1099, - [1100] = 1068, + [1099] = 1032, + [1100] = 1100, [1101] = 1101, [1102] = 1102, [1103] = 1103, - [1104] = 1041, + [1104] = 1104, [1105] = 1105, - [1106] = 1074, - [1107] = 1050, + [1106] = 976, + [1107] = 1107, [1108] = 1108, [1109] = 1109, [1110] = 1110, - [1111] = 1105, + [1111] = 1111, [1112] = 1112, - [1113] = 1046, + [1113] = 1113, [1114] = 1114, [1115] = 1115, [1116] = 1116, [1117] = 1117, - [1118] = 1056, - [1119] = 1060, - [1120] = 1114, - [1121] = 1105, - [1122] = 1055, + [1118] = 1118, + [1119] = 1119, + [1120] = 1120, + [1121] = 1121, + [1122] = 1122, [1123] = 1123, [1124] = 1124, - [1125] = 1064, + [1125] = 1125, [1126] = 1126, - [1127] = 1057, - [1128] = 1128, - [1129] = 1057, - [1130] = 1130, - [1131] = 1040, - [1132] = 1083, - [1133] = 1066, - [1134] = 1134, - [1135] = 1135, - [1136] = 1136, - [1137] = 1061, - [1138] = 1138, - [1139] = 1066, - [1140] = 1056, - [1141] = 1141, - [1142] = 1064, - [1143] = 1079, - [1144] = 1114, - [1145] = 1061, - [1146] = 1042, - [1147] = 1060, + [1127] = 1121, + [1128] = 1124, + [1129] = 1123, + [1130] = 1003, + [1131] = 1122, + [1132] = 1122, + [1133] = 1125, + [1134] = 1124, + [1135] = 1126, + [1136] = 1123, + [1137] = 1137, + [1138] = 1125, + [1139] = 1126, + [1140] = 1140, + [1141] = 1137, + [1142] = 1140, + [1143] = 1121, + [1144] = 1137, + [1145] = 1140, + [1146] = 1146, + [1147] = 1147, [1148] = 1148, [1149] = 1149, [1150] = 1150, [1151] = 1151, - [1152] = 1152, + [1152] = 1147, [1153] = 1153, [1154] = 1154, [1155] = 1155, - [1156] = 1152, - [1157] = 1150, + [1156] = 994, + [1157] = 1153, [1158] = 1158, - [1159] = 1152, + [1159] = 1159, [1160] = 1160, - [1161] = 1161, - [1162] = 1154, - [1163] = 1163, - [1164] = 1155, - [1165] = 1165, - [1166] = 1154, + [1161] = 1150, + [1162] = 1162, + [1163] = 990, + [1164] = 1164, + [1165] = 1160, + [1166] = 1151, [1167] = 1167, [1168] = 1168, - [1169] = 1169, - [1170] = 1152, - [1171] = 1155, - [1172] = 1172, - [1173] = 1163, - [1174] = 1174, - [1175] = 1175, + [1169] = 1150, + [1170] = 1170, + [1171] = 1150, + [1172] = 1160, + [1173] = 1173, + [1174] = 1148, + [1175] = 1148, [1176] = 1176, - [1177] = 1177, - [1178] = 1151, - [1179] = 1179, - [1180] = 1180, - [1181] = 1181, - [1182] = 1182, - [1183] = 1175, - [1184] = 1184, - [1185] = 1185, - [1186] = 1150, - [1187] = 1187, + [1177] = 1146, + [1178] = 1170, + [1179] = 1151, + [1180] = 1159, + [1181] = 1147, + [1182] = 1149, + [1183] = 1162, + [1184] = 1146, + [1185] = 1153, + [1186] = 1159, + [1187] = 1149, [1188] = 1188, - [1189] = 1189, - [1190] = 1190, + [1189] = 1168, + [1190] = 1158, [1191] = 1191, - [1192] = 1155, - [1193] = 1193, - [1194] = 1194, - [1195] = 1195, - [1196] = 1196, - [1197] = 1197, - [1198] = 1184, + [1192] = 1188, + [1193] = 1167, + [1194] = 1173, + [1195] = 1188, + [1196] = 1167, + [1197] = 1162, + [1198] = 1173, [1199] = 1199, - [1200] = 1181, + [1200] = 1200, [1201] = 1201, - [1202] = 1167, - [1203] = 1181, + [1202] = 1202, + [1203] = 1203, [1204] = 1204, - [1205] = 1167, - [1206] = 1176, - [1207] = 1177, - [1208] = 1177, - [1209] = 1177, - [1210] = 1180, + [1205] = 1205, + [1206] = 1206, + [1207] = 1207, + [1208] = 1208, + [1209] = 1209, + [1210] = 1210, [1211] = 1211, [1212] = 1212, - [1213] = 1213, + [1213] = 1110, [1214] = 1214, [1215] = 1215, [1216] = 1216, @@ -3084,225 +3525,578 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1220] = 1220, [1221] = 1221, [1222] = 1222, - [1223] = 1223, - [1224] = 1224, + [1223] = 1216, + [1224] = 1220, [1225] = 1225, - [1226] = 1226, + [1226] = 1102, [1227] = 1227, - [1228] = 1227, + [1228] = 1228, [1229] = 1229, [1230] = 1230, - [1231] = 1231, - [1232] = 1232, - [1233] = 1233, + [1231] = 1218, + [1232] = 1207, + [1233] = 1221, [1234] = 1234, [1235] = 1235, - [1236] = 1236, + [1236] = 1215, [1237] = 1237, - [1238] = 1238, - [1239] = 1239, - [1240] = 1220, - [1241] = 1241, - [1242] = 1242, - [1243] = 1243, - [1244] = 1244, + [1238] = 1222, + [1239] = 1219, + [1240] = 1230, + [1241] = 1215, + [1242] = 1214, + [1243] = 1203, + [1244] = 1208, [1245] = 1245, - [1246] = 1246, - [1247] = 1241, - [1248] = 1222, + [1246] = 1217, + [1247] = 1234, + [1248] = 1227, [1249] = 1249, - [1250] = 1250, - [1251] = 1231, - [1252] = 1252, - [1253] = 1211, + [1250] = 1225, + [1251] = 1229, + [1252] = 1235, + [1253] = 1253, [1254] = 1254, - [1255] = 1255, - [1256] = 1216, - [1257] = 1257, + [1255] = 1203, + [1256] = 1208, + [1257] = 1227, [1258] = 1258, [1259] = 1259, - [1260] = 1231, - [1261] = 1233, - [1262] = 1262, - [1263] = 1218, - [1264] = 1264, - [1265] = 1255, + [1260] = 1225, + [1261] = 1228, + [1262] = 1229, + [1263] = 1254, + [1264] = 1203, + [1265] = 1208, [1266] = 1266, [1267] = 1267, - [1268] = 1268, + [1268] = 1218, [1269] = 1269, [1270] = 1216, - [1271] = 1269, - [1272] = 1217, + [1271] = 1271, + [1272] = 1272, [1273] = 1273, [1274] = 1274, - [1275] = 1275, - [1276] = 1276, - [1277] = 1221, + [1275] = 1254, + [1276] = 1215, + [1277] = 1277, [1278] = 1278, - [1279] = 1258, - [1280] = 1220, + [1279] = 1279, + [1280] = 1280, [1281] = 1281, - [1282] = 1235, + [1282] = 1282, [1283] = 1283, [1284] = 1284, - [1285] = 1217, + [1285] = 1285, [1286] = 1286, - [1287] = 1257, - [1288] = 1234, + [1287] = 1287, + [1288] = 1288, [1289] = 1289, - [1290] = 1276, - [1291] = 1239, + [1290] = 1290, + [1291] = 1291, [1292] = 1292, [1293] = 1293, - [1294] = 1231, + [1294] = 1284, [1295] = 1295, - [1296] = 1243, + [1296] = 1296, [1297] = 1297, [1298] = 1298, - [1299] = 1236, + [1299] = 1299, [1300] = 1300, - [1301] = 1292, + [1301] = 1301, [1302] = 1302, [1303] = 1303, [1304] = 1304, - [1305] = 1259, + [1305] = 1300, [1306] = 1306, - [1307] = 1245, - [1308] = 1237, - [1309] = 1266, - [1310] = 1222, - [1311] = 1229, - [1312] = 1252, - [1313] = 1233, - [1314] = 1241, - [1315] = 1284, + [1307] = 1307, + [1308] = 1308, + [1309] = 1309, + [1310] = 1297, + [1311] = 1311, + [1312] = 1285, + [1313] = 1313, + [1314] = 1307, + [1315] = 1311, [1316] = 1316, - [1317] = 1274, - [1318] = 1236, - [1319] = 1319, - [1320] = 1262, - [1321] = 1237, - [1322] = 1255, - [1323] = 1238, - [1324] = 1235, - [1325] = 1220, - [1326] = 1326, - [1327] = 1273, - [1328] = 1226, - [1329] = 1221, - [1330] = 1330, - [1331] = 1258, - [1332] = 1241, + [1317] = 1317, + [1318] = 1318, + [1319] = 1296, + [1320] = 1301, + [1321] = 1280, + [1322] = 1281, + [1323] = 1323, + [1324] = 1282, + [1325] = 1283, + [1326] = 1285, + [1327] = 1286, + [1328] = 1287, + [1329] = 1284, + [1330] = 1289, + [1331] = 1281, + [1332] = 1332, [1333] = 1333, - [1334] = 1334, + [1334] = 1302, [1335] = 1335, - [1336] = 1229, + [1336] = 1336, [1337] = 1337, - [1338] = 1289, - [1339] = 1276, - [1340] = 1340, - [1341] = 1292, - [1342] = 1342, - [1343] = 1278, + [1338] = 1286, + [1339] = 1339, + [1340] = 1308, + [1341] = 1341, + [1342] = 1299, + [1343] = 1343, [1344] = 1344, - [1345] = 1298, - [1346] = 1245, - [1347] = 1273, - [1348] = 1297, - [1349] = 1246, - [1350] = 1303, - [1351] = 1351, + [1345] = 1345, + [1346] = 1337, + [1347] = 1347, + [1348] = 1348, + [1349] = 1349, + [1350] = 1350, + [1351] = 1298, [1352] = 1352, - [1353] = 1293, - [1354] = 1275, + [1353] = 1353, + [1354] = 1354, [1355] = 1355, - [1356] = 1252, - [1357] = 1357, - [1358] = 1255, - [1359] = 1264, - [1360] = 1344, - [1361] = 1250, - [1362] = 1266, - [1363] = 1319, - [1364] = 1249, - [1365] = 1344, - [1366] = 1366, + [1356] = 1356, + [1357] = 1301, + [1358] = 1354, + [1359] = 1313, + [1360] = 1360, + [1361] = 1361, + [1362] = 1362, + [1363] = 1283, + [1364] = 1361, + [1365] = 1365, + [1366] = 1287, [1367] = 1367, [1368] = 1368, - [1369] = 1283, - [1370] = 1262, - [1371] = 1367, - [1372] = 1250, - [1373] = 1373, - [1374] = 1330, + [1369] = 1341, + [1370] = 1370, + [1371] = 1339, + [1372] = 1335, + [1373] = 1299, + [1374] = 1345, [1375] = 1375, - [1376] = 1376, - [1377] = 1377, - [1378] = 1373, - [1379] = 1219, - [1380] = 1230, - [1381] = 1239, - [1382] = 1242, + [1376] = 1282, + [1377] = 1280, + [1378] = 1350, + [1379] = 1379, + [1380] = 1296, + [1381] = 1381, + [1382] = 1300, [1383] = 1383, - [1384] = 1375, - [1385] = 1302, - [1386] = 1224, - [1387] = 1333, - [1388] = 1355, - [1389] = 1214, - [1390] = 1390, - [1391] = 1366, - [1392] = 1367, - [1393] = 1368, - [1394] = 1243, - [1395] = 1250, - [1396] = 1330, - [1397] = 1235, - [1398] = 1219, - [1399] = 1230, - [1400] = 1400, - [1401] = 1401, - [1402] = 1302, - [1403] = 1333, - [1404] = 1214, - [1405] = 1366, - [1406] = 1302, - [1407] = 1342, - [1408] = 1366, - [1409] = 1286, - [1410] = 1401, - [1411] = 1213, + [1384] = 1290, + [1385] = 1290, + [1386] = 1306, + [1387] = 1306, + [1388] = 1388, + [1389] = 1389, + [1390] = 1308, + [1391] = 1389, + [1392] = 1339, + [1393] = 1393, + [1394] = 1394, + [1395] = 1297, + [1396] = 1396, + [1397] = 1397, + [1398] = 1398, + [1399] = 1399, + [1400] = 1318, + [1401] = 1313, + [1402] = 1345, + [1403] = 1339, + [1404] = 1349, + [1405] = 1405, + [1406] = 1367, + [1407] = 1407, + [1408] = 1350, + [1409] = 1307, + [1410] = 1311, + [1411] = 1367, [1412] = 1412, - [1413] = 1368, - [1414] = 1357, - [1415] = 1337, - [1416] = 1298, + [1413] = 1289, + [1414] = 1352, + [1415] = 1318, + [1416] = 1360, [1417] = 1417, - [1418] = 1238, - [1419] = 1286, - [1420] = 1401, - [1421] = 1376, - [1422] = 1357, - [1423] = 1337, - [1424] = 1417, - [1425] = 1357, - [1426] = 1326, - [1427] = 1215, - [1428] = 1383, - [1429] = 1303, - [1430] = 1306, + [1418] = 1418, + [1419] = 1419, + [1420] = 1420, + [1421] = 1421, + [1422] = 539, + [1423] = 1423, + [1424] = 1424, + [1425] = 1425, + [1426] = 1426, + [1427] = 1427, + [1428] = 1428, + [1429] = 1428, + [1430] = 1430, [1431] = 1431, - [1432] = 1326, - [1433] = 1215, - [1434] = 1211, - [1435] = 1267, - [1436] = 1225, - [1437] = 1289, - [1438] = 1264, - [1439] = 1417, - [1440] = 1252, + [1432] = 1432, + [1433] = 1100, + [1434] = 1428, + [1435] = 1435, + [1436] = 1436, + [1437] = 1437, + [1438] = 1423, + [1439] = 1439, + [1440] = 1440, [1441] = 1441, + [1442] = 1442, + [1443] = 1432, + [1444] = 1441, + [1445] = 1055, + [1446] = 1424, + [1447] = 1447, + [1448] = 1448, + [1449] = 1436, + [1450] = 1437, + [1451] = 1432, + [1452] = 1423, + [1453] = 1453, + [1454] = 1423, + [1455] = 1432, + [1456] = 1456, + [1457] = 1426, + [1458] = 1458, + [1459] = 1459, + [1460] = 1460, + [1461] = 1461, + [1462] = 1462, + [1463] = 1420, + [1464] = 1464, + [1465] = 1465, + [1466] = 1466, + [1467] = 1467, + [1468] = 1468, + [1469] = 1469, + [1470] = 1470, + [1471] = 1456, + [1472] = 1103, + [1473] = 1473, + [1474] = 1474, + [1475] = 1475, + [1476] = 1436, + [1477] = 1477, + [1478] = 1478, + [1479] = 1479, + [1480] = 1480, + [1481] = 1481, + [1482] = 1459, + [1483] = 1439, + [1484] = 1478, + [1485] = 1466, + [1486] = 1458, + [1487] = 1467, + [1488] = 1475, + [1489] = 1425, + [1490] = 1490, + [1491] = 1491, + [1492] = 1417, + [1493] = 1439, + [1494] = 1466, + [1495] = 1475, + [1496] = 1439, + [1497] = 1497, + [1498] = 1456, + [1499] = 1417, + [1500] = 1461, + [1501] = 1437, + [1502] = 1461, + [1503] = 1503, + [1504] = 1461, + [1505] = 1505, + [1506] = 1506, + [1507] = 1507, + [1508] = 1508, + [1509] = 1509, + [1510] = 1510, + [1511] = 1511, + [1512] = 1512, + [1513] = 1513, + [1514] = 1514, + [1515] = 1515, + [1516] = 1516, + [1517] = 1517, + [1518] = 1518, + [1519] = 1519, + [1520] = 1520, + [1521] = 1521, + [1522] = 1522, + [1523] = 1523, + [1524] = 1514, + [1525] = 1525, + [1526] = 1526, + [1527] = 1527, + [1528] = 1528, + [1529] = 1529, + [1530] = 1530, + [1531] = 1531, + [1532] = 1532, + [1533] = 1532, + [1534] = 1534, + [1535] = 1535, + [1536] = 1536, + [1537] = 1537, + [1538] = 1538, + [1539] = 1539, + [1540] = 1540, + [1541] = 1541, + [1542] = 1538, + [1543] = 1543, + [1544] = 1529, + [1545] = 1545, + [1546] = 1529, + [1547] = 1547, + [1548] = 1548, + [1549] = 1549, + [1550] = 1550, + [1551] = 1551, + [1552] = 1552, + [1553] = 1553, + [1554] = 1532, + [1555] = 1555, + [1556] = 1527, + [1557] = 1529, + [1558] = 1514, + [1559] = 1516, + [1560] = 1560, + [1561] = 1561, + [1562] = 1562, + [1563] = 1563, + [1564] = 1564, + [1565] = 1565, + [1566] = 1566, + [1567] = 1537, + [1568] = 1536, + [1569] = 1569, + [1570] = 1570, + [1571] = 1565, + [1572] = 1572, + [1573] = 1573, + [1574] = 1573, + [1575] = 1575, + [1576] = 1576, + [1577] = 1577, + [1578] = 1578, + [1579] = 1538, + [1580] = 1521, + [1581] = 1581, + [1582] = 1562, + [1583] = 1583, + [1584] = 1584, + [1585] = 1585, + [1586] = 1586, + [1587] = 1587, + [1588] = 1588, + [1589] = 1589, + [1590] = 1590, + [1591] = 1591, + [1592] = 1592, + [1593] = 1535, + [1594] = 1583, + [1595] = 1595, + [1596] = 1596, + [1597] = 1547, + [1598] = 1598, + [1599] = 1548, + [1600] = 1600, + [1601] = 1601, + [1602] = 1602, + [1603] = 1603, + [1604] = 1604, + [1605] = 1605, + [1606] = 1515, + [1607] = 1510, + [1608] = 1520, + [1609] = 1566, + [1610] = 1610, + [1611] = 1101, + [1612] = 1612, + [1613] = 1517, + [1614] = 1595, + [1615] = 1615, + [1616] = 1616, + [1617] = 1617, + [1618] = 1585, + [1619] = 1588, + [1620] = 1539, + [1621] = 1527, + [1622] = 1601, + [1623] = 1623, + [1624] = 1624, + [1625] = 1537, + [1626] = 1626, + [1627] = 1548, + [1628] = 1628, + [1629] = 1629, + [1630] = 1551, + [1631] = 1631, + [1632] = 1536, + [1633] = 1555, + [1634] = 1634, + [1635] = 1528, + [1636] = 1538, + [1637] = 1521, + [1638] = 1638, + [1639] = 1639, + [1640] = 1640, + [1641] = 1641, + [1642] = 1539, + [1643] = 1570, + [1644] = 1565, + [1645] = 1605, + [1646] = 1573, + [1647] = 1528, + [1648] = 1540, + [1649] = 1649, + [1650] = 1650, + [1651] = 1584, + [1652] = 1586, + [1653] = 1617, + [1654] = 1588, + [1655] = 1570, + [1656] = 1591, + [1657] = 1555, + [1658] = 1603, + [1659] = 1601, + [1660] = 1634, + [1661] = 1560, + [1662] = 1624, + [1663] = 1604, + [1664] = 1605, + [1665] = 1665, + [1666] = 1666, + [1667] = 1520, + [1668] = 1668, + [1669] = 1669, + [1670] = 1577, + [1671] = 1617, + [1672] = 1672, + [1673] = 1673, + [1674] = 1604, + [1675] = 1675, + [1676] = 1623, + [1677] = 1541, + [1678] = 1678, + [1679] = 1679, + [1680] = 1540, + [1681] = 1668, + [1682] = 1555, + [1683] = 1539, + [1684] = 1684, + [1685] = 1573, + [1686] = 1624, + [1687] = 1687, + [1688] = 1506, + [1689] = 1591, + [1690] = 1584, + [1691] = 1605, + [1692] = 1575, + [1693] = 1629, + [1694] = 1679, + [1695] = 1695, + [1696] = 1596, + [1697] = 1551, + [1698] = 1698, + [1699] = 1522, + [1700] = 1540, + [1701] = 1525, + [1702] = 1537, + [1703] = 1703, + [1704] = 1553, + [1705] = 1678, + [1706] = 1511, + [1707] = 1703, + [1708] = 1572, + [1709] = 1709, + [1710] = 1631, + [1711] = 1506, + [1712] = 1581, + [1713] = 1602, + [1714] = 1526, + [1715] = 1615, + [1716] = 1673, + [1717] = 1669, + [1718] = 1541, + [1719] = 1531, + [1720] = 1541, + [1721] = 1508, + [1722] = 1629, + [1723] = 1709, + [1724] = 1535, + [1725] = 1547, + [1726] = 1561, + [1727] = 1534, + [1728] = 1668, + [1729] = 1679, + [1730] = 1684, + [1731] = 1731, + [1732] = 1698, + [1733] = 1522, + [1734] = 1684, + [1735] = 1553, + [1736] = 1703, + [1737] = 1737, + [1738] = 1738, + [1739] = 1602, + [1740] = 1526, + [1741] = 1741, + [1742] = 1742, + [1743] = 1508, + [1744] = 1591, + [1745] = 1709, + [1746] = 1534, + [1747] = 1529, + [1748] = 1526, + [1749] = 1508, + [1750] = 1672, + [1751] = 1741, + [1752] = 1553, + [1753] = 1517, + [1754] = 1626, + [1755] = 1509, + [1756] = 1519, + [1757] = 1592, + [1758] = 1575, + [1759] = 1616, + [1760] = 1760, + [1761] = 1761, + [1762] = 1612, + [1763] = 1596, + [1764] = 1764, + [1765] = 1507, + [1766] = 1589, + [1767] = 1529, + [1768] = 1626, + [1769] = 1509, + [1770] = 1695, + [1771] = 1761, + [1772] = 1612, + [1773] = 1507, + [1774] = 1761, + [1775] = 1513, + [1776] = 1532, + [1777] = 1678, + [1778] = 1778, + [1779] = 1576, + [1780] = 1623, + [1781] = 1673, + [1782] = 1586, + [1783] = 1513, + [1784] = 1761, + [1785] = 1564, + [1786] = 1786, + [1787] = 1669, + [1788] = 1698, + [1789] = 1528, + [1790] = 1672, + [1791] = 1516, + [1792] = 1519, + [1793] = 1598, + [1794] = 1510, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -3310,602 +4104,680 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (eof) ADVANCE(38); + if (eof) ADVANCE(42); ADVANCE_MAP( - '!', 59, - '"', 8, - '%', 76, - '&', 16, - '(', 50, - ')', 51, - '*', 73, - '+', 70, - ',', 53, - '-', 72, - '.', 40, - '/', 74, - ':', 41, - '<', 47, - '=', 44, - '>', 49, - '?', 63, - '[', 78, - ']', 61, - '{', 56, - '|', 55, - '}', 57, + '!', 66, + '"', 9, + '%', 82, + '&', 18, + '(', 60, + ')', 61, + '*', 48, + '+', 77, + ',', 49, + '-', 79, + '.', 44, + '/', 80, + ':', 51, + ';', 50, + '<', 57, + '=', 54, + '>', 59, + '?', 70, + '[', 84, + ']', 68, + '{', 46, + '|', 64, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(32); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + lookahead == ' ') SKIP(36); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); case 1: - if (lookahead == '\n') ADVANCE(15); - if (lookahead == '"') ADVANCE(10); - if (lookahead == '$') ADVANCE(11); + if (lookahead == '\n') ADVANCE(17); + if (lookahead == '"') ADVANCE(11); + if (lookahead == '$') ADVANCE(12); if (lookahead == '\\') ADVANCE(2); - if (lookahead != 0) ADVANCE(8); + if (lookahead != 0) ADVANCE(9); END_STATE(); case 2: - if (lookahead == '\n') ADVANCE(10); - if (lookahead == '"') ADVANCE(84); + if (lookahead == '\n') ADVANCE(11); + if (lookahead == '"') ADVANCE(90); if (lookahead == '\\') ADVANCE(1); - if (lookahead != 0) ADVANCE(8); + if (lookahead != 0) ADVANCE(9); END_STATE(); case 3: - if (lookahead == '\n') ADVANCE(10); - if (lookahead == '"') ADVANCE(83); + if (lookahead == '\n') ADVANCE(11); + if (lookahead == '"') ADVANCE(89); if (lookahead == '\\') ADVANCE(5); - if (lookahead != 0) ADVANCE(9); + if (lookahead != 0) ADVANCE(10); END_STATE(); case 4: - if (lookahead == '\n') ADVANCE(25); - if (lookahead == '}') ADVANCE(9); - if (lookahead != 0) ADVANCE(12); + if (lookahead == '\n') ADVANCE(29); + if (lookahead == '}') ADVANCE(10); + if (lookahead != 0) ADVANCE(14); END_STATE(); case 5: - if (lookahead == '\n') ADVANCE(13); - if (lookahead == '"') ADVANCE(87); - if (lookahead == '$') ADVANCE(14); + if (lookahead == '\n') ADVANCE(15); + if (lookahead == '"') ADVANCE(93); + if (lookahead == '$') ADVANCE(16); if (lookahead == '\\') ADVANCE(3); - if (lookahead != 0) ADVANCE(9); + if (lookahead != 0) ADVANCE(10); END_STATE(); case 6: ADVANCE_MAP( - '!', 58, - '"', 8, - '(', 50, - ')', 51, - '+', 70, - ',', 53, - '-', 71, - '.', 17, - '/', 20, - ':', 41, - '<', 46, - '=', 45, - '>', 48, - '[', 60, - ']', 61, - '{', 56, - '|', 54, - '}', 57, + '!', 65, + '"', 9, + '(', 60, + ')', 61, + '+', 77, + ',', 49, + '-', 78, + '.', 19, + '/', 22, + ':', 51, + '<', 56, + '=', 55, + '>', 58, + '[', 67, + ']', 68, + '{', 46, + '|', 63, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(6); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); case 7: ADVANCE_MAP( - '!', 58, - ',', 53, - '-', 22, - '/', 20, - ':', 41, - '<', 46, - '=', 42, - ']', 61, - '{', 56, + '!', 24, + '"', 9, + '%', 82, + '&', 18, + '(', 60, + ')', 61, + '*', 48, + '+', 77, + ',', 49, + '-', 79, + '.', 43, + '/', 81, + ':', 51, + '<', 57, + '=', 25, + '>', 59, + '?', 70, + '[', 84, + ']', 68, + '{', 46, + '|', 26, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(7); + lookahead == ' ') SKIP(8); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); case 8: - if (lookahead == '"') ADVANCE(82); - if (lookahead == '$') ADVANCE(11); - if (lookahead == '\\') ADVANCE(27); - if (lookahead != 0) ADVANCE(8); + ADVANCE_MAP( + '!', 24, + '"', 9, + '%', 82, + '&', 18, + '(', 60, + ')', 61, + '*', 48, + '+', 77, + ',', 49, + '-', 79, + '.', 43, + '/', 81, + ':', 51, + '<', 57, + '=', 25, + '>', 59, + '?', 70, + '[', 67, + ']', 68, + '{', 46, + '|', 26, + '}', 47, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(8); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); case 9: - if (lookahead == '"') ADVANCE(82); - if (lookahead == '$') ADVANCE(14); + if (lookahead == '"') ADVANCE(88); + if (lookahead == '$') ADVANCE(12); if (lookahead == '\\') ADVANCE(31); if (lookahead != 0) ADVANCE(9); END_STATE(); case 10: - if (lookahead == '"') ADVANCE(82); - if (lookahead == '\\') ADVANCE(29); + if (lookahead == '"') ADVANCE(88); + if (lookahead == '$') ADVANCE(16); + if (lookahead == '\\') ADVANCE(35); if (lookahead != 0) ADVANCE(10); END_STATE(); case 11: - if (lookahead == '"') ADVANCE(84); - if (lookahead == '\\') ADVANCE(1); - if (lookahead == '{') ADVANCE(12); - if (lookahead != 0) ADVANCE(8); + if (lookahead == '"') ADVANCE(88); + if (lookahead == '\\') ADVANCE(33); + if (lookahead != 0) ADVANCE(11); END_STATE(); case 12: - if (lookahead == '"') ADVANCE(85); - if (lookahead == '\\') ADVANCE(4); - if (lookahead == '}') ADVANCE(9); - if (lookahead != 0) ADVANCE(12); + if (lookahead == '"') ADVANCE(90); + if (lookahead == '\\') ADVANCE(1); + if (lookahead == '{') ADVANCE(14); + if (lookahead != 0) ADVANCE(9); END_STATE(); case 13: - if (lookahead == '"') ADVANCE(86); - if (lookahead == '$') ADVANCE(24); - if (lookahead == '\\') ADVANCE(30); - if (lookahead != 0) ADVANCE(13); + if (lookahead == '"') ADVANCE(11); + if (lookahead == '/') ADVANCE(22); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(13); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); case 14: - if (lookahead == '"') ADVANCE(83); - if (lookahead == '\\') ADVANCE(5); - if (lookahead == '{') ADVANCE(12); - if (lookahead != 0) ADVANCE(9); + if (lookahead == '"') ADVANCE(91); + if (lookahead == '\\') ADVANCE(4); + if (lookahead == '}') ADVANCE(10); + if (lookahead != 0) ADVANCE(14); END_STATE(); case 15: - if (lookahead == '$') ADVANCE(23); - if (lookahead == '\\') ADVANCE(28); - if (lookahead != 0 && - lookahead != '"') ADVANCE(15); + if (lookahead == '"') ADVANCE(92); + if (lookahead == '$') ADVANCE(28); + if (lookahead == '\\') ADVANCE(34); + if (lookahead != 0) ADVANCE(15); END_STATE(); case 16: - if (lookahead == '&') ADVANCE(65); + if (lookahead == '"') ADVANCE(89); + if (lookahead == '\\') ADVANCE(5); + if (lookahead == '{') ADVANCE(14); + if (lookahead != 0) ADVANCE(10); END_STATE(); case 17: - if (lookahead == '.') ADVANCE(18); + if (lookahead == '$') ADVANCE(27); + if (lookahead == '\\') ADVANCE(32); + if (lookahead != 0 && + lookahead != '"') ADVANCE(17); END_STATE(); case 18: - if (lookahead == '.') ADVANCE(79); + if (lookahead == '&') ADVANCE(72); END_STATE(); case 19: - if (lookahead == '/') ADVANCE(90); + if (lookahead == '.') ADVANCE(20); END_STATE(); case 20: - if (lookahead == '/') ADVANCE(91); + if (lookahead == '.') ADVANCE(85); END_STATE(); case 21: - if (lookahead == '=') ADVANCE(66); - if (lookahead == '>') ADVANCE(62); + if (lookahead == '/') ADVANCE(96); END_STATE(); case 22: - if (lookahead == '>') ADVANCE(52); + if (lookahead == '/') ADVANCE(97); END_STATE(); case 23: - if (lookahead == '{') ADVANCE(25); - if (lookahead != 0) ADVANCE(15); + if (lookahead == ':') ADVANCE(45); END_STATE(); case 24: - if (lookahead == '{') ADVANCE(25); - if (lookahead != 0) ADVANCE(13); + if (lookahead == '=') ADVANCE(74); END_STATE(); case 25: - if (lookahead == '}') ADVANCE(13); - if (lookahead != 0) ADVANCE(25); + if (lookahead == '=') ADVANCE(73); + if (lookahead == '>') ADVANCE(69); END_STATE(); case 26: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(80); + if (lookahead == '>') ADVANCE(83); + if (lookahead == '|') ADVANCE(71); END_STATE(); case 27: - if (lookahead != 0 && - lookahead != '\n') ADVANCE(8); + if (lookahead == '{') ADVANCE(29); + if (lookahead != 0) ADVANCE(17); END_STATE(); case 28: - if (lookahead != 0 && - lookahead != '\n') ADVANCE(15); + if (lookahead == '{') ADVANCE(29); + if (lookahead != 0) ADVANCE(15); END_STATE(); case 29: - if (lookahead != 0 && - lookahead != '\n') ADVANCE(10); + if (lookahead == '}') ADVANCE(15); + if (lookahead != 0) ADVANCE(29); END_STATE(); case 30: - if (lookahead != 0 && - lookahead != '\n') ADVANCE(13); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(86); END_STATE(); case 31: if (lookahead != 0 && lookahead != '\n') ADVANCE(9); END_STATE(); case 32: - if (eof) ADVANCE(38); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(17); + END_STATE(); + case 33: + if (lookahead != 0 && + lookahead != '\n') ADVANCE(11); + END_STATE(); + case 34: + if (lookahead != 0 && + lookahead != '\n') ADVANCE(15); + END_STATE(); + case 35: + if (lookahead != 0 && + lookahead != '\n') ADVANCE(10); + END_STATE(); + case 36: + if (eof) ADVANCE(42); ADVANCE_MAP( - '!', 59, - '"', 8, - '%', 76, - '&', 16, - '(', 50, - ')', 51, - '*', 73, - '+', 70, - ',', 53, - '-', 72, - '.', 40, - '/', 74, - ':', 41, - '<', 47, - '=', 44, - '>', 49, - '?', 63, - '[', 60, - ']', 61, - '{', 56, - '|', 55, - '}', 57, + '!', 66, + '"', 9, + '%', 82, + '&', 18, + '(', 60, + ')', 61, + '*', 48, + '+', 77, + ',', 49, + '-', 79, + '.', 44, + '/', 80, + ':', 51, + ';', 50, + '<', 57, + '=', 54, + '>', 59, + '?', 70, + '[', 67, + ']', 68, + '{', 46, + '|', 64, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(32); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + lookahead == ' ') SKIP(36); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); - case 33: - if (eof) ADVANCE(38); + case 37: + if (eof) ADVANCE(42); ADVANCE_MAP( - '!', 59, - '"', 8, - '%', 76, - '&', 16, - '(', 50, - ')', 51, - '*', 73, - '+', 70, - ',', 53, - '-', 72, - '.', 39, - '/', 75, - ':', 41, - '<', 47, - '=', 21, - '>', 49, - '?', 63, - '[', 78, - ']', 61, - '{', 56, - '|', 55, - '}', 57, + '!', 66, + '"', 9, + '%', 82, + '&', 18, + '(', 60, + ')', 61, + '*', 48, + '+', 77, + ',', 49, + '-', 79, + '.', 43, + '/', 81, + ':', 51, + ';', 50, + '<', 57, + '=', 53, + '>', 59, + '?', 70, + '[', 84, + ']', 68, + '{', 46, + '|', 64, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(34); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + lookahead == ' ') SKIP(38); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); - case 34: - if (eof) ADVANCE(38); + case 38: + if (eof) ADVANCE(42); ADVANCE_MAP( - '!', 59, - '"', 8, - '%', 76, - '&', 16, - '(', 50, - ')', 51, - '*', 73, - '+', 70, - ',', 53, - '-', 72, - '.', 39, - '/', 75, - ':', 41, - '<', 47, - '=', 21, - '>', 49, - '?', 63, - '[', 60, - ']', 61, - '{', 56, - '|', 55, - '}', 57, + '!', 66, + '"', 9, + '%', 82, + '&', 18, + '(', 60, + ')', 61, + '*', 48, + '+', 77, + ',', 49, + '-', 79, + '.', 43, + '/', 81, + ':', 51, + ';', 50, + '<', 57, + '=', 53, + '>', 59, + '?', 70, + '[', 67, + ']', 68, + '{', 46, + '|', 64, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(34); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + lookahead == ' ') SKIP(38); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); - case 35: - if (eof) ADVANCE(38); + case 39: + if (eof) ADVANCE(42); ADVANCE_MAP( - '!', 59, - '"', 8, - '%', 76, - '&', 16, - '(', 50, - '*', 73, - '+', 70, - '-', 71, - '.', 39, - '/', 74, - ':', 41, - '<', 47, - '=', 43, - '>', 49, - '?', 63, - '[', 78, - '{', 56, - '|', 55, - '}', 57, + '!', 66, + '"', 9, + '%', 82, + '&', 18, + '(', 60, + '*', 48, + '+', 77, + '-', 78, + '.', 43, + '/', 80, + ':', 51, + '<', 57, + '=', 53, + '>', 59, + '?', 70, + '[', 84, + '{', 46, + '|', 64, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(36); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + lookahead == ' ') SKIP(40); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); - case 36: - if (eof) ADVANCE(38); + case 40: + if (eof) ADVANCE(42); ADVANCE_MAP( - '!', 59, - '"', 8, - '%', 76, - '&', 16, - '(', 50, - '*', 73, - '+', 70, - '-', 71, - '.', 39, - '/', 74, - ':', 41, - '<', 47, - '=', 43, - '>', 49, - '?', 63, - '[', 60, - '{', 56, - '|', 55, - '}', 57, + '!', 66, + '"', 9, + '%', 82, + '&', 18, + '(', 60, + '*', 48, + '+', 77, + '-', 78, + '.', 43, + '/', 80, + ':', 51, + '<', 57, + '=', 53, + '>', 59, + '?', 70, + '[', 67, + '{', 46, + '|', 64, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(36); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + lookahead == ' ') SKIP(40); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); - case 37: - if (eof) ADVANCE(38); + case 41: + if (eof) ADVANCE(42); ADVANCE_MAP( - '!', 58, - '"', 8, - '(', 50, - '+', 70, - '-', 72, - '.', 39, - '/', 19, - '<', 46, - '[', 60, - '{', 56, - '|', 54, - '}', 57, + '!', 65, + '"', 9, + '(', 60, + '+', 77, + '-', 79, + '.', 43, + '/', 21, + ':', 23, + '<', 56, + '=', 52, + '[', 67, + '{', 46, + '|', 63, + '}', 47, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(37); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + lookahead == ' ') SKIP(41); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); - END_STATE(); - case 38: - ACCEPT_TOKEN(ts_builtin_sym_end); - END_STATE(); - case 39: - ACCEPT_TOKEN(anon_sym_DOT); - END_STATE(); - case 40: - ACCEPT_TOKEN(anon_sym_DOT); - if (lookahead == '.') ADVANCE(18); - END_STATE(); - case 41: - ACCEPT_TOKEN(anon_sym_COLON); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); case 42: - ACCEPT_TOKEN(anon_sym_EQ); + ACCEPT_TOKEN(ts_builtin_sym_end); END_STATE(); case 43: - ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '=') ADVANCE(66); + ACCEPT_TOKEN(anon_sym_DOT); END_STATE(); case 44: - ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '=') ADVANCE(66); - if (lookahead == '>') ADVANCE(62); + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(20); END_STATE(); case 45: - ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '>') ADVANCE(62); + ACCEPT_TOKEN(anon_sym_COLON_COLON); END_STATE(); case 46: - ACCEPT_TOKEN(anon_sym_LT); + ACCEPT_TOKEN(anon_sym_LBRACE); END_STATE(); case 47: - ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '=') ADVANCE(68); + ACCEPT_TOKEN(anon_sym_RBRACE); END_STATE(); case 48: - ACCEPT_TOKEN(anon_sym_GT); + ACCEPT_TOKEN(anon_sym_STAR); END_STATE(); case 49: - ACCEPT_TOKEN(anon_sym_GT); - if (lookahead == '=') ADVANCE(69); + ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); case 50: - ACCEPT_TOKEN(anon_sym_LPAREN); + ACCEPT_TOKEN(anon_sym_SEMI); END_STATE(); case 51: - ACCEPT_TOKEN(anon_sym_RPAREN); + ACCEPT_TOKEN(anon_sym_COLON); + if (lookahead == ':') ADVANCE(45); END_STATE(); case 52: - ACCEPT_TOKEN(anon_sym_DASH_GT); + ACCEPT_TOKEN(anon_sym_EQ); END_STATE(); case 53: - ACCEPT_TOKEN(anon_sym_COMMA); + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(73); END_STATE(); case 54: - ACCEPT_TOKEN(anon_sym_PIPE); + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(73); + if (lookahead == '>') ADVANCE(69); END_STATE(); case 55: - ACCEPT_TOKEN(anon_sym_PIPE); - if (lookahead == '>') ADVANCE(77); - if (lookahead == '|') ADVANCE(64); + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '>') ADVANCE(69); END_STATE(); case 56: - ACCEPT_TOKEN(anon_sym_LBRACE); + ACCEPT_TOKEN(anon_sym_LT); END_STATE(); case 57: - ACCEPT_TOKEN(anon_sym_RBRACE); + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '=') ADVANCE(75); END_STATE(); case 58: - ACCEPT_TOKEN(anon_sym_BANG); + ACCEPT_TOKEN(anon_sym_GT); END_STATE(); case 59: - ACCEPT_TOKEN(anon_sym_BANG); - if (lookahead == '=') ADVANCE(67); + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(76); END_STATE(); case 60: - ACCEPT_TOKEN(anon_sym_LBRACK); + ACCEPT_TOKEN(anon_sym_LPAREN); END_STATE(); case 61: - ACCEPT_TOKEN(anon_sym_RBRACK); + ACCEPT_TOKEN(anon_sym_RPAREN); END_STATE(); case 62: - ACCEPT_TOKEN(anon_sym_EQ_GT); + ACCEPT_TOKEN(anon_sym_DASH_GT); END_STATE(); case 63: - ACCEPT_TOKEN(anon_sym_QMARK); + ACCEPT_TOKEN(anon_sym_PIPE); END_STATE(); case 64: - ACCEPT_TOKEN(anon_sym_PIPE_PIPE); + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '>') ADVANCE(83); + if (lookahead == '|') ADVANCE(71); END_STATE(); case 65: - ACCEPT_TOKEN(anon_sym_AMP_AMP); + ACCEPT_TOKEN(anon_sym_BANG); END_STATE(); case 66: - ACCEPT_TOKEN(anon_sym_EQ_EQ); + ACCEPT_TOKEN(anon_sym_BANG); + if (lookahead == '=') ADVANCE(74); END_STATE(); case 67: - ACCEPT_TOKEN(anon_sym_BANG_EQ); + ACCEPT_TOKEN(anon_sym_LBRACK); END_STATE(); case 68: - ACCEPT_TOKEN(anon_sym_LT_EQ); + ACCEPT_TOKEN(anon_sym_RBRACK); END_STATE(); case 69: - ACCEPT_TOKEN(anon_sym_GT_EQ); + ACCEPT_TOKEN(anon_sym_EQ_GT); END_STATE(); case 70: - ACCEPT_TOKEN(anon_sym_PLUS); + ACCEPT_TOKEN(anon_sym_QMARK); END_STATE(); case 71: - ACCEPT_TOKEN(anon_sym_DASH); + ACCEPT_TOKEN(anon_sym_PIPE_PIPE); END_STATE(); case 72: - ACCEPT_TOKEN(anon_sym_DASH); - if (lookahead == '>') ADVANCE(52); + ACCEPT_TOKEN(anon_sym_AMP_AMP); END_STATE(); case 73: - ACCEPT_TOKEN(anon_sym_STAR); + ACCEPT_TOKEN(anon_sym_EQ_EQ); END_STATE(); case 74: - ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(90); + ACCEPT_TOKEN(anon_sym_BANG_EQ); END_STATE(); case 75: - ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(91); + ACCEPT_TOKEN(anon_sym_LT_EQ); END_STATE(); case 76: - ACCEPT_TOKEN(anon_sym_PERCENT); + ACCEPT_TOKEN(anon_sym_GT_EQ); END_STATE(); case 77: - ACCEPT_TOKEN(anon_sym_PIPE_GT); + ACCEPT_TOKEN(anon_sym_PLUS); END_STATE(); case 78: - ACCEPT_TOKEN(anon_sym_LBRACK2); + ACCEPT_TOKEN(anon_sym_DASH); END_STATE(); case 79: - ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + ACCEPT_TOKEN(anon_sym_DASH); + if (lookahead == '>') ADVANCE(62); END_STATE(); case 80: - ACCEPT_TOKEN(sym_float); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(80); + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(96); END_STATE(); case 81: - ACCEPT_TOKEN(sym_integer); - if (lookahead == '.') ADVANCE(26); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(81); + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(97); END_STATE(); case 82: - ACCEPT_TOKEN(sym_string); + ACCEPT_TOKEN(anon_sym_PERCENT); END_STATE(); case 83: - ACCEPT_TOKEN(sym_string); - if (lookahead == '"') ADVANCE(86); - if (lookahead == '$') ADVANCE(24); - if (lookahead == '\\') ADVANCE(30); - if (lookahead != 0) ADVANCE(13); + ACCEPT_TOKEN(anon_sym_PIPE_GT); END_STATE(); case 84: + ACCEPT_TOKEN(anon_sym_LBRACK2); + END_STATE(); + case 85: + ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + END_STATE(); + case 86: + ACCEPT_TOKEN(sym_float); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(86); + END_STATE(); + case 87: + ACCEPT_TOKEN(sym_integer); + if (lookahead == '.') ADVANCE(30); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); + END_STATE(); + case 88: + ACCEPT_TOKEN(sym_string); + END_STATE(); + case 89: ACCEPT_TOKEN(sym_string); - if (lookahead == '$') ADVANCE(23); - if (lookahead == '\\') ADVANCE(28); + if (lookahead == '"') ADVANCE(92); + if (lookahead == '$') ADVANCE(28); + if (lookahead == '\\') ADVANCE(34); + if (lookahead != 0) ADVANCE(15); + END_STATE(); + case 90: + ACCEPT_TOKEN(sym_string); + if (lookahead == '$') ADVANCE(27); + if (lookahead == '\\') ADVANCE(32); if (lookahead != 0 && - lookahead != '"') ADVANCE(15); + lookahead != '"') ADVANCE(17); END_STATE(); - case 85: + case 91: ACCEPT_TOKEN(sym_string); - if (lookahead == '}') ADVANCE(13); - if (lookahead != 0) ADVANCE(25); + if (lookahead == '}') ADVANCE(15); + if (lookahead != 0) ADVANCE(29); END_STATE(); - case 86: + case 92: ACCEPT_TOKEN(sym_interpolated_string); END_STATE(); - case 87: + case 93: ACCEPT_TOKEN(sym_interpolated_string); - if (lookahead == '"') ADVANCE(82); - if (lookahead == '\\') ADVANCE(29); - if (lookahead != 0) ADVANCE(10); + if (lookahead == '"') ADVANCE(88); + if (lookahead == '\\') ADVANCE(33); + if (lookahead != 0) ADVANCE(11); END_STATE(); - case 88: + case 94: ACCEPT_TOKEN(sym_identifier); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(94); END_STATE(); - case 89: + case 95: ACCEPT_TOKEN(sym__doc_comment_line); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(89); + lookahead != '\r') ADVANCE(95); END_STATE(); - case 90: + case 96: ACCEPT_TOKEN(sym_line_comment); - if (lookahead == '/') ADVANCE(89); + if (lookahead == '/') ADVANCE(95); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(91); + lookahead != '\r') ADVANCE(97); END_STATE(); - case 91: + case 97: ACCEPT_TOKEN(sym_line_comment); if (lookahead != 0 && lookahead != '\n' && - lookahead != '\r') ADVANCE(91); + lookahead != '\r') ADVANCE(97); END_STATE(); default: return false; @@ -3926,13 +4798,14 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { 'i', 6, 'l', 7, 'm', 8, - 'o', 9, - 'p', 10, - 'r', 11, - 's', 12, - 't', 13, - 'w', 14, - 'y', 15, + 'n', 9, + 'o', 10, + 'p', 11, + 'r', 12, + 's', 13, + 't', 14, + 'w', 15, + 'y', 16, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(0); @@ -3941,319 +4814,424 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { ACCEPT_TOKEN(anon_sym__); END_STATE(); case 2: - if (lookahead == 'w') ADVANCE(16); + if (lookahead == 's') ADVANCE(17); + if (lookahead == 'w') ADVANCE(18); END_STATE(); case 3: - if (lookahead == 'f') ADVANCE(17); - if (lookahead == 'l') ADVANCE(18); - if (lookahead == 'x') ADVANCE(19); + if (lookahead == 'f') ADVANCE(19); + if (lookahead == 'l') ADVANCE(20); + if (lookahead == 'x') ADVANCE(21); END_STATE(); case 4: - if (lookahead == 'a') ADVANCE(20); - if (lookahead == 'n') ADVANCE(21); + if (lookahead == 'a') ADVANCE(22); + if (lookahead == 'n') ADVANCE(23); END_STATE(); case 5: - if (lookahead == 'a') ADVANCE(22); + if (lookahead == 'a') ADVANCE(24); END_STATE(); case 6: - if (lookahead == 'f') ADVANCE(23); - if (lookahead == 'm') ADVANCE(24); - if (lookahead == 'n') ADVANCE(25); + if (lookahead == 'f') ADVANCE(25); + if (lookahead == 'm') ADVANCE(26); + if (lookahead == 'n') ADVANCE(27); END_STATE(); case 7: - if (lookahead == 'e') ADVANCE(26); + if (lookahead == 'e') ADVANCE(28); END_STATE(); case 8: - if (lookahead == 'a') ADVANCE(27); - if (lookahead == 'o') ADVANCE(28); - if (lookahead == 'u') ADVANCE(29); + if (lookahead == 'a') ADVANCE(29); + if (lookahead == 'o') ADVANCE(30); + if (lookahead == 'u') ADVANCE(31); END_STATE(); case 9: - if (lookahead == 'u') ADVANCE(30); + if (lookahead == 'a') ADVANCE(32); END_STATE(); case 10: - if (lookahead == 'e') ADVANCE(31); + if (lookahead == 'p') ADVANCE(33); + if (lookahead == 'u') ADVANCE(34); END_STATE(); case 11: - if (lookahead == 'e') ADVANCE(32); + if (lookahead == 'e') ADVANCE(35); END_STATE(); case 12: - if (lookahead == 'e') ADVANCE(33); - if (lookahead == 'p') ADVANCE(34); + if (lookahead == 'e') ADVANCE(36); END_STATE(); case 13: - if (lookahead == 'r') ADVANCE(35); - if (lookahead == 'y') ADVANCE(36); + if (lookahead == 'e') ADVANCE(37); + if (lookahead == 'i') ADVANCE(38); + if (lookahead == 'p') ADVANCE(39); + if (lookahead == 't') ADVANCE(40); END_STATE(); case 14: - if (lookahead == 'h') ADVANCE(37); + if (lookahead == 'r') ADVANCE(41); + if (lookahead == 'y') ADVANCE(42); END_STATE(); case 15: - if (lookahead == 'i') ADVANCE(38); + if (lookahead == 'h') ADVANCE(43); END_STATE(); case 16: - if (lookahead == 'a') ADVANCE(39); + if (lookahead == 'i') ADVANCE(44); END_STATE(); case 17: - if (lookahead == 'f') ADVANCE(40); + ACCEPT_TOKEN(anon_sym_as); END_STATE(); case 18: - if (lookahead == 's') ADVANCE(41); + if (lookahead == 'a') ADVANCE(45); END_STATE(); case 19: - if (lookahead == 't') ADVANCE(42); + if (lookahead == 'f') ADVANCE(46); END_STATE(); case 20: - if (lookahead == 'l') ADVANCE(43); + if (lookahead == 's') ADVANCE(47); END_STATE(); case 21: - ACCEPT_TOKEN(anon_sym_fn); + if (lookahead == 'p') ADVANCE(48); + if (lookahead == 't') ADVANCE(49); END_STATE(); case 22: - if (lookahead == 'n') ADVANCE(44); + if (lookahead == 'l') ADVANCE(50); END_STATE(); case 23: - ACCEPT_TOKEN(anon_sym_if); + ACCEPT_TOKEN(anon_sym_fn); END_STATE(); case 24: - if (lookahead == 'p') ADVANCE(45); + if (lookahead == 'n') ADVANCE(51); END_STATE(); case 25: - ACCEPT_TOKEN(anon_sym_in); + ACCEPT_TOKEN(anon_sym_if); END_STATE(); case 26: - if (lookahead == 't') ADVANCE(46); + if (lookahead == 'p') ADVANCE(52); END_STATE(); case 27: - if (lookahead == 't') ADVANCE(47); + ACCEPT_TOKEN(anon_sym_in); END_STATE(); case 28: - if (lookahead == 'd') ADVANCE(48); + if (lookahead == 't') ADVANCE(53); END_STATE(); case 29: - if (lookahead == 't') ADVANCE(49); + if (lookahead == 't') ADVANCE(54); END_STATE(); case 30: - if (lookahead == 't') ADVANCE(50); + if (lookahead == 'd') ADVANCE(55); END_STATE(); case 31: - if (lookahead == 'r') ADVANCE(51); + if (lookahead == 't') ADVANCE(56); END_STATE(); case 32: - if (lookahead == 'c') ADVANCE(52); - if (lookahead == 's') ADVANCE(53); + if (lookahead == 'm') ADVANCE(57); END_STATE(); case 33: - if (lookahead == 'l') ADVANCE(54); - if (lookahead == 'n') ADVANCE(55); + if (lookahead == 'a') ADVANCE(58); END_STATE(); case 34: - if (lookahead == 'a') ADVANCE(56); + if (lookahead == 't') ADVANCE(59); END_STATE(); case 35: - if (lookahead == 'u') ADVANCE(57); + if (lookahead == 'r') ADVANCE(60); END_STATE(); case 36: - if (lookahead == 'p') ADVANCE(58); + if (lookahead == 'c') ADVANCE(61); + if (lookahead == 's') ADVANCE(62); END_STATE(); case 37: - if (lookahead == 'e') ADVANCE(59); + if (lookahead == 'l') ADVANCE(63); + if (lookahead == 'n') ADVANCE(64); END_STATE(); case 38: - if (lookahead == 'e') ADVANCE(60); + if (lookahead == 'g') ADVANCE(65); END_STATE(); case 39: - if (lookahead == 'i') ADVANCE(61); + if (lookahead == 'a') ADVANCE(66); END_STATE(); case 40: - if (lookahead == 'e') ADVANCE(62); + if (lookahead == 'a') ADVANCE(67); END_STATE(); case 41: - if (lookahead == 'e') ADVANCE(63); + if (lookahead == 'u') ADVANCE(68); END_STATE(); case 42: - if (lookahead == 'e') ADVANCE(64); + if (lookahead == 'p') ADVANCE(69); END_STATE(); case 43: - if (lookahead == 's') ADVANCE(65); + if (lookahead == 'e') ADVANCE(70); END_STATE(); case 44: - if (lookahead == 'd') ADVANCE(66); + if (lookahead == 'e') ADVANCE(71); END_STATE(); case 45: - if (lookahead == 'o') ADVANCE(67); + if (lookahead == 'i') ADVANCE(72); END_STATE(); case 46: - ACCEPT_TOKEN(anon_sym_let); + if (lookahead == 'e') ADVANCE(73); END_STATE(); case 47: - if (lookahead == 'c') ADVANCE(68); + if (lookahead == 'e') ADVANCE(74); END_STATE(); case 48: - if (lookahead == 'u') ADVANCE(69); + if (lookahead == 'o') ADVANCE(75); END_STATE(); case 49: - ACCEPT_TOKEN(anon_sym_mut); + if (lookahead == 'e') ADVANCE(76); + if (lookahead == 'r') ADVANCE(77); END_STATE(); case 50: - ACCEPT_TOKEN(anon_sym_out); + if (lookahead == 's') ADVANCE(78); END_STATE(); case 51: - if (lookahead == 'f') ADVANCE(70); + if (lookahead == 'd') ADVANCE(79); END_STATE(); case 52: - if (lookahead == 'v') ADVANCE(71); + if (lookahead == 'o') ADVANCE(80); END_STATE(); case 53: - if (lookahead == 'u') ADVANCE(72); + ACCEPT_TOKEN(anon_sym_let); END_STATE(); case 54: - if (lookahead == 'e') ADVANCE(73); + if (lookahead == 'c') ADVANCE(81); END_STATE(); case 55: - if (lookahead == 'd') ADVANCE(74); + if (lookahead == 'u') ADVANCE(82); END_STATE(); case 56: - if (lookahead == 'w') ADVANCE(75); + ACCEPT_TOKEN(anon_sym_mut); END_STATE(); case 57: - if (lookahead == 'e') ADVANCE(76); + if (lookahead == 'e') ADVANCE(83); END_STATE(); case 58: - if (lookahead == 'e') ADVANCE(77); + if (lookahead == 'q') ADVANCE(84); END_STATE(); case 59: - if (lookahead == 'r') ADVANCE(78); + ACCEPT_TOKEN(anon_sym_out); END_STATE(); case 60: - if (lookahead == 'l') ADVANCE(79); + if (lookahead == 'f') ADVANCE(85); END_STATE(); case 61: - if (lookahead == 't') ADVANCE(80); + if (lookahead == 'v') ADVANCE(86); END_STATE(); case 62: - if (lookahead == 'c') ADVANCE(81); + if (lookahead == 'u') ADVANCE(87); END_STATE(); case 63: - ACCEPT_TOKEN(anon_sym_else); + if (lookahead == 'e') ADVANCE(88); END_STATE(); case 64: - if (lookahead == 'r') ADVANCE(82); + if (lookahead == 'd') ADVANCE(89); END_STATE(); case 65: - if (lookahead == 'e') ADVANCE(83); + if (lookahead == 'n') ADVANCE(90); END_STATE(); case 66: - if (lookahead == 'l') ADVANCE(84); + if (lookahead == 'w') ADVANCE(91); END_STATE(); case 67: - if (lookahead == 'r') ADVANCE(85); + if (lookahead == 't') ADVANCE(92); END_STATE(); case 68: - if (lookahead == 'h') ADVANCE(86); + if (lookahead == 'e') ADVANCE(93); END_STATE(); case 69: - if (lookahead == 'l') ADVANCE(87); + if (lookahead == 'e') ADVANCE(94); END_STATE(); case 70: - if (lookahead == 'o') ADVANCE(88); + if (lookahead == 'r') ADVANCE(95); END_STATE(); case 71: - ACCEPT_TOKEN(anon_sym_recv); + if (lookahead == 'l') ADVANCE(96); END_STATE(); case 72: - if (lookahead == 'm') ADVANCE(89); + if (lookahead == 't') ADVANCE(97); END_STATE(); case 73: - if (lookahead == 'c') ADVANCE(90); + if (lookahead == 'c') ADVANCE(98); END_STATE(); case 74: - ACCEPT_TOKEN(anon_sym_send); + ACCEPT_TOKEN(anon_sym_else); END_STATE(); case 75: - if (lookahead == 'n') ADVANCE(91); + if (lookahead == 'r') ADVANCE(99); END_STATE(); case 76: - ACCEPT_TOKEN(anon_sym_true); + if (lookahead == 'r') ADVANCE(100); END_STATE(); case 77: - ACCEPT_TOKEN(anon_sym_type); + if (lookahead == 'a') ADVANCE(101); END_STATE(); case 78: - if (lookahead == 'e') ADVANCE(92); + if (lookahead == 'e') ADVANCE(102); END_STATE(); case 79: - if (lookahead == 'd') ADVANCE(93); + if (lookahead == 'l') ADVANCE(103); END_STATE(); case 80: - ACCEPT_TOKEN(anon_sym_await); + if (lookahead == 'r') ADVANCE(104); END_STATE(); case 81: - if (lookahead == 't') ADVANCE(94); + if (lookahead == 'h') ADVANCE(105); END_STATE(); case 82: - if (lookahead == 'n') ADVANCE(95); + if (lookahead == 'l') ADVANCE(106); END_STATE(); case 83: - ACCEPT_TOKEN(anon_sym_false); + if (lookahead == 's') ADVANCE(107); END_STATE(); case 84: - if (lookahead == 'e') ADVANCE(96); + if (lookahead == 'u') ADVANCE(108); END_STATE(); case 85: - if (lookahead == 't') ADVANCE(97); + if (lookahead == 'o') ADVANCE(109); END_STATE(); case 86: - ACCEPT_TOKEN(anon_sym_match); + ACCEPT_TOKEN(anon_sym_recv); END_STATE(); case 87: - if (lookahead == 'e') ADVANCE(98); + if (lookahead == 'm') ADVANCE(110); END_STATE(); case 88: - if (lookahead == 'r') ADVANCE(99); + if (lookahead == 'c') ADVANCE(111); END_STATE(); case 89: - if (lookahead == 'e') ADVANCE(100); + ACCEPT_TOKEN(anon_sym_send); END_STATE(); case 90: - if (lookahead == 't') ADVANCE(101); + if (lookahead == 'a') ADVANCE(112); END_STATE(); case 91: - ACCEPT_TOKEN(anon_sym_spawn); + if (lookahead == 'n') ADVANCE(113); END_STATE(); case 92: - ACCEPT_TOKEN(anon_sym_where); + if (lookahead == 'e') ADVANCE(114); END_STATE(); case 93: - ACCEPT_TOKEN(anon_sym_yield); + ACCEPT_TOKEN(anon_sym_true); END_STATE(); case 94: - ACCEPT_TOKEN(anon_sym_effect); + ACCEPT_TOKEN(anon_sym_type); END_STATE(); case 95: - ACCEPT_TOKEN(anon_sym_extern); + if (lookahead == 'e') ADVANCE(115); END_STATE(); case 96: - ACCEPT_TOKEN(anon_sym_handle); + if (lookahead == 'd') ADVANCE(116); END_STATE(); case 97: - ACCEPT_TOKEN(anon_sym_import); + ACCEPT_TOKEN(anon_sym_await); END_STATE(); case 98: - ACCEPT_TOKEN(anon_sym_module); + if (lookahead == 't') ADVANCE(117); END_STATE(); case 99: - if (lookahead == 'm') ADVANCE(102); + if (lookahead == 't') ADVANCE(118); END_STATE(); case 100: - ACCEPT_TOKEN(anon_sym_resume); + if (lookahead == 'n') ADVANCE(119); END_STATE(); case 101: - ACCEPT_TOKEN(anon_sym_select); + ACCEPT_TOKEN(anon_sym_extra); END_STATE(); case 102: + ACCEPT_TOKEN(anon_sym_false); + END_STATE(); + case 103: + if (lookahead == 'e') ADVANCE(120); + END_STATE(); + case 104: + if (lookahead == 't') ADVANCE(121); + END_STATE(); + case 105: + ACCEPT_TOKEN(anon_sym_match); + END_STATE(); + case 106: + if (lookahead == 'e') ADVANCE(122); + END_STATE(); + case 107: + if (lookahead == 'p') ADVANCE(123); + END_STATE(); + case 108: + if (lookahead == 'e') ADVANCE(124); + END_STATE(); + case 109: + if (lookahead == 'r') ADVANCE(125); + END_STATE(); + case 110: + if (lookahead == 'e') ADVANCE(126); + END_STATE(); + case 111: + if (lookahead == 't') ADVANCE(127); + END_STATE(); + case 112: + if (lookahead == 't') ADVANCE(128); + END_STATE(); + case 113: + ACCEPT_TOKEN(anon_sym_spawn); + END_STATE(); + case 114: + ACCEPT_TOKEN(anon_sym_state); + END_STATE(); + case 115: + ACCEPT_TOKEN(anon_sym_where); + END_STATE(); + case 116: + ACCEPT_TOKEN(anon_sym_yield); + END_STATE(); + case 117: + ACCEPT_TOKEN(anon_sym_effect); + END_STATE(); + case 118: + ACCEPT_TOKEN(anon_sym_export); + END_STATE(); + case 119: + ACCEPT_TOKEN(anon_sym_extern); + END_STATE(); + case 120: + ACCEPT_TOKEN(anon_sym_handle); + END_STATE(); + case 121: + ACCEPT_TOKEN(anon_sym_import); + END_STATE(); + case 122: + ACCEPT_TOKEN(anon_sym_module); + END_STATE(); + case 123: + if (lookahead == 'a') ADVANCE(129); + END_STATE(); + case 124: + ACCEPT_TOKEN(anon_sym_opaque); + END_STATE(); + case 125: + if (lookahead == 'm') ADVANCE(130); + END_STATE(); + case 126: + ACCEPT_TOKEN(anon_sym_resume); + END_STATE(); + case 127: + ACCEPT_TOKEN(anon_sym_select); + END_STATE(); + case 128: + if (lookahead == 'u') ADVANCE(131); + END_STATE(); + case 129: + if (lookahead == 'c') ADVANCE(132); + END_STATE(); + case 130: ACCEPT_TOKEN(anon_sym_perform); END_STATE(); + case 131: + if (lookahead == 'r') ADVANCE(133); + END_STATE(); + case 132: + if (lookahead == 'e') ADVANCE(134); + END_STATE(); + case 133: + if (lookahead == 'e') ADVANCE(135); + END_STATE(); + case 134: + ACCEPT_TOKEN(anon_sym_namespace); + END_STATE(); + case 135: + ACCEPT_TOKEN(anon_sym_signature); + END_STATE(); default: return false; } @@ -4261,93 +5239,93 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { static const TSLexMode ts_lex_modes[STATE_COUNT] = { [0] = {.lex_state = 0}, - [1] = {.lex_state = 37}, - [2] = {.lex_state = 35}, - [3] = {.lex_state = 37}, - [4] = {.lex_state = 37}, - [5] = {.lex_state = 37}, - [6] = {.lex_state = 35}, - [7] = {.lex_state = 37}, - [8] = {.lex_state = 37}, - [9] = {.lex_state = 37}, - [10] = {.lex_state = 37}, - [11] = {.lex_state = 37}, - [12] = {.lex_state = 33}, - [13] = {.lex_state = 37}, - [14] = {.lex_state = 37}, - [15] = {.lex_state = 37}, - [16] = {.lex_state = 37}, - [17] = {.lex_state = 37}, - [18] = {.lex_state = 37}, - [19] = {.lex_state = 35}, - [20] = {.lex_state = 6}, - [21] = {.lex_state = 6}, - [22] = {.lex_state = 6}, - [23] = {.lex_state = 6}, - [24] = {.lex_state = 6}, + [1] = {.lex_state = 41}, + [2] = {.lex_state = 41}, + [3] = {.lex_state = 41}, + [4] = {.lex_state = 41}, + [5] = {.lex_state = 39}, + [6] = {.lex_state = 41}, + [7] = {.lex_state = 41}, + [8] = {.lex_state = 41}, + [9] = {.lex_state = 41}, + [10] = {.lex_state = 41}, + [11] = {.lex_state = 41}, + [12] = {.lex_state = 41}, + [13] = {.lex_state = 41}, + [14] = {.lex_state = 41}, + [15] = {.lex_state = 41}, + [16] = {.lex_state = 41}, + [17] = {.lex_state = 41}, + [18] = {.lex_state = 41}, + [19] = {.lex_state = 39}, + [20] = {.lex_state = 41}, + [21] = {.lex_state = 41}, + [22] = {.lex_state = 39}, + [23] = {.lex_state = 37}, + [24] = {.lex_state = 39}, [25] = {.lex_state = 6}, [26] = {.lex_state = 6}, - [27] = {.lex_state = 6}, + [27] = {.lex_state = 39}, [28] = {.lex_state = 6}, [29] = {.lex_state = 6}, - [30] = {.lex_state = 6}, + [30] = {.lex_state = 39}, [31] = {.lex_state = 6}, - [32] = {.lex_state = 6}, + [32] = {.lex_state = 39}, [33] = {.lex_state = 6}, - [34] = {.lex_state = 6}, - [35] = {.lex_state = 6}, - [36] = {.lex_state = 6}, - [37] = {.lex_state = 6}, - [38] = {.lex_state = 6}, - [39] = {.lex_state = 6}, - [40] = {.lex_state = 6}, - [41] = {.lex_state = 6}, - [42] = {.lex_state = 6}, - [43] = {.lex_state = 6}, - [44] = {.lex_state = 6}, - [45] = {.lex_state = 6}, - [46] = {.lex_state = 6}, + [34] = {.lex_state = 39}, + [35] = {.lex_state = 39}, + [36] = {.lex_state = 39}, + [37] = {.lex_state = 39}, + [38] = {.lex_state = 39}, + [39] = {.lex_state = 39}, + [40] = {.lex_state = 39}, + [41] = {.lex_state = 39}, + [42] = {.lex_state = 39}, + [43] = {.lex_state = 39}, + [44] = {.lex_state = 39}, + [45] = {.lex_state = 39}, + [46] = {.lex_state = 39}, [47] = {.lex_state = 6}, - [48] = {.lex_state = 6}, - [49] = {.lex_state = 6}, - [50] = {.lex_state = 6}, - [51] = {.lex_state = 6}, - [52] = {.lex_state = 6}, - [53] = {.lex_state = 6}, - [54] = {.lex_state = 6}, - [55] = {.lex_state = 6}, - [56] = {.lex_state = 6}, - [57] = {.lex_state = 6}, - [58] = {.lex_state = 6}, + [48] = {.lex_state = 39}, + [49] = {.lex_state = 39}, + [50] = {.lex_state = 39}, + [51] = {.lex_state = 39}, + [52] = {.lex_state = 39}, + [53] = {.lex_state = 39}, + [54] = {.lex_state = 39}, + [55] = {.lex_state = 39}, + [56] = {.lex_state = 39}, + [57] = {.lex_state = 39}, + [58] = {.lex_state = 39}, [59] = {.lex_state = 6}, - [60] = {.lex_state = 6}, - [61] = {.lex_state = 6}, - [62] = {.lex_state = 6}, - [63] = {.lex_state = 6}, - [64] = {.lex_state = 6}, + [60] = {.lex_state = 39}, + [61] = {.lex_state = 39}, + [62] = {.lex_state = 39}, + [63] = {.lex_state = 39}, + [64] = {.lex_state = 39}, [65] = {.lex_state = 6}, - [66] = {.lex_state = 6}, + [66] = {.lex_state = 39}, [67] = {.lex_state = 6}, - [68] = {.lex_state = 6}, + [68] = {.lex_state = 39}, [69] = {.lex_state = 6}, [70] = {.lex_state = 6}, [71] = {.lex_state = 6}, - [72] = {.lex_state = 6}, - [73] = {.lex_state = 6}, - [74] = {.lex_state = 6}, - [75] = {.lex_state = 6}, - [76] = {.lex_state = 6}, + [72] = {.lex_state = 39}, + [73] = {.lex_state = 39}, + [74] = {.lex_state = 39}, + [75] = {.lex_state = 39}, + [76] = {.lex_state = 39}, [77] = {.lex_state = 6}, - [78] = {.lex_state = 6}, - [79] = {.lex_state = 6}, + [78] = {.lex_state = 39}, + [79] = {.lex_state = 39}, [80] = {.lex_state = 6}, - [81] = {.lex_state = 6}, + [81] = {.lex_state = 39}, [82] = {.lex_state = 6}, - [83] = {.lex_state = 6}, - [84] = {.lex_state = 6}, - [85] = {.lex_state = 6}, + [83] = {.lex_state = 39}, + [84] = {.lex_state = 39}, + [85] = {.lex_state = 39}, [86] = {.lex_state = 6}, - [87] = {.lex_state = 6}, + [87] = {.lex_state = 39}, [88] = {.lex_state = 6}, [89] = {.lex_state = 6}, [90] = {.lex_state = 6}, @@ -4384,7 +5362,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [121] = {.lex_state = 6}, [122] = {.lex_state = 6}, [123] = {.lex_state = 6}, - [124] = {.lex_state = 6}, + [124] = {.lex_state = 39}, [125] = {.lex_state = 6}, [126] = {.lex_state = 6}, [127] = {.lex_state = 6}, @@ -4414,17 +5392,17 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [151] = {.lex_state = 6}, [152] = {.lex_state = 6}, [153] = {.lex_state = 6}, - [154] = {.lex_state = 6}, - [155] = {.lex_state = 6}, - [156] = {.lex_state = 6}, - [157] = {.lex_state = 6}, + [154] = {.lex_state = 39}, + [155] = {.lex_state = 39}, + [156] = {.lex_state = 39}, + [157] = {.lex_state = 39}, [158] = {.lex_state = 6}, - [159] = {.lex_state = 6}, + [159] = {.lex_state = 39}, [160] = {.lex_state = 6}, - [161] = {.lex_state = 6}, - [162] = {.lex_state = 6}, - [163] = {.lex_state = 6}, - [164] = {.lex_state = 6}, + [161] = {.lex_state = 39}, + [162] = {.lex_state = 39}, + [163] = {.lex_state = 39}, + [164] = {.lex_state = 39}, [165] = {.lex_state = 6}, [166] = {.lex_state = 6}, [167] = {.lex_state = 6}, @@ -4434,77 +5412,77 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [171] = {.lex_state = 6}, [172] = {.lex_state = 6}, [173] = {.lex_state = 6}, - [174] = {.lex_state = 6}, - [175] = {.lex_state = 6}, - [176] = {.lex_state = 6}, + [174] = {.lex_state = 39}, + [175] = {.lex_state = 39}, + [176] = {.lex_state = 39}, [177] = {.lex_state = 6}, - [178] = {.lex_state = 6}, + [178] = {.lex_state = 39}, [179] = {.lex_state = 6}, - [180] = {.lex_state = 6}, - [181] = {.lex_state = 6}, - [182] = {.lex_state = 6}, - [183] = {.lex_state = 6}, - [184] = {.lex_state = 6}, - [185] = {.lex_state = 6}, + [180] = {.lex_state = 39}, + [181] = {.lex_state = 39}, + [182] = {.lex_state = 39}, + [183] = {.lex_state = 39}, + [184] = {.lex_state = 39}, + [185] = {.lex_state = 39}, [186] = {.lex_state = 6}, - [187] = {.lex_state = 6}, - [188] = {.lex_state = 6}, - [189] = {.lex_state = 6}, - [190] = {.lex_state = 6}, - [191] = {.lex_state = 6}, - [192] = {.lex_state = 6}, + [187] = {.lex_state = 39}, + [188] = {.lex_state = 39}, + [189] = {.lex_state = 39}, + [190] = {.lex_state = 39}, + [191] = {.lex_state = 39}, + [192] = {.lex_state = 39}, [193] = {.lex_state = 6}, - [194] = {.lex_state = 6}, - [195] = {.lex_state = 6}, - [196] = {.lex_state = 6}, + [194] = {.lex_state = 39}, + [195] = {.lex_state = 39}, + [196] = {.lex_state = 39}, [197] = {.lex_state = 6}, - [198] = {.lex_state = 6}, + [198] = {.lex_state = 39}, [199] = {.lex_state = 6}, - [200] = {.lex_state = 6}, - [201] = {.lex_state = 6}, - [202] = {.lex_state = 6}, - [203] = {.lex_state = 6}, - [204] = {.lex_state = 6}, + [200] = {.lex_state = 39}, + [201] = {.lex_state = 39}, + [202] = {.lex_state = 39}, + [203] = {.lex_state = 39}, + [204] = {.lex_state = 39}, [205] = {.lex_state = 6}, - [206] = {.lex_state = 6}, - [207] = {.lex_state = 6}, + [206] = {.lex_state = 39}, + [207] = {.lex_state = 39}, [208] = {.lex_state = 6}, [209] = {.lex_state = 6}, - [210] = {.lex_state = 6}, + [210] = {.lex_state = 39}, [211] = {.lex_state = 6}, [212] = {.lex_state = 6}, - [213] = {.lex_state = 6}, - [214] = {.lex_state = 6}, - [215] = {.lex_state = 6}, - [216] = {.lex_state = 6}, + [213] = {.lex_state = 39}, + [214] = {.lex_state = 39}, + [215] = {.lex_state = 39}, + [216] = {.lex_state = 39}, [217] = {.lex_state = 6}, - [218] = {.lex_state = 6}, + [218] = {.lex_state = 39}, [219] = {.lex_state = 6}, [220] = {.lex_state = 6}, - [221] = {.lex_state = 6}, - [222] = {.lex_state = 35}, + [221] = {.lex_state = 39}, + [222] = {.lex_state = 39}, [223] = {.lex_state = 6}, [224] = {.lex_state = 6}, - [225] = {.lex_state = 6}, + [225] = {.lex_state = 39}, [226] = {.lex_state = 6}, [227] = {.lex_state = 6}, [228] = {.lex_state = 6}, - [229] = {.lex_state = 6}, - [230] = {.lex_state = 6}, + [229] = {.lex_state = 39}, + [230] = {.lex_state = 39}, [231] = {.lex_state = 6}, [232] = {.lex_state = 6}, [233] = {.lex_state = 6}, - [234] = {.lex_state = 6}, + [234] = {.lex_state = 39}, [235] = {.lex_state = 6}, [236] = {.lex_state = 6}, [237] = {.lex_state = 6}, - [238] = {.lex_state = 6}, + [238] = {.lex_state = 39}, [239] = {.lex_state = 6}, [240] = {.lex_state = 6}, [241] = {.lex_state = 6}, [242] = {.lex_state = 6}, [243] = {.lex_state = 6}, - [244] = {.lex_state = 6}, + [244] = {.lex_state = 39}, [245] = {.lex_state = 6}, [246] = {.lex_state = 6}, [247] = {.lex_state = 6}, @@ -4523,1185 +5501,1538 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [260] = {.lex_state = 6}, [261] = {.lex_state = 6}, [262] = {.lex_state = 6}, - [263] = {.lex_state = 35}, - [264] = {.lex_state = 35}, - [265] = {.lex_state = 35}, - [266] = {.lex_state = 35}, - [267] = {.lex_state = 35}, - [268] = {.lex_state = 35}, - [269] = {.lex_state = 35}, - [270] = {.lex_state = 35}, - [271] = {.lex_state = 35}, - [272] = {.lex_state = 35}, - [273] = {.lex_state = 35}, - [274] = {.lex_state = 35}, - [275] = {.lex_state = 35}, - [276] = {.lex_state = 35}, - [277] = {.lex_state = 35}, - [278] = {.lex_state = 35}, - [279] = {.lex_state = 35}, - [280] = {.lex_state = 35}, - [281] = {.lex_state = 35}, - [282] = {.lex_state = 35}, - [283] = {.lex_state = 35}, - [284] = {.lex_state = 35}, - [285] = {.lex_state = 35}, - [286] = {.lex_state = 35}, - [287] = {.lex_state = 35}, - [288] = {.lex_state = 35}, - [289] = {.lex_state = 35}, - [290] = {.lex_state = 35}, - [291] = {.lex_state = 35}, - [292] = {.lex_state = 35}, - [293] = {.lex_state = 35}, - [294] = {.lex_state = 35}, - [295] = {.lex_state = 35}, - [296] = {.lex_state = 35}, - [297] = {.lex_state = 35}, - [298] = {.lex_state = 35}, - [299] = {.lex_state = 35}, - [300] = {.lex_state = 35}, - [301] = {.lex_state = 35}, - [302] = {.lex_state = 35}, - [303] = {.lex_state = 35}, - [304] = {.lex_state = 35}, - [305] = {.lex_state = 35}, - [306] = {.lex_state = 35}, - [307] = {.lex_state = 35}, - [308] = {.lex_state = 35}, - [309] = {.lex_state = 35}, - [310] = {.lex_state = 35}, - [311] = {.lex_state = 35}, - [312] = {.lex_state = 35}, - [313] = {.lex_state = 35}, - [314] = {.lex_state = 35}, - [315] = {.lex_state = 35}, - [316] = {.lex_state = 35}, - [317] = {.lex_state = 35}, - [318] = {.lex_state = 35}, - [319] = {.lex_state = 35}, - [320] = {.lex_state = 35}, - [321] = {.lex_state = 35}, - [322] = {.lex_state = 35}, - [323] = {.lex_state = 35}, - [324] = {.lex_state = 35}, - [325] = {.lex_state = 35}, - [326] = {.lex_state = 35}, - [327] = {.lex_state = 35}, - [328] = {.lex_state = 35}, - [329] = {.lex_state = 35}, - [330] = {.lex_state = 35}, - [331] = {.lex_state = 35}, - [332] = {.lex_state = 35}, - [333] = {.lex_state = 35}, - [334] = {.lex_state = 35}, - [335] = {.lex_state = 35}, - [336] = {.lex_state = 35}, - [337] = {.lex_state = 35}, - [338] = {.lex_state = 35}, - [339] = {.lex_state = 35}, - [340] = {.lex_state = 35}, - [341] = {.lex_state = 35}, - [342] = {.lex_state = 35}, - [343] = {.lex_state = 35}, - [344] = {.lex_state = 35}, - [345] = {.lex_state = 35}, - [346] = {.lex_state = 35}, - [347] = {.lex_state = 35}, - [348] = {.lex_state = 35}, - [349] = {.lex_state = 35}, - [350] = {.lex_state = 35}, - [351] = {.lex_state = 35}, - [352] = {.lex_state = 35}, - [353] = {.lex_state = 35}, - [354] = {.lex_state = 35}, - [355] = {.lex_state = 35}, - [356] = {.lex_state = 35}, - [357] = {.lex_state = 35}, - [358] = {.lex_state = 35}, - [359] = {.lex_state = 35}, - [360] = {.lex_state = 35}, - [361] = {.lex_state = 35}, - [362] = {.lex_state = 35}, - [363] = {.lex_state = 35}, - [364] = {.lex_state = 35}, - [365] = {.lex_state = 35}, - [366] = {.lex_state = 35}, - [367] = {.lex_state = 35}, - [368] = {.lex_state = 35}, - [369] = {.lex_state = 35}, - [370] = {.lex_state = 35}, - [371] = {.lex_state = 35}, - [372] = {.lex_state = 35}, - [373] = {.lex_state = 35}, - [374] = {.lex_state = 35}, - [375] = {.lex_state = 35}, - [376] = {.lex_state = 35}, - [377] = {.lex_state = 35}, - [378] = {.lex_state = 35}, - [379] = {.lex_state = 35}, - [380] = {.lex_state = 35}, - [381] = {.lex_state = 35}, - [382] = {.lex_state = 35}, - [383] = {.lex_state = 35}, - [384] = {.lex_state = 35}, - [385] = {.lex_state = 35}, - [386] = {.lex_state = 35}, - [387] = {.lex_state = 35}, - [388] = {.lex_state = 35}, - [389] = {.lex_state = 35}, - [390] = {.lex_state = 35}, - [391] = {.lex_state = 35}, - [392] = {.lex_state = 35}, - [393] = {.lex_state = 35}, - [394] = {.lex_state = 35}, - [395] = {.lex_state = 35}, - [396] = {.lex_state = 35}, - [397] = {.lex_state = 35}, - [398] = {.lex_state = 35}, - [399] = {.lex_state = 35}, - [400] = {.lex_state = 35}, - [401] = {.lex_state = 35}, - [402] = {.lex_state = 35}, - [403] = {.lex_state = 35}, - [404] = {.lex_state = 35}, - [405] = {.lex_state = 35}, - [406] = {.lex_state = 35}, - [407] = {.lex_state = 35}, - [408] = {.lex_state = 35}, - [409] = {.lex_state = 35}, - [410] = {.lex_state = 35}, - [411] = {.lex_state = 35}, - [412] = {.lex_state = 35}, - [413] = {.lex_state = 35}, - [414] = {.lex_state = 35}, - [415] = {.lex_state = 35}, - [416] = {.lex_state = 35}, - [417] = {.lex_state = 35}, - [418] = {.lex_state = 35}, - [419] = {.lex_state = 35}, - [420] = {.lex_state = 35}, - [421] = {.lex_state = 35}, - [422] = {.lex_state = 35}, - [423] = {.lex_state = 35}, - [424] = {.lex_state = 35}, - [425] = {.lex_state = 35}, - [426] = {.lex_state = 35}, - [427] = {.lex_state = 35}, - [428] = {.lex_state = 35}, - [429] = {.lex_state = 35}, - [430] = {.lex_state = 35}, - [431] = {.lex_state = 35}, - [432] = {.lex_state = 35}, - [433] = {.lex_state = 35}, - [434] = {.lex_state = 35}, - [435] = {.lex_state = 35}, - [436] = {.lex_state = 35}, - [437] = {.lex_state = 35}, - [438] = {.lex_state = 35}, - [439] = {.lex_state = 35}, - [440] = {.lex_state = 35}, - [441] = {.lex_state = 35}, - [442] = {.lex_state = 35}, - [443] = {.lex_state = 35}, - [444] = {.lex_state = 35}, - [445] = {.lex_state = 35}, - [446] = {.lex_state = 35}, - [447] = {.lex_state = 35}, - [448] = {.lex_state = 35}, - [449] = {.lex_state = 35}, - [450] = {.lex_state = 35}, - [451] = {.lex_state = 35}, - [452] = {.lex_state = 35}, - [453] = {.lex_state = 35}, - [454] = {.lex_state = 37}, - [455] = {.lex_state = 37}, - [456] = {.lex_state = 37}, - [457] = {.lex_state = 37}, - [458] = {.lex_state = 37}, - [459] = {.lex_state = 37}, - [460] = {.lex_state = 37}, - [461] = {.lex_state = 37}, - [462] = {.lex_state = 37}, - [463] = {.lex_state = 37}, - [464] = {.lex_state = 37}, - [465] = {.lex_state = 37}, - [466] = {.lex_state = 37}, - [467] = {.lex_state = 37}, - [468] = {.lex_state = 37}, - [469] = {.lex_state = 37}, - [470] = {.lex_state = 37}, - [471] = {.lex_state = 37}, - [472] = {.lex_state = 37}, - [473] = {.lex_state = 37}, - [474] = {.lex_state = 37}, - [475] = {.lex_state = 37}, - [476] = {.lex_state = 37}, - [477] = {.lex_state = 37}, - [478] = {.lex_state = 37}, - [479] = {.lex_state = 37}, - [480] = {.lex_state = 37}, - [481] = {.lex_state = 37}, - [482] = {.lex_state = 37}, - [483] = {.lex_state = 37}, - [484] = {.lex_state = 37}, - [485] = {.lex_state = 37}, - [486] = {.lex_state = 37}, - [487] = {.lex_state = 37}, - [488] = {.lex_state = 37}, - [489] = {.lex_state = 37}, - [490] = {.lex_state = 37}, - [491] = {.lex_state = 37}, - [492] = {.lex_state = 37}, - [493] = {.lex_state = 37}, - [494] = {.lex_state = 37}, - [495] = {.lex_state = 37}, - [496] = {.lex_state = 37}, - [497] = {.lex_state = 37}, - [498] = {.lex_state = 37}, - [499] = {.lex_state = 37}, - [500] = {.lex_state = 37}, - [501] = {.lex_state = 37}, - [502] = {.lex_state = 37}, - [503] = {.lex_state = 37}, - [504] = {.lex_state = 37}, - [505] = {.lex_state = 37}, - [506] = {.lex_state = 37}, - [507] = {.lex_state = 37}, - [508] = {.lex_state = 37}, - [509] = {.lex_state = 37}, - [510] = {.lex_state = 37}, - [511] = {.lex_state = 37}, - [512] = {.lex_state = 37}, - [513] = {.lex_state = 37}, - [514] = {.lex_state = 37}, - [515] = {.lex_state = 37}, - [516] = {.lex_state = 37}, - [517] = {.lex_state = 37}, - [518] = {.lex_state = 37}, - [519] = {.lex_state = 37}, - [520] = {.lex_state = 37}, - [521] = {.lex_state = 37}, - [522] = {.lex_state = 37}, - [523] = {.lex_state = 37}, - [524] = {.lex_state = 37}, - [525] = {.lex_state = 37}, - [526] = {.lex_state = 37}, - [527] = {.lex_state = 37}, - [528] = {.lex_state = 37}, - [529] = {.lex_state = 37}, - [530] = {.lex_state = 37}, - [531] = {.lex_state = 37}, - [532] = {.lex_state = 37}, - [533] = {.lex_state = 37}, - [534] = {.lex_state = 37}, - [535] = {.lex_state = 37}, - [536] = {.lex_state = 37}, - [537] = {.lex_state = 37}, - [538] = {.lex_state = 37}, - [539] = {.lex_state = 37}, - [540] = {.lex_state = 37}, - [541] = {.lex_state = 37}, - [542] = {.lex_state = 37}, - [543] = {.lex_state = 37}, - [544] = {.lex_state = 37}, - [545] = {.lex_state = 37}, - [546] = {.lex_state = 37}, - [547] = {.lex_state = 37}, - [548] = {.lex_state = 37}, - [549] = {.lex_state = 37}, - [550] = {.lex_state = 37}, - [551] = {.lex_state = 37}, - [552] = {.lex_state = 37}, - [553] = {.lex_state = 37}, - [554] = {.lex_state = 37}, - [555] = {.lex_state = 37}, - [556] = {.lex_state = 37}, - [557] = {.lex_state = 37}, - [558] = {.lex_state = 37}, - [559] = {.lex_state = 37}, - [560] = {.lex_state = 37}, - [561] = {.lex_state = 37}, - [562] = {.lex_state = 37}, - [563] = {.lex_state = 37}, - [564] = {.lex_state = 37}, - [565] = {.lex_state = 37}, - [566] = {.lex_state = 37}, - [567] = {.lex_state = 37}, - [568] = {.lex_state = 37}, - [569] = {.lex_state = 37}, - [570] = {.lex_state = 37}, - [571] = {.lex_state = 37}, - [572] = {.lex_state = 37}, - [573] = {.lex_state = 37}, - [574] = {.lex_state = 37}, - [575] = {.lex_state = 37}, - [576] = {.lex_state = 37}, - [577] = {.lex_state = 37}, - [578] = {.lex_state = 37}, - [579] = {.lex_state = 37}, - [580] = {.lex_state = 37}, - [581] = {.lex_state = 37}, - [582] = {.lex_state = 37}, - [583] = {.lex_state = 37}, - [584] = {.lex_state = 37}, - [585] = {.lex_state = 37}, - [586] = {.lex_state = 37}, - [587] = {.lex_state = 37}, - [588] = {.lex_state = 37}, - [589] = {.lex_state = 37}, - [590] = {.lex_state = 37}, - [591] = {.lex_state = 37}, - [592] = {.lex_state = 37}, - [593] = {.lex_state = 37}, - [594] = {.lex_state = 37}, - [595] = {.lex_state = 37}, - [596] = {.lex_state = 33}, - [597] = {.lex_state = 37}, - [598] = {.lex_state = 37}, - [599] = {.lex_state = 37}, - [600] = {.lex_state = 33}, - [601] = {.lex_state = 37}, - [602] = {.lex_state = 37}, - [603] = {.lex_state = 37}, - [604] = {.lex_state = 37}, - [605] = {.lex_state = 37}, - [606] = {.lex_state = 37}, - [607] = {.lex_state = 37}, - [608] = {.lex_state = 37}, - [609] = {.lex_state = 37}, - [610] = {.lex_state = 37}, - [611] = {.lex_state = 37}, - [612] = {.lex_state = 37}, - [613] = {.lex_state = 37}, - [614] = {.lex_state = 37}, - [615] = {.lex_state = 37}, - [616] = {.lex_state = 37}, - [617] = {.lex_state = 37}, - [618] = {.lex_state = 37}, - [619] = {.lex_state = 37}, - [620] = {.lex_state = 33}, - [621] = {.lex_state = 33}, - [622] = {.lex_state = 33}, - [623] = {.lex_state = 33}, - [624] = {.lex_state = 33}, - [625] = {.lex_state = 33}, - [626] = {.lex_state = 33}, - [627] = {.lex_state = 33}, - [628] = {.lex_state = 33}, - [629] = {.lex_state = 33}, - [630] = {.lex_state = 33}, - [631] = {.lex_state = 33}, - [632] = {.lex_state = 33}, - [633] = {.lex_state = 33}, - [634] = {.lex_state = 33}, - [635] = {.lex_state = 33}, - [636] = {.lex_state = 33}, - [637] = {.lex_state = 33}, - [638] = {.lex_state = 33}, - [639] = {.lex_state = 33}, - [640] = {.lex_state = 33}, - [641] = {.lex_state = 33}, - [642] = {.lex_state = 33}, - [643] = {.lex_state = 33}, - [644] = {.lex_state = 33}, - [645] = {.lex_state = 33}, - [646] = {.lex_state = 33}, - [647] = {.lex_state = 33}, - [648] = {.lex_state = 33}, - [649] = {.lex_state = 33}, - [650] = {.lex_state = 33}, - [651] = {.lex_state = 33}, - [652] = {.lex_state = 33}, - [653] = {.lex_state = 33}, - [654] = {.lex_state = 33}, - [655] = {.lex_state = 33}, - [656] = {.lex_state = 33}, - [657] = {.lex_state = 33}, - [658] = {.lex_state = 33}, - [659] = {.lex_state = 33}, - [660] = {.lex_state = 33}, - [661] = {.lex_state = 33}, - [662] = {.lex_state = 33}, - [663] = {.lex_state = 33}, - [664] = {.lex_state = 33}, - [665] = {.lex_state = 33}, - [666] = {.lex_state = 33}, - [667] = {.lex_state = 33}, - [668] = {.lex_state = 33}, - [669] = {.lex_state = 33}, - [670] = {.lex_state = 33}, - [671] = {.lex_state = 35}, - [672] = {.lex_state = 35}, - [673] = {.lex_state = 35}, - [674] = {.lex_state = 35}, - [675] = {.lex_state = 35}, - [676] = {.lex_state = 35}, - [677] = {.lex_state = 35}, - [678] = {.lex_state = 35}, - [679] = {.lex_state = 35}, - [680] = {.lex_state = 35}, - [681] = {.lex_state = 35}, - [682] = {.lex_state = 35}, - [683] = {.lex_state = 35}, - [684] = {.lex_state = 35}, - [685] = {.lex_state = 35}, - [686] = {.lex_state = 35}, - [687] = {.lex_state = 35}, - [688] = {.lex_state = 35}, - [689] = {.lex_state = 35}, - [690] = {.lex_state = 35}, - [691] = {.lex_state = 35}, - [692] = {.lex_state = 35}, - [693] = {.lex_state = 35}, - [694] = {.lex_state = 35}, - [695] = {.lex_state = 35}, - [696] = {.lex_state = 35}, - [697] = {.lex_state = 35}, - [698] = {.lex_state = 35}, - [699] = {.lex_state = 35}, - [700] = {.lex_state = 35}, - [701] = {.lex_state = 35}, - [702] = {.lex_state = 35}, - [703] = {.lex_state = 35}, - [704] = {.lex_state = 35}, - [705] = {.lex_state = 35}, - [706] = {.lex_state = 35}, - [707] = {.lex_state = 35}, - [708] = {.lex_state = 35}, - [709] = {.lex_state = 35}, - [710] = {.lex_state = 35}, - [711] = {.lex_state = 35}, - [712] = {.lex_state = 35}, - [713] = {.lex_state = 35}, - [714] = {.lex_state = 35}, - [715] = {.lex_state = 35}, - [716] = {.lex_state = 35}, - [717] = {.lex_state = 35}, - [718] = {.lex_state = 35}, - [719] = {.lex_state = 35}, - [720] = {.lex_state = 35}, - [721] = {.lex_state = 35}, - [722] = {.lex_state = 35}, - [723] = {.lex_state = 35}, - [724] = {.lex_state = 33}, - [725] = {.lex_state = 33}, - [726] = {.lex_state = 33}, - [727] = {.lex_state = 33}, - [728] = {.lex_state = 33}, - [729] = {.lex_state = 33}, - [730] = {.lex_state = 33}, - [731] = {.lex_state = 33}, - [732] = {.lex_state = 33}, - [733] = {.lex_state = 33}, - [734] = {.lex_state = 33}, - [735] = {.lex_state = 33}, - [736] = {.lex_state = 33}, - [737] = {.lex_state = 33}, - [738] = {.lex_state = 33}, - [739] = {.lex_state = 33}, - [740] = {.lex_state = 33}, - [741] = {.lex_state = 33}, - [742] = {.lex_state = 33}, - [743] = {.lex_state = 33}, - [744] = {.lex_state = 33}, - [745] = {.lex_state = 33}, - [746] = {.lex_state = 33}, - [747] = {.lex_state = 33}, - [748] = {.lex_state = 33}, - [749] = {.lex_state = 33}, - [750] = {.lex_state = 33}, - [751] = {.lex_state = 33}, - [752] = {.lex_state = 33}, - [753] = {.lex_state = 33}, - [754] = {.lex_state = 33}, - [755] = {.lex_state = 33}, - [756] = {.lex_state = 33}, - [757] = {.lex_state = 33}, - [758] = {.lex_state = 33}, - [759] = {.lex_state = 33}, - [760] = {.lex_state = 33}, - [761] = {.lex_state = 33}, - [762] = {.lex_state = 33}, - [763] = {.lex_state = 33}, - [764] = {.lex_state = 33}, - [765] = {.lex_state = 33}, - [766] = {.lex_state = 33}, - [767] = {.lex_state = 33}, - [768] = {.lex_state = 33}, - [769] = {.lex_state = 33}, - [770] = {.lex_state = 33}, - [771] = {.lex_state = 33}, - [772] = {.lex_state = 33}, - [773] = {.lex_state = 33}, - [774] = {.lex_state = 33}, - [775] = {.lex_state = 33}, - [776] = {.lex_state = 6}, - [777] = {.lex_state = 6}, - [778] = {.lex_state = 33}, - [779] = {.lex_state = 6}, - [780] = {.lex_state = 33}, - [781] = {.lex_state = 33}, - [782] = {.lex_state = 33}, - [783] = {.lex_state = 6}, - [784] = {.lex_state = 6}, - [785] = {.lex_state = 6}, - [786] = {.lex_state = 6}, - [787] = {.lex_state = 6}, - [788] = {.lex_state = 6}, - [789] = {.lex_state = 6}, - [790] = {.lex_state = 6}, - [791] = {.lex_state = 6}, - [792] = {.lex_state = 6}, - [793] = {.lex_state = 6}, - [794] = {.lex_state = 6}, - [795] = {.lex_state = 6}, - [796] = {.lex_state = 6}, - [797] = {.lex_state = 6}, - [798] = {.lex_state = 6}, - [799] = {.lex_state = 6}, - [800] = {.lex_state = 6}, - [801] = {.lex_state = 0}, - [802] = {.lex_state = 0}, - [803] = {.lex_state = 0}, - [804] = {.lex_state = 0}, - [805] = {.lex_state = 0}, - [806] = {.lex_state = 0}, - [807] = {.lex_state = 0}, - [808] = {.lex_state = 0}, - [809] = {.lex_state = 0}, - [810] = {.lex_state = 6}, - [811] = {.lex_state = 6}, - [812] = {.lex_state = 6}, - [813] = {.lex_state = 6}, - [814] = {.lex_state = 6}, - [815] = {.lex_state = 33}, - [816] = {.lex_state = 33}, - [817] = {.lex_state = 33}, - [818] = {.lex_state = 33}, - [819] = {.lex_state = 33}, - [820] = {.lex_state = 33}, - [821] = {.lex_state = 33}, - [822] = {.lex_state = 33}, - [823] = {.lex_state = 33}, - [824] = {.lex_state = 0}, - [825] = {.lex_state = 0}, - [826] = {.lex_state = 33}, - [827] = {.lex_state = 33}, - [828] = {.lex_state = 33}, - [829] = {.lex_state = 33}, - [830] = {.lex_state = 33}, - [831] = {.lex_state = 33}, - [832] = {.lex_state = 33}, - [833] = {.lex_state = 33}, - [834] = {.lex_state = 33}, - [835] = {.lex_state = 33}, - [836] = {.lex_state = 33}, - [837] = {.lex_state = 33}, - [838] = {.lex_state = 33}, - [839] = {.lex_state = 33}, - [840] = {.lex_state = 33}, - [841] = {.lex_state = 33}, - [842] = {.lex_state = 33}, - [843] = {.lex_state = 33}, - [844] = {.lex_state = 33}, - [845] = {.lex_state = 33}, - [846] = {.lex_state = 33}, - [847] = {.lex_state = 33}, - [848] = {.lex_state = 33}, - [849] = {.lex_state = 33}, - [850] = {.lex_state = 33}, - [851] = {.lex_state = 33}, - [852] = {.lex_state = 33}, - [853] = {.lex_state = 33}, - [854] = {.lex_state = 33}, - [855] = {.lex_state = 33}, - [856] = {.lex_state = 33}, - [857] = {.lex_state = 33}, - [858] = {.lex_state = 33}, - [859] = {.lex_state = 33}, - [860] = {.lex_state = 33}, - [861] = {.lex_state = 33}, - [862] = {.lex_state = 33}, - [863] = {.lex_state = 33}, - [864] = {.lex_state = 33}, - [865] = {.lex_state = 33}, - [866] = {.lex_state = 33}, - [867] = {.lex_state = 33}, - [868] = {.lex_state = 33}, - [869] = {.lex_state = 33}, - [870] = {.lex_state = 33}, - [871] = {.lex_state = 33}, - [872] = {.lex_state = 33}, - [873] = {.lex_state = 33}, - [874] = {.lex_state = 33}, - [875] = {.lex_state = 33}, - [876] = {.lex_state = 33}, - [877] = {.lex_state = 33}, - [878] = {.lex_state = 33}, - [879] = {.lex_state = 33}, - [880] = {.lex_state = 33}, - [881] = {.lex_state = 33}, - [882] = {.lex_state = 33}, - [883] = {.lex_state = 33}, - [884] = {.lex_state = 33}, - [885] = {.lex_state = 33}, - [886] = {.lex_state = 33}, - [887] = {.lex_state = 33}, - [888] = {.lex_state = 33}, - [889] = {.lex_state = 33}, - [890] = {.lex_state = 33}, - [891] = {.lex_state = 33}, - [892] = {.lex_state = 33}, - [893] = {.lex_state = 33}, - [894] = {.lex_state = 33}, - [895] = {.lex_state = 7}, - [896] = {.lex_state = 7}, - [897] = {.lex_state = 7}, - [898] = {.lex_state = 7}, - [899] = {.lex_state = 7}, - [900] = {.lex_state = 7}, - [901] = {.lex_state = 7}, - [902] = {.lex_state = 7}, - [903] = {.lex_state = 7}, - [904] = {.lex_state = 7}, - [905] = {.lex_state = 7}, - [906] = {.lex_state = 7}, - [907] = {.lex_state = 7}, - [908] = {.lex_state = 7}, - [909] = {.lex_state = 7}, - [910] = {.lex_state = 7}, - [911] = {.lex_state = 0}, - [912] = {.lex_state = 7}, - [913] = {.lex_state = 7}, - [914] = {.lex_state = 7}, - [915] = {.lex_state = 7}, - [916] = {.lex_state = 7}, - [917] = {.lex_state = 7}, - [918] = {.lex_state = 7}, - [919] = {.lex_state = 7}, - [920] = {.lex_state = 7}, - [921] = {.lex_state = 33}, - [922] = {.lex_state = 7}, - [923] = {.lex_state = 7}, - [924] = {.lex_state = 7}, - [925] = {.lex_state = 7}, - [926] = {.lex_state = 33}, - [927] = {.lex_state = 7}, - [928] = {.lex_state = 7}, - [929] = {.lex_state = 7}, - [930] = {.lex_state = 33}, - [931] = {.lex_state = 7}, - [932] = {.lex_state = 33}, - [933] = {.lex_state = 33}, - [934] = {.lex_state = 33}, - [935] = {.lex_state = 33}, - [936] = {.lex_state = 7}, - [937] = {.lex_state = 7}, - [938] = {.lex_state = 7}, - [939] = {.lex_state = 7}, - [940] = {.lex_state = 7}, - [941] = {.lex_state = 33}, - [942] = {.lex_state = 7}, - [943] = {.lex_state = 7}, - [944] = {.lex_state = 7}, - [945] = {.lex_state = 7}, - [946] = {.lex_state = 33}, - [947] = {.lex_state = 7}, - [948] = {.lex_state = 7}, - [949] = {.lex_state = 7}, - [950] = {.lex_state = 33}, - [951] = {.lex_state = 33}, - [952] = {.lex_state = 33}, - [953] = {.lex_state = 33}, - [954] = {.lex_state = 7}, - [955] = {.lex_state = 33}, - [956] = {.lex_state = 7}, - [957] = {.lex_state = 33}, - [958] = {.lex_state = 33}, - [959] = {.lex_state = 33}, - [960] = {.lex_state = 7}, - [961] = {.lex_state = 33}, - [962] = {.lex_state = 33}, - [963] = {.lex_state = 33}, - [964] = {.lex_state = 33}, - [965] = {.lex_state = 33}, - [966] = {.lex_state = 7}, - [967] = {.lex_state = 33}, - [968] = {.lex_state = 6}, - [969] = {.lex_state = 33}, - [970] = {.lex_state = 33}, - [971] = {.lex_state = 33}, - [972] = {.lex_state = 33}, - [973] = {.lex_state = 33}, - [974] = {.lex_state = 6}, - [975] = {.lex_state = 33}, - [976] = {.lex_state = 33}, + [263] = {.lex_state = 6}, + [264] = {.lex_state = 6}, + [265] = {.lex_state = 6}, + [266] = {.lex_state = 6}, + [267] = {.lex_state = 6}, + [268] = {.lex_state = 6}, + [269] = {.lex_state = 6}, + [270] = {.lex_state = 6}, + [271] = {.lex_state = 6}, + [272] = {.lex_state = 6}, + [273] = {.lex_state = 6}, + [274] = {.lex_state = 6}, + [275] = {.lex_state = 6}, + [276] = {.lex_state = 6}, + [277] = {.lex_state = 6}, + [278] = {.lex_state = 6}, + [279] = {.lex_state = 6}, + [280] = {.lex_state = 6}, + [281] = {.lex_state = 6}, + [282] = {.lex_state = 6}, + [283] = {.lex_state = 6}, + [284] = {.lex_state = 6}, + [285] = {.lex_state = 6}, + [286] = {.lex_state = 6}, + [287] = {.lex_state = 6}, + [288] = {.lex_state = 6}, + [289] = {.lex_state = 6}, + [290] = {.lex_state = 6}, + [291] = {.lex_state = 6}, + [292] = {.lex_state = 6}, + [293] = {.lex_state = 6}, + [294] = {.lex_state = 6}, + [295] = {.lex_state = 6}, + [296] = {.lex_state = 6}, + [297] = {.lex_state = 6}, + [298] = {.lex_state = 6}, + [299] = {.lex_state = 6}, + [300] = {.lex_state = 6}, + [301] = {.lex_state = 6}, + [302] = {.lex_state = 6}, + [303] = {.lex_state = 6}, + [304] = {.lex_state = 6}, + [305] = {.lex_state = 6}, + [306] = {.lex_state = 6}, + [307] = {.lex_state = 6}, + [308] = {.lex_state = 6}, + [309] = {.lex_state = 6}, + [310] = {.lex_state = 6}, + [311] = {.lex_state = 6}, + [312] = {.lex_state = 6}, + [313] = {.lex_state = 6}, + [314] = {.lex_state = 6}, + [315] = {.lex_state = 6}, + [316] = {.lex_state = 6}, + [317] = {.lex_state = 6}, + [318] = {.lex_state = 6}, + [319] = {.lex_state = 6}, + [320] = {.lex_state = 6}, + [321] = {.lex_state = 6}, + [322] = {.lex_state = 6}, + [323] = {.lex_state = 6}, + [324] = {.lex_state = 6}, + [325] = {.lex_state = 6}, + [326] = {.lex_state = 6}, + [327] = {.lex_state = 6}, + [328] = {.lex_state = 6}, + [329] = {.lex_state = 6}, + [330] = {.lex_state = 6}, + [331] = {.lex_state = 6}, + [332] = {.lex_state = 39}, + [333] = {.lex_state = 6}, + [334] = {.lex_state = 6}, + [335] = {.lex_state = 6}, + [336] = {.lex_state = 6}, + [337] = {.lex_state = 6}, + [338] = {.lex_state = 6}, + [339] = {.lex_state = 39}, + [340] = {.lex_state = 6}, + [341] = {.lex_state = 6}, + [342] = {.lex_state = 6}, + [343] = {.lex_state = 6}, + [344] = {.lex_state = 6}, + [345] = {.lex_state = 6}, + [346] = {.lex_state = 6}, + [347] = {.lex_state = 6}, + [348] = {.lex_state = 6}, + [349] = {.lex_state = 6}, + [350] = {.lex_state = 6}, + [351] = {.lex_state = 6}, + [352] = {.lex_state = 6}, + [353] = {.lex_state = 6}, + [354] = {.lex_state = 6}, + [355] = {.lex_state = 6}, + [356] = {.lex_state = 6}, + [357] = {.lex_state = 6}, + [358] = {.lex_state = 6}, + [359] = {.lex_state = 6}, + [360] = {.lex_state = 6}, + [361] = {.lex_state = 6}, + [362] = {.lex_state = 6}, + [363] = {.lex_state = 6}, + [364] = {.lex_state = 6}, + [365] = {.lex_state = 6}, + [366] = {.lex_state = 39}, + [367] = {.lex_state = 39}, + [368] = {.lex_state = 39}, + [369] = {.lex_state = 39}, + [370] = {.lex_state = 39}, + [371] = {.lex_state = 39}, + [372] = {.lex_state = 39}, + [373] = {.lex_state = 39}, + [374] = {.lex_state = 39}, + [375] = {.lex_state = 39}, + [376] = {.lex_state = 39}, + [377] = {.lex_state = 39}, + [378] = {.lex_state = 39}, + [379] = {.lex_state = 39}, + [380] = {.lex_state = 39}, + [381] = {.lex_state = 39}, + [382] = {.lex_state = 39}, + [383] = {.lex_state = 39}, + [384] = {.lex_state = 39}, + [385] = {.lex_state = 39}, + [386] = {.lex_state = 39}, + [387] = {.lex_state = 39}, + [388] = {.lex_state = 39}, + [389] = {.lex_state = 39}, + [390] = {.lex_state = 39}, + [391] = {.lex_state = 39}, + [392] = {.lex_state = 39}, + [393] = {.lex_state = 39}, + [394] = {.lex_state = 39}, + [395] = {.lex_state = 39}, + [396] = {.lex_state = 39}, + [397] = {.lex_state = 39}, + [398] = {.lex_state = 39}, + [399] = {.lex_state = 39}, + [400] = {.lex_state = 39}, + [401] = {.lex_state = 39}, + [402] = {.lex_state = 39}, + [403] = {.lex_state = 39}, + [404] = {.lex_state = 39}, + [405] = {.lex_state = 39}, + [406] = {.lex_state = 39}, + [407] = {.lex_state = 39}, + [408] = {.lex_state = 39}, + [409] = {.lex_state = 39}, + [410] = {.lex_state = 39}, + [411] = {.lex_state = 39}, + [412] = {.lex_state = 39}, + [413] = {.lex_state = 39}, + [414] = {.lex_state = 39}, + [415] = {.lex_state = 39}, + [416] = {.lex_state = 39}, + [417] = {.lex_state = 39}, + [418] = {.lex_state = 39}, + [419] = {.lex_state = 39}, + [420] = {.lex_state = 39}, + [421] = {.lex_state = 39}, + [422] = {.lex_state = 39}, + [423] = {.lex_state = 39}, + [424] = {.lex_state = 39}, + [425] = {.lex_state = 39}, + [426] = {.lex_state = 39}, + [427] = {.lex_state = 39}, + [428] = {.lex_state = 39}, + [429] = {.lex_state = 39}, + [430] = {.lex_state = 39}, + [431] = {.lex_state = 39}, + [432] = {.lex_state = 39}, + [433] = {.lex_state = 39}, + [434] = {.lex_state = 39}, + [435] = {.lex_state = 39}, + [436] = {.lex_state = 39}, + [437] = {.lex_state = 39}, + [438] = {.lex_state = 39}, + [439] = {.lex_state = 39}, + [440] = {.lex_state = 39}, + [441] = {.lex_state = 39}, + [442] = {.lex_state = 39}, + [443] = {.lex_state = 39}, + [444] = {.lex_state = 39}, + [445] = {.lex_state = 39}, + [446] = {.lex_state = 39}, + [447] = {.lex_state = 39}, + [448] = {.lex_state = 39}, + [449] = {.lex_state = 39}, + [450] = {.lex_state = 39}, + [451] = {.lex_state = 39}, + [452] = {.lex_state = 39}, + [453] = {.lex_state = 39}, + [454] = {.lex_state = 39}, + [455] = {.lex_state = 39}, + [456] = {.lex_state = 39}, + [457] = {.lex_state = 39}, + [458] = {.lex_state = 39}, + [459] = {.lex_state = 39}, + [460] = {.lex_state = 39}, + [461] = {.lex_state = 39}, + [462] = {.lex_state = 39}, + [463] = {.lex_state = 39}, + [464] = {.lex_state = 39}, + [465] = {.lex_state = 39}, + [466] = {.lex_state = 39}, + [467] = {.lex_state = 39}, + [468] = {.lex_state = 41}, + [469] = {.lex_state = 41}, + [470] = {.lex_state = 41}, + [471] = {.lex_state = 41}, + [472] = {.lex_state = 41}, + [473] = {.lex_state = 41}, + [474] = {.lex_state = 41}, + [475] = {.lex_state = 41}, + [476] = {.lex_state = 41}, + [477] = {.lex_state = 41}, + [478] = {.lex_state = 41}, + [479] = {.lex_state = 41}, + [480] = {.lex_state = 41}, + [481] = {.lex_state = 41}, + [482] = {.lex_state = 41}, + [483] = {.lex_state = 41}, + [484] = {.lex_state = 41}, + [485] = {.lex_state = 41}, + [486] = {.lex_state = 41}, + [487] = {.lex_state = 41}, + [488] = {.lex_state = 41}, + [489] = {.lex_state = 41}, + [490] = {.lex_state = 41}, + [491] = {.lex_state = 41}, + [492] = {.lex_state = 41}, + [493] = {.lex_state = 41}, + [494] = {.lex_state = 41}, + [495] = {.lex_state = 41}, + [496] = {.lex_state = 41}, + [497] = {.lex_state = 41}, + [498] = {.lex_state = 41}, + [499] = {.lex_state = 41}, + [500] = {.lex_state = 41}, + [501] = {.lex_state = 41}, + [502] = {.lex_state = 41}, + [503] = {.lex_state = 41}, + [504] = {.lex_state = 41}, + [505] = {.lex_state = 41}, + [506] = {.lex_state = 41}, + [507] = {.lex_state = 41}, + [508] = {.lex_state = 41}, + [509] = {.lex_state = 41}, + [510] = {.lex_state = 41}, + [511] = {.lex_state = 41}, + [512] = {.lex_state = 41}, + [513] = {.lex_state = 41}, + [514] = {.lex_state = 41}, + [515] = {.lex_state = 41}, + [516] = {.lex_state = 41}, + [517] = {.lex_state = 41}, + [518] = {.lex_state = 41}, + [519] = {.lex_state = 41}, + [520] = {.lex_state = 41}, + [521] = {.lex_state = 41}, + [522] = {.lex_state = 41}, + [523] = {.lex_state = 41}, + [524] = {.lex_state = 41}, + [525] = {.lex_state = 41}, + [526] = {.lex_state = 41}, + [527] = {.lex_state = 41}, + [528] = {.lex_state = 41}, + [529] = {.lex_state = 41}, + [530] = {.lex_state = 41}, + [531] = {.lex_state = 41}, + [532] = {.lex_state = 41}, + [533] = {.lex_state = 41}, + [534] = {.lex_state = 41}, + [535] = {.lex_state = 41}, + [536] = {.lex_state = 41}, + [537] = {.lex_state = 41}, + [538] = {.lex_state = 41}, + [539] = {.lex_state = 41}, + [540] = {.lex_state = 41}, + [541] = {.lex_state = 41}, + [542] = {.lex_state = 41}, + [543] = {.lex_state = 41}, + [544] = {.lex_state = 41}, + [545] = {.lex_state = 41}, + [546] = {.lex_state = 41}, + [547] = {.lex_state = 41}, + [548] = {.lex_state = 41}, + [549] = {.lex_state = 41}, + [550] = {.lex_state = 41}, + [551] = {.lex_state = 41}, + [552] = {.lex_state = 41}, + [553] = {.lex_state = 41}, + [554] = {.lex_state = 41}, + [555] = {.lex_state = 41}, + [556] = {.lex_state = 41}, + [557] = {.lex_state = 41}, + [558] = {.lex_state = 41}, + [559] = {.lex_state = 41}, + [560] = {.lex_state = 41}, + [561] = {.lex_state = 41}, + [562] = {.lex_state = 41}, + [563] = {.lex_state = 41}, + [564] = {.lex_state = 41}, + [565] = {.lex_state = 41}, + [566] = {.lex_state = 41}, + [567] = {.lex_state = 41}, + [568] = {.lex_state = 41}, + [569] = {.lex_state = 41}, + [570] = {.lex_state = 41}, + [571] = {.lex_state = 41}, + [572] = {.lex_state = 41}, + [573] = {.lex_state = 41}, + [574] = {.lex_state = 41}, + [575] = {.lex_state = 41}, + [576] = {.lex_state = 41}, + [577] = {.lex_state = 41}, + [578] = {.lex_state = 41}, + [579] = {.lex_state = 41}, + [580] = {.lex_state = 41}, + [581] = {.lex_state = 41}, + [582] = {.lex_state = 41}, + [583] = {.lex_state = 41}, + [584] = {.lex_state = 41}, + [585] = {.lex_state = 41}, + [586] = {.lex_state = 41}, + [587] = {.lex_state = 41}, + [588] = {.lex_state = 41}, + [589] = {.lex_state = 41}, + [590] = {.lex_state = 41}, + [591] = {.lex_state = 41}, + [592] = {.lex_state = 41}, + [593] = {.lex_state = 41}, + [594] = {.lex_state = 41}, + [595] = {.lex_state = 41}, + [596] = {.lex_state = 41}, + [597] = {.lex_state = 41}, + [598] = {.lex_state = 41}, + [599] = {.lex_state = 41}, + [600] = {.lex_state = 41}, + [601] = {.lex_state = 41}, + [602] = {.lex_state = 41}, + [603] = {.lex_state = 41}, + [604] = {.lex_state = 41}, + [605] = {.lex_state = 41}, + [606] = {.lex_state = 41}, + [607] = {.lex_state = 41}, + [608] = {.lex_state = 41}, + [609] = {.lex_state = 41}, + [610] = {.lex_state = 41}, + [611] = {.lex_state = 41}, + [612] = {.lex_state = 41}, + [613] = {.lex_state = 41}, + [614] = {.lex_state = 41}, + [615] = {.lex_state = 41}, + [616] = {.lex_state = 41}, + [617] = {.lex_state = 41}, + [618] = {.lex_state = 41}, + [619] = {.lex_state = 41}, + [620] = {.lex_state = 41}, + [621] = {.lex_state = 41}, + [622] = {.lex_state = 41}, + [623] = {.lex_state = 41}, + [624] = {.lex_state = 41}, + [625] = {.lex_state = 41}, + [626] = {.lex_state = 41}, + [627] = {.lex_state = 41}, + [628] = {.lex_state = 41}, + [629] = {.lex_state = 41}, + [630] = {.lex_state = 41}, + [631] = {.lex_state = 41}, + [632] = {.lex_state = 41}, + [633] = {.lex_state = 41}, + [634] = {.lex_state = 41}, + [635] = {.lex_state = 41}, + [636] = {.lex_state = 41}, + [637] = {.lex_state = 41}, + [638] = {.lex_state = 41}, + [639] = {.lex_state = 41}, + [640] = {.lex_state = 41}, + [641] = {.lex_state = 41}, + [642] = {.lex_state = 41}, + [643] = {.lex_state = 41}, + [644] = {.lex_state = 41}, + [645] = {.lex_state = 41}, + [646] = {.lex_state = 41}, + [647] = {.lex_state = 41}, + [648] = {.lex_state = 41}, + [649] = {.lex_state = 41}, + [650] = {.lex_state = 41}, + [651] = {.lex_state = 41}, + [652] = {.lex_state = 41}, + [653] = {.lex_state = 41}, + [654] = {.lex_state = 41}, + [655] = {.lex_state = 41}, + [656] = {.lex_state = 41}, + [657] = {.lex_state = 41}, + [658] = {.lex_state = 41}, + [659] = {.lex_state = 41}, + [660] = {.lex_state = 41}, + [661] = {.lex_state = 41}, + [662] = {.lex_state = 41}, + [663] = {.lex_state = 41}, + [664] = {.lex_state = 41}, + [665] = {.lex_state = 41}, + [666] = {.lex_state = 41}, + [667] = {.lex_state = 41}, + [668] = {.lex_state = 41}, + [669] = {.lex_state = 41}, + [670] = {.lex_state = 41}, + [671] = {.lex_state = 41}, + [672] = {.lex_state = 41}, + [673] = {.lex_state = 41}, + [674] = {.lex_state = 41}, + [675] = {.lex_state = 41}, + [676] = {.lex_state = 41}, + [677] = {.lex_state = 41}, + [678] = {.lex_state = 41}, + [679] = {.lex_state = 41}, + [680] = {.lex_state = 41}, + [681] = {.lex_state = 41}, + [682] = {.lex_state = 41}, + [683] = {.lex_state = 41}, + [684] = {.lex_state = 41}, + [685] = {.lex_state = 41}, + [686] = {.lex_state = 41}, + [687] = {.lex_state = 41}, + [688] = {.lex_state = 41}, + [689] = {.lex_state = 41}, + [690] = {.lex_state = 41}, + [691] = {.lex_state = 41}, + [692] = {.lex_state = 41}, + [693] = {.lex_state = 41}, + [694] = {.lex_state = 41}, + [695] = {.lex_state = 41}, + [696] = {.lex_state = 41}, + [697] = {.lex_state = 41}, + [698] = {.lex_state = 41}, + [699] = {.lex_state = 41}, + [700] = {.lex_state = 41}, + [701] = {.lex_state = 41}, + [702] = {.lex_state = 41}, + [703] = {.lex_state = 41}, + [704] = {.lex_state = 41}, + [705] = {.lex_state = 41}, + [706] = {.lex_state = 41}, + [707] = {.lex_state = 41}, + [708] = {.lex_state = 41}, + [709] = {.lex_state = 41}, + [710] = {.lex_state = 41}, + [711] = {.lex_state = 41}, + [712] = {.lex_state = 41}, + [713] = {.lex_state = 41}, + [714] = {.lex_state = 41}, + [715] = {.lex_state = 41}, + [716] = {.lex_state = 37}, + [717] = {.lex_state = 37}, + [718] = {.lex_state = 37}, + [719] = {.lex_state = 37}, + [720] = {.lex_state = 7}, + [721] = {.lex_state = 37}, + [722] = {.lex_state = 37}, + [723] = {.lex_state = 37}, + [724] = {.lex_state = 37}, + [725] = {.lex_state = 37}, + [726] = {.lex_state = 37}, + [727] = {.lex_state = 37}, + [728] = {.lex_state = 37}, + [729] = {.lex_state = 37}, + [730] = {.lex_state = 37}, + [731] = {.lex_state = 37}, + [732] = {.lex_state = 37}, + [733] = {.lex_state = 37}, + [734] = {.lex_state = 37}, + [735] = {.lex_state = 37}, + [736] = {.lex_state = 37}, + [737] = {.lex_state = 37}, + [738] = {.lex_state = 37}, + [739] = {.lex_state = 37}, + [740] = {.lex_state = 37}, + [741] = {.lex_state = 37}, + [742] = {.lex_state = 37}, + [743] = {.lex_state = 37}, + [744] = {.lex_state = 37}, + [745] = {.lex_state = 37}, + [746] = {.lex_state = 37}, + [747] = {.lex_state = 37}, + [748] = {.lex_state = 37}, + [749] = {.lex_state = 37}, + [750] = {.lex_state = 37}, + [751] = {.lex_state = 37}, + [752] = {.lex_state = 37}, + [753] = {.lex_state = 37}, + [754] = {.lex_state = 37}, + [755] = {.lex_state = 37}, + [756] = {.lex_state = 37}, + [757] = {.lex_state = 37}, + [758] = {.lex_state = 37}, + [759] = {.lex_state = 37}, + [760] = {.lex_state = 37}, + [761] = {.lex_state = 37}, + [762] = {.lex_state = 37}, + [763] = {.lex_state = 37}, + [764] = {.lex_state = 37}, + [765] = {.lex_state = 37}, + [766] = {.lex_state = 37}, + [767] = {.lex_state = 37}, + [768] = {.lex_state = 37}, + [769] = {.lex_state = 37}, + [770] = {.lex_state = 37}, + [771] = {.lex_state = 37}, + [772] = {.lex_state = 39}, + [773] = {.lex_state = 39}, + [774] = {.lex_state = 39}, + [775] = {.lex_state = 39}, + [776] = {.lex_state = 39}, + [777] = {.lex_state = 39}, + [778] = {.lex_state = 39}, + [779] = {.lex_state = 39}, + [780] = {.lex_state = 39}, + [781] = {.lex_state = 39}, + [782] = {.lex_state = 39}, + [783] = {.lex_state = 39}, + [784] = {.lex_state = 39}, + [785] = {.lex_state = 39}, + [786] = {.lex_state = 39}, + [787] = {.lex_state = 39}, + [788] = {.lex_state = 39}, + [789] = {.lex_state = 39}, + [790] = {.lex_state = 39}, + [791] = {.lex_state = 39}, + [792] = {.lex_state = 39}, + [793] = {.lex_state = 39}, + [794] = {.lex_state = 39}, + [795] = {.lex_state = 39}, + [796] = {.lex_state = 39}, + [797] = {.lex_state = 39}, + [798] = {.lex_state = 39}, + [799] = {.lex_state = 39}, + [800] = {.lex_state = 39}, + [801] = {.lex_state = 39}, + [802] = {.lex_state = 39}, + [803] = {.lex_state = 39}, + [804] = {.lex_state = 39}, + [805] = {.lex_state = 39}, + [806] = {.lex_state = 39}, + [807] = {.lex_state = 39}, + [808] = {.lex_state = 39}, + [809] = {.lex_state = 39}, + [810] = {.lex_state = 39}, + [811] = {.lex_state = 39}, + [812] = {.lex_state = 39}, + [813] = {.lex_state = 39}, + [814] = {.lex_state = 39}, + [815] = {.lex_state = 39}, + [816] = {.lex_state = 39}, + [817] = {.lex_state = 39}, + [818] = {.lex_state = 39}, + [819] = {.lex_state = 39}, + [820] = {.lex_state = 39}, + [821] = {.lex_state = 39}, + [822] = {.lex_state = 39}, + [823] = {.lex_state = 39}, + [824] = {.lex_state = 39}, + [825] = {.lex_state = 37}, + [826] = {.lex_state = 37}, + [827] = {.lex_state = 0}, + [828] = {.lex_state = 0}, + [829] = {.lex_state = 0}, + [830] = {.lex_state = 0}, + [831] = {.lex_state = 0}, + [832] = {.lex_state = 0}, + [833] = {.lex_state = 0}, + [834] = {.lex_state = 0}, + [835] = {.lex_state = 0}, + [836] = {.lex_state = 37}, + [837] = {.lex_state = 0}, + [838] = {.lex_state = 0}, + [839] = {.lex_state = 0}, + [840] = {.lex_state = 0}, + [841] = {.lex_state = 0}, + [842] = {.lex_state = 0}, + [843] = {.lex_state = 0}, + [844] = {.lex_state = 0}, + [845] = {.lex_state = 0}, + [846] = {.lex_state = 0}, + [847] = {.lex_state = 0}, + [848] = {.lex_state = 0}, + [849] = {.lex_state = 0}, + [850] = {.lex_state = 0}, + [851] = {.lex_state = 0}, + [852] = {.lex_state = 0}, + [853] = {.lex_state = 0}, + [854] = {.lex_state = 0}, + [855] = {.lex_state = 0}, + [856] = {.lex_state = 0}, + [857] = {.lex_state = 37}, + [858] = {.lex_state = 0}, + [859] = {.lex_state = 0}, + [860] = {.lex_state = 0}, + [861] = {.lex_state = 0}, + [862] = {.lex_state = 37}, + [863] = {.lex_state = 37}, + [864] = {.lex_state = 37}, + [865] = {.lex_state = 37}, + [866] = {.lex_state = 37}, + [867] = {.lex_state = 37}, + [868] = {.lex_state = 37}, + [869] = {.lex_state = 0}, + [870] = {.lex_state = 37}, + [871] = {.lex_state = 37}, + [872] = {.lex_state = 37}, + [873] = {.lex_state = 37}, + [874] = {.lex_state = 0}, + [875] = {.lex_state = 37}, + [876] = {.lex_state = 6}, + [877] = {.lex_state = 37}, + [878] = {.lex_state = 37}, + [879] = {.lex_state = 37}, + [880] = {.lex_state = 37}, + [881] = {.lex_state = 37}, + [882] = {.lex_state = 37}, + [883] = {.lex_state = 37}, + [884] = {.lex_state = 37}, + [885] = {.lex_state = 6}, + [886] = {.lex_state = 37}, + [887] = {.lex_state = 37}, + [888] = {.lex_state = 37}, + [889] = {.lex_state = 37}, + [890] = {.lex_state = 37}, + [891] = {.lex_state = 37}, + [892] = {.lex_state = 37}, + [893] = {.lex_state = 37}, + [894] = {.lex_state = 37}, + [895] = {.lex_state = 37}, + [896] = {.lex_state = 37}, + [897] = {.lex_state = 37}, + [898] = {.lex_state = 6}, + [899] = {.lex_state = 37}, + [900] = {.lex_state = 37}, + [901] = {.lex_state = 37}, + [902] = {.lex_state = 37}, + [903] = {.lex_state = 37}, + [904] = {.lex_state = 37}, + [905] = {.lex_state = 37}, + [906] = {.lex_state = 37}, + [907] = {.lex_state = 37}, + [908] = {.lex_state = 37}, + [909] = {.lex_state = 37}, + [910] = {.lex_state = 37}, + [911] = {.lex_state = 37}, + [912] = {.lex_state = 37}, + [913] = {.lex_state = 37}, + [914] = {.lex_state = 37}, + [915] = {.lex_state = 6}, + [916] = {.lex_state = 6}, + [917] = {.lex_state = 37}, + [918] = {.lex_state = 6}, + [919] = {.lex_state = 6}, + [920] = {.lex_state = 6}, + [921] = {.lex_state = 41}, + [922] = {.lex_state = 37}, + [923] = {.lex_state = 37}, + [924] = {.lex_state = 37}, + [925] = {.lex_state = 41}, + [926] = {.lex_state = 37}, + [927] = {.lex_state = 6}, + [928] = {.lex_state = 6}, + [929] = {.lex_state = 6}, + [930] = {.lex_state = 37}, + [931] = {.lex_state = 6}, + [932] = {.lex_state = 6}, + [933] = {.lex_state = 6}, + [934] = {.lex_state = 0}, + [935] = {.lex_state = 0}, + [936] = {.lex_state = 0}, + [937] = {.lex_state = 0}, + [938] = {.lex_state = 0}, + [939] = {.lex_state = 6}, + [940] = {.lex_state = 0}, + [941] = {.lex_state = 0}, + [942] = {.lex_state = 6}, + [943] = {.lex_state = 0}, + [944] = {.lex_state = 6}, + [945] = {.lex_state = 0}, + [946] = {.lex_state = 41}, + [947] = {.lex_state = 41}, + [948] = {.lex_state = 6}, + [949] = {.lex_state = 6}, + [950] = {.lex_state = 6}, + [951] = {.lex_state = 6}, + [952] = {.lex_state = 6}, + [953] = {.lex_state = 6}, + [954] = {.lex_state = 6}, + [955] = {.lex_state = 37}, + [956] = {.lex_state = 37}, + [957] = {.lex_state = 37}, + [958] = {.lex_state = 37}, + [959] = {.lex_state = 37}, + [960] = {.lex_state = 37}, + [961] = {.lex_state = 37}, + [962] = {.lex_state = 37}, + [963] = {.lex_state = 37}, + [964] = {.lex_state = 37}, + [965] = {.lex_state = 37}, + [966] = {.lex_state = 37}, + [967] = {.lex_state = 6}, + [968] = {.lex_state = 0}, + [969] = {.lex_state = 0}, + [970] = {.lex_state = 0}, + [971] = {.lex_state = 0}, + [972] = {.lex_state = 0}, + [973] = {.lex_state = 0}, + [974] = {.lex_state = 0}, + [975] = {.lex_state = 0}, + [976] = {.lex_state = 0}, [977] = {.lex_state = 6}, - [978] = {.lex_state = 7}, - [979] = {.lex_state = 33}, - [980] = {.lex_state = 33}, - [981] = {.lex_state = 33}, - [982] = {.lex_state = 33}, - [983] = {.lex_state = 33}, - [984] = {.lex_state = 33}, - [985] = {.lex_state = 33}, - [986] = {.lex_state = 33}, - [987] = {.lex_state = 33}, - [988] = {.lex_state = 33}, - [989] = {.lex_state = 33}, - [990] = {.lex_state = 33}, - [991] = {.lex_state = 33}, - [992] = {.lex_state = 33}, - [993] = {.lex_state = 33}, - [994] = {.lex_state = 33}, - [995] = {.lex_state = 33}, - [996] = {.lex_state = 33}, - [997] = {.lex_state = 33}, - [998] = {.lex_state = 6}, - [999] = {.lex_state = 33}, - [1000] = {.lex_state = 33}, - [1001] = {.lex_state = 33}, - [1002] = {.lex_state = 33}, - [1003] = {.lex_state = 33}, - [1004] = {.lex_state = 7}, - [1005] = {.lex_state = 33}, - [1006] = {.lex_state = 33}, - [1007] = {.lex_state = 33}, - [1008] = {.lex_state = 33}, - [1009] = {.lex_state = 6}, - [1010] = {.lex_state = 33}, - [1011] = {.lex_state = 33}, - [1012] = {.lex_state = 6}, - [1013] = {.lex_state = 33}, - [1014] = {.lex_state = 6}, - [1015] = {.lex_state = 33}, - [1016] = {.lex_state = 6}, - [1017] = {.lex_state = 33}, - [1018] = {.lex_state = 33}, - [1019] = {.lex_state = 33}, - [1020] = {.lex_state = 33}, - [1021] = {.lex_state = 33}, - [1022] = {.lex_state = 6}, - [1023] = {.lex_state = 33}, - [1024] = {.lex_state = 33}, - [1025] = {.lex_state = 6}, - [1026] = {.lex_state = 33}, - [1027] = {.lex_state = 33}, - [1028] = {.lex_state = 33}, - [1029] = {.lex_state = 33}, - [1030] = {.lex_state = 33}, - [1031] = {.lex_state = 33}, - [1032] = {.lex_state = 33}, - [1033] = {.lex_state = 6}, - [1034] = {.lex_state = 33}, - [1035] = {.lex_state = 33}, - [1036] = {.lex_state = 33}, - [1037] = {.lex_state = 33}, - [1038] = {.lex_state = 33}, - [1039] = {.lex_state = 7}, - [1040] = {.lex_state = 7}, - [1041] = {.lex_state = 33}, - [1042] = {.lex_state = 7}, - [1043] = {.lex_state = 7}, - [1044] = {.lex_state = 7}, - [1045] = {.lex_state = 33}, - [1046] = {.lex_state = 7}, - [1047] = {.lex_state = 7}, - [1048] = {.lex_state = 7}, - [1049] = {.lex_state = 7}, - [1050] = {.lex_state = 7}, - [1051] = {.lex_state = 33}, - [1052] = {.lex_state = 33}, - [1053] = {.lex_state = 7}, - [1054] = {.lex_state = 7}, - [1055] = {.lex_state = 7}, - [1056] = {.lex_state = 7}, - [1057] = {.lex_state = 7}, - [1058] = {.lex_state = 33}, - [1059] = {.lex_state = 7}, - [1060] = {.lex_state = 33}, - [1061] = {.lex_state = 7}, - [1062] = {.lex_state = 7}, - [1063] = {.lex_state = 33}, - [1064] = {.lex_state = 33}, - [1065] = {.lex_state = 33}, - [1066] = {.lex_state = 7}, - [1067] = {.lex_state = 33}, - [1068] = {.lex_state = 33}, - [1069] = {.lex_state = 33}, - [1070] = {.lex_state = 33}, - [1071] = {.lex_state = 33}, - [1072] = {.lex_state = 33}, - [1073] = {.lex_state = 33}, - [1074] = {.lex_state = 33}, - [1075] = {.lex_state = 33}, - [1076] = {.lex_state = 7}, - [1077] = {.lex_state = 33}, - [1078] = {.lex_state = 7}, - [1079] = {.lex_state = 33}, - [1080] = {.lex_state = 33}, - [1081] = {.lex_state = 7}, - [1082] = {.lex_state = 33}, - [1083] = {.lex_state = 7}, - [1084] = {.lex_state = 33}, - [1085] = {.lex_state = 7}, - [1086] = {.lex_state = 33}, - [1087] = {.lex_state = 7}, - [1088] = {.lex_state = 7}, - [1089] = {.lex_state = 33}, - [1090] = {.lex_state = 7}, - [1091] = {.lex_state = 6}, - [1092] = {.lex_state = 33}, - [1093] = {.lex_state = 33}, - [1094] = {.lex_state = 7}, - [1095] = {.lex_state = 33}, - [1096] = {.lex_state = 33}, - [1097] = {.lex_state = 33}, - [1098] = {.lex_state = 6}, - [1099] = {.lex_state = 6}, - [1100] = {.lex_state = 33}, - [1101] = {.lex_state = 6}, - [1102] = {.lex_state = 33}, - [1103] = {.lex_state = 33}, - [1104] = {.lex_state = 33}, - [1105] = {.lex_state = 7}, - [1106] = {.lex_state = 33}, - [1107] = {.lex_state = 7}, - [1108] = {.lex_state = 33}, - [1109] = {.lex_state = 33}, - [1110] = {.lex_state = 33}, - [1111] = {.lex_state = 7}, - [1112] = {.lex_state = 33}, - [1113] = {.lex_state = 7}, - [1114] = {.lex_state = 7}, - [1115] = {.lex_state = 6}, - [1116] = {.lex_state = 6}, - [1117] = {.lex_state = 33}, - [1118] = {.lex_state = 7}, - [1119] = {.lex_state = 33}, - [1120] = {.lex_state = 7}, - [1121] = {.lex_state = 7}, - [1122] = {.lex_state = 7}, - [1123] = {.lex_state = 33}, - [1124] = {.lex_state = 33}, - [1125] = {.lex_state = 33}, - [1126] = {.lex_state = 33}, - [1127] = {.lex_state = 7}, - [1128] = {.lex_state = 33}, - [1129] = {.lex_state = 7}, - [1130] = {.lex_state = 33}, - [1131] = {.lex_state = 7}, - [1132] = {.lex_state = 7}, - [1133] = {.lex_state = 7}, - [1134] = {.lex_state = 33}, - [1135] = {.lex_state = 33}, - [1136] = {.lex_state = 33}, - [1137] = {.lex_state = 7}, - [1138] = {.lex_state = 33}, - [1139] = {.lex_state = 7}, - [1140] = {.lex_state = 7}, - [1141] = {.lex_state = 33}, - [1142] = {.lex_state = 33}, - [1143] = {.lex_state = 33}, - [1144] = {.lex_state = 7}, - [1145] = {.lex_state = 7}, - [1146] = {.lex_state = 7}, - [1147] = {.lex_state = 33}, - [1148] = {.lex_state = 6}, - [1149] = {.lex_state = 6}, - [1150] = {.lex_state = 7}, - [1151] = {.lex_state = 33}, - [1152] = {.lex_state = 33}, - [1153] = {.lex_state = 33}, - [1154] = {.lex_state = 7}, - [1155] = {.lex_state = 33}, - [1156] = {.lex_state = 33}, - [1157] = {.lex_state = 7}, - [1158] = {.lex_state = 7}, - [1159] = {.lex_state = 33}, - [1160] = {.lex_state = 33}, - [1161] = {.lex_state = 33}, - [1162] = {.lex_state = 7}, - [1163] = {.lex_state = 7}, - [1164] = {.lex_state = 33}, - [1165] = {.lex_state = 33}, - [1166] = {.lex_state = 7}, - [1167] = {.lex_state = 33}, - [1168] = {.lex_state = 33}, - [1169] = {.lex_state = 33}, - [1170] = {.lex_state = 33}, - [1171] = {.lex_state = 33}, - [1172] = {.lex_state = 33}, - [1173] = {.lex_state = 7}, - [1174] = {.lex_state = 33}, - [1175] = {.lex_state = 7}, - [1176] = {.lex_state = 33}, - [1177] = {.lex_state = 33}, - [1178] = {.lex_state = 33}, - [1179] = {.lex_state = 33}, - [1180] = {.lex_state = 33}, - [1181] = {.lex_state = 33}, - [1182] = {.lex_state = 33}, - [1183] = {.lex_state = 7}, - [1184] = {.lex_state = 33}, - [1185] = {.lex_state = 33}, - [1186] = {.lex_state = 7}, - [1187] = {.lex_state = 33}, - [1188] = {.lex_state = 33}, - [1189] = {.lex_state = 7}, - [1190] = {.lex_state = 33}, - [1191] = {.lex_state = 33}, - [1192] = {.lex_state = 33}, - [1193] = {.lex_state = 6}, - [1194] = {.lex_state = 6}, - [1195] = {.lex_state = 33}, - [1196] = {.lex_state = 33}, - [1197] = {.lex_state = 33}, - [1198] = {.lex_state = 33}, - [1199] = {.lex_state = 33}, - [1200] = {.lex_state = 33}, - [1201] = {.lex_state = 33}, - [1202] = {.lex_state = 33}, - [1203] = {.lex_state = 33}, - [1204] = {.lex_state = 33}, - [1205] = {.lex_state = 33}, - [1206] = {.lex_state = 33}, - [1207] = {.lex_state = 33}, - [1208] = {.lex_state = 33}, - [1209] = {.lex_state = 33}, - [1210] = {.lex_state = 33}, - [1211] = {.lex_state = 7}, - [1212] = {.lex_state = 33}, - [1213] = {.lex_state = 33}, - [1214] = {.lex_state = 33}, - [1215] = {.lex_state = 33}, - [1216] = {.lex_state = 33}, - [1217] = {.lex_state = 33}, - [1218] = {.lex_state = 33}, - [1219] = {.lex_state = 33}, - [1220] = {.lex_state = 33}, - [1221] = {.lex_state = 33}, - [1222] = {.lex_state = 33}, - [1223] = {.lex_state = 33}, - [1224] = {.lex_state = 33}, - [1225] = {.lex_state = 33}, - [1226] = {.lex_state = 33}, - [1227] = {.lex_state = 7}, - [1228] = {.lex_state = 7}, - [1229] = {.lex_state = 33}, - [1230] = {.lex_state = 33}, - [1231] = {.lex_state = 33}, - [1232] = {.lex_state = 33}, - [1233] = {.lex_state = 33}, - [1234] = {.lex_state = 33}, - [1235] = {.lex_state = 33}, - [1236] = {.lex_state = 6}, - [1237] = {.lex_state = 33}, - [1238] = {.lex_state = 7}, - [1239] = {.lex_state = 33}, - [1240] = {.lex_state = 33}, - [1241] = {.lex_state = 33}, - [1242] = {.lex_state = 33}, - [1243] = {.lex_state = 33}, - [1244] = {.lex_state = 6}, - [1245] = {.lex_state = 33}, - [1246] = {.lex_state = 33}, - [1247] = {.lex_state = 33}, - [1248] = {.lex_state = 33}, - [1249] = {.lex_state = 33}, - [1250] = {.lex_state = 33}, - [1251] = {.lex_state = 33}, - [1252] = {.lex_state = 6}, - [1253] = {.lex_state = 7}, - [1254] = {.lex_state = 33}, - [1255] = {.lex_state = 33}, - [1256] = {.lex_state = 33}, - [1257] = {.lex_state = 33}, - [1258] = {.lex_state = 33}, - [1259] = {.lex_state = 33}, - [1260] = {.lex_state = 33}, - [1261] = {.lex_state = 33}, - [1262] = {.lex_state = 33}, - [1263] = {.lex_state = 33}, - [1264] = {.lex_state = 33}, - [1265] = {.lex_state = 33}, - [1266] = {.lex_state = 33}, - [1267] = {.lex_state = 33}, - [1268] = {.lex_state = 33}, - [1269] = {.lex_state = 33}, - [1270] = {.lex_state = 33}, - [1271] = {.lex_state = 33}, - [1272] = {.lex_state = 33}, - [1273] = {.lex_state = 33}, - [1274] = {.lex_state = 33}, - [1275] = {.lex_state = 6}, - [1276] = {.lex_state = 33}, - [1277] = {.lex_state = 33}, - [1278] = {.lex_state = 7}, - [1279] = {.lex_state = 33}, - [1280] = {.lex_state = 33}, - [1281] = {.lex_state = 33}, - [1282] = {.lex_state = 33}, - [1283] = {.lex_state = 33}, - [1284] = {.lex_state = 33}, - [1285] = {.lex_state = 33}, - [1286] = {.lex_state = 33}, - [1287] = {.lex_state = 33}, - [1288] = {.lex_state = 33}, - [1289] = {.lex_state = 33}, - [1290] = {.lex_state = 33}, - [1291] = {.lex_state = 33}, - [1292] = {.lex_state = 33}, - [1293] = {.lex_state = 6}, - [1294] = {.lex_state = 33}, - [1295] = {.lex_state = 33}, - [1296] = {.lex_state = 33}, - [1297] = {.lex_state = 33}, - [1298] = {.lex_state = 33}, - [1299] = {.lex_state = 6}, - [1300] = {.lex_state = 33}, - [1301] = {.lex_state = 33}, - [1302] = {.lex_state = 33}, - [1303] = {.lex_state = 33}, - [1304] = {.lex_state = 33}, - [1305] = {.lex_state = 33}, - [1306] = {.lex_state = 33}, - [1307] = {.lex_state = 33}, - [1308] = {.lex_state = 33}, - [1309] = {.lex_state = 33}, - [1310] = {.lex_state = 33}, - [1311] = {.lex_state = 33}, - [1312] = {.lex_state = 6}, - [1313] = {.lex_state = 33}, - [1314] = {.lex_state = 33}, - [1315] = {.lex_state = 33}, - [1316] = {.lex_state = 33}, - [1317] = {.lex_state = 33}, - [1318] = {.lex_state = 6}, - [1319] = {.lex_state = 33}, - [1320] = {.lex_state = 33}, - [1321] = {.lex_state = 33}, - [1322] = {.lex_state = 33}, - [1323] = {.lex_state = 7}, - [1324] = {.lex_state = 33}, - [1325] = {.lex_state = 33}, - [1326] = {.lex_state = 33}, - [1327] = {.lex_state = 33}, - [1328] = {.lex_state = 33}, - [1329] = {.lex_state = 33}, - [1330] = {.lex_state = 33}, - [1331] = {.lex_state = 33}, - [1332] = {.lex_state = 33}, - [1333] = {.lex_state = 33}, - [1334] = {.lex_state = 33}, - [1335] = {.lex_state = 33}, - [1336] = {.lex_state = 33}, - [1337] = {.lex_state = 6}, - [1338] = {.lex_state = 33}, - [1339] = {.lex_state = 33}, - [1340] = {.lex_state = 33}, - [1341] = {.lex_state = 33}, - [1342] = {.lex_state = 33}, - [1343] = {.lex_state = 7}, - [1344] = {.lex_state = 33}, - [1345] = {.lex_state = 33}, - [1346] = {.lex_state = 33}, - [1347] = {.lex_state = 33}, - [1348] = {.lex_state = 33}, - [1349] = {.lex_state = 33}, - [1350] = {.lex_state = 33}, - [1351] = {.lex_state = 33}, - [1352] = {.lex_state = 33}, - [1353] = {.lex_state = 6}, - [1354] = {.lex_state = 6}, - [1355] = {.lex_state = 6}, - [1356] = {.lex_state = 6}, - [1357] = {.lex_state = 33}, - [1358] = {.lex_state = 33}, - [1359] = {.lex_state = 33}, - [1360] = {.lex_state = 33}, - [1361] = {.lex_state = 33}, - [1362] = {.lex_state = 33}, - [1363] = {.lex_state = 33}, - [1364] = {.lex_state = 33}, - [1365] = {.lex_state = 33}, - [1366] = {.lex_state = 33}, - [1367] = {.lex_state = 33}, - [1368] = {.lex_state = 33}, - [1369] = {.lex_state = 33}, - [1370] = {.lex_state = 33}, - [1371] = {.lex_state = 33}, - [1372] = {.lex_state = 33}, - [1373] = {.lex_state = 33}, - [1374] = {.lex_state = 33}, - [1375] = {.lex_state = 33}, - [1376] = {.lex_state = 33}, - [1377] = {.lex_state = 33}, - [1378] = {.lex_state = 33}, - [1379] = {.lex_state = 33}, - [1380] = {.lex_state = 33}, - [1381] = {.lex_state = 33}, - [1382] = {.lex_state = 33}, - [1383] = {.lex_state = 6}, - [1384] = {.lex_state = 33}, - [1385] = {.lex_state = 33}, - [1386] = {.lex_state = 33}, - [1387] = {.lex_state = 33}, - [1388] = {.lex_state = 6}, - [1389] = {.lex_state = 33}, - [1390] = {.lex_state = 33}, - [1391] = {.lex_state = 33}, - [1392] = {.lex_state = 33}, - [1393] = {.lex_state = 33}, - [1394] = {.lex_state = 33}, - [1395] = {.lex_state = 33}, - [1396] = {.lex_state = 33}, - [1397] = {.lex_state = 33}, - [1398] = {.lex_state = 33}, - [1399] = {.lex_state = 33}, - [1400] = {.lex_state = 33}, - [1401] = {.lex_state = 33}, - [1402] = {.lex_state = 33}, - [1403] = {.lex_state = 33}, - [1404] = {.lex_state = 33}, - [1405] = {.lex_state = 33}, - [1406] = {.lex_state = 33}, - [1407] = {.lex_state = 33}, - [1408] = {.lex_state = 33}, - [1409] = {.lex_state = 33}, - [1410] = {.lex_state = 33}, - [1411] = {.lex_state = 33}, - [1412] = {.lex_state = 33}, - [1413] = {.lex_state = 33}, - [1414] = {.lex_state = 33}, - [1415] = {.lex_state = 6}, - [1416] = {.lex_state = 33}, - [1417] = {.lex_state = 6}, - [1418] = {.lex_state = 7}, - [1419] = {.lex_state = 33}, - [1420] = {.lex_state = 33}, - [1421] = {.lex_state = 33}, - [1422] = {.lex_state = 33}, - [1423] = {.lex_state = 6}, - [1424] = {.lex_state = 6}, - [1425] = {.lex_state = 33}, - [1426] = {.lex_state = 33}, - [1427] = {.lex_state = 33}, - [1428] = {.lex_state = 6}, - [1429] = {.lex_state = 33}, - [1430] = {.lex_state = 33}, - [1431] = {.lex_state = 33}, - [1432] = {.lex_state = 33}, - [1433] = {.lex_state = 33}, - [1434] = {.lex_state = 7}, - [1435] = {.lex_state = 33}, - [1436] = {.lex_state = 33}, - [1437] = {.lex_state = 33}, - [1438] = {.lex_state = 33}, - [1439] = {.lex_state = 6}, - [1440] = {.lex_state = 6}, - [1441] = {.lex_state = 33}, + [978] = {.lex_state = 6}, + [979] = {.lex_state = 0}, + [980] = {.lex_state = 6}, + [981] = {.lex_state = 6}, + [982] = {.lex_state = 0}, + [983] = {.lex_state = 6}, + [984] = {.lex_state = 0}, + [985] = {.lex_state = 37}, + [986] = {.lex_state = 0}, + [987] = {.lex_state = 37}, + [988] = {.lex_state = 37}, + [989] = {.lex_state = 37}, + [990] = {.lex_state = 0}, + [991] = {.lex_state = 37}, + [992] = {.lex_state = 0}, + [993] = {.lex_state = 37}, + [994] = {.lex_state = 0}, + [995] = {.lex_state = 0}, + [996] = {.lex_state = 37}, + [997] = {.lex_state = 37}, + [998] = {.lex_state = 0}, + [999] = {.lex_state = 7}, + [1000] = {.lex_state = 0}, + [1001] = {.lex_state = 37}, + [1002] = {.lex_state = 0}, + [1003] = {.lex_state = 0}, + [1004] = {.lex_state = 0}, + [1005] = {.lex_state = 37}, + [1006] = {.lex_state = 37}, + [1007] = {.lex_state = 0}, + [1008] = {.lex_state = 37}, + [1009] = {.lex_state = 37}, + [1010] = {.lex_state = 41}, + [1011] = {.lex_state = 37}, + [1012] = {.lex_state = 41}, + [1013] = {.lex_state = 37}, + [1014] = {.lex_state = 7}, + [1015] = {.lex_state = 37}, + [1016] = {.lex_state = 37}, + [1017] = {.lex_state = 37}, + [1018] = {.lex_state = 37}, + [1019] = {.lex_state = 37}, + [1020] = {.lex_state = 37}, + [1021] = {.lex_state = 37}, + [1022] = {.lex_state = 37}, + [1023] = {.lex_state = 37}, + [1024] = {.lex_state = 41}, + [1025] = {.lex_state = 37}, + [1026] = {.lex_state = 37}, + [1027] = {.lex_state = 37}, + [1028] = {.lex_state = 37}, + [1029] = {.lex_state = 37}, + [1030] = {.lex_state = 37}, + [1031] = {.lex_state = 37}, + [1032] = {.lex_state = 37}, + [1033] = {.lex_state = 37}, + [1034] = {.lex_state = 37}, + [1035] = {.lex_state = 37}, + [1036] = {.lex_state = 37}, + [1037] = {.lex_state = 37}, + [1038] = {.lex_state = 37}, + [1039] = {.lex_state = 37}, + [1040] = {.lex_state = 37}, + [1041] = {.lex_state = 37}, + [1042] = {.lex_state = 37}, + [1043] = {.lex_state = 37}, + [1044] = {.lex_state = 37}, + [1045] = {.lex_state = 37}, + [1046] = {.lex_state = 37}, + [1047] = {.lex_state = 37}, + [1048] = {.lex_state = 37}, + [1049] = {.lex_state = 37}, + [1050] = {.lex_state = 37}, + [1051] = {.lex_state = 37}, + [1052] = {.lex_state = 37}, + [1053] = {.lex_state = 37}, + [1054] = {.lex_state = 37}, + [1055] = {.lex_state = 0}, + [1056] = {.lex_state = 37}, + [1057] = {.lex_state = 37}, + [1058] = {.lex_state = 37}, + [1059] = {.lex_state = 37}, + [1060] = {.lex_state = 37}, + [1061] = {.lex_state = 37}, + [1062] = {.lex_state = 37}, + [1063] = {.lex_state = 37}, + [1064] = {.lex_state = 37}, + [1065] = {.lex_state = 37}, + [1066] = {.lex_state = 37}, + [1067] = {.lex_state = 41}, + [1068] = {.lex_state = 37}, + [1069] = {.lex_state = 37}, + [1070] = {.lex_state = 37}, + [1071] = {.lex_state = 37}, + [1072] = {.lex_state = 37}, + [1073] = {.lex_state = 37}, + [1074] = {.lex_state = 37}, + [1075] = {.lex_state = 37}, + [1076] = {.lex_state = 37}, + [1077] = {.lex_state = 37}, + [1078] = {.lex_state = 37}, + [1079] = {.lex_state = 37}, + [1080] = {.lex_state = 37}, + [1081] = {.lex_state = 37}, + [1082] = {.lex_state = 37}, + [1083] = {.lex_state = 37}, + [1084] = {.lex_state = 37}, + [1085] = {.lex_state = 37}, + [1086] = {.lex_state = 37}, + [1087] = {.lex_state = 37}, + [1088] = {.lex_state = 37}, + [1089] = {.lex_state = 37}, + [1090] = {.lex_state = 37}, + [1091] = {.lex_state = 37}, + [1092] = {.lex_state = 37}, + [1093] = {.lex_state = 37}, + [1094] = {.lex_state = 37}, + [1095] = {.lex_state = 37}, + [1096] = {.lex_state = 37}, + [1097] = {.lex_state = 37}, + [1098] = {.lex_state = 37}, + [1099] = {.lex_state = 37}, + [1100] = {.lex_state = 0}, + [1101] = {.lex_state = 0}, + [1102] = {.lex_state = 0}, + [1103] = {.lex_state = 0}, + [1104] = {.lex_state = 0}, + [1105] = {.lex_state = 0}, + [1106] = {.lex_state = 37}, + [1107] = {.lex_state = 0}, + [1108] = {.lex_state = 0}, + [1109] = {.lex_state = 0}, + [1110] = {.lex_state = 0}, + [1111] = {.lex_state = 0}, + [1112] = {.lex_state = 0}, + [1113] = {.lex_state = 0}, + [1114] = {.lex_state = 0}, + [1115] = {.lex_state = 0}, + [1116] = {.lex_state = 0}, + [1117] = {.lex_state = 0}, + [1118] = {.lex_state = 0}, + [1119] = {.lex_state = 0}, + [1120] = {.lex_state = 0}, + [1121] = {.lex_state = 37}, + [1122] = {.lex_state = 37}, + [1123] = {.lex_state = 37}, + [1124] = {.lex_state = 37}, + [1125] = {.lex_state = 37}, + [1126] = {.lex_state = 37}, + [1127] = {.lex_state = 37}, + [1128] = {.lex_state = 37}, + [1129] = {.lex_state = 37}, + [1130] = {.lex_state = 37}, + [1131] = {.lex_state = 37}, + [1132] = {.lex_state = 37}, + [1133] = {.lex_state = 37}, + [1134] = {.lex_state = 37}, + [1135] = {.lex_state = 37}, + [1136] = {.lex_state = 37}, + [1137] = {.lex_state = 37}, + [1138] = {.lex_state = 37}, + [1139] = {.lex_state = 37}, + [1140] = {.lex_state = 37}, + [1141] = {.lex_state = 37}, + [1142] = {.lex_state = 37}, + [1143] = {.lex_state = 37}, + [1144] = {.lex_state = 37}, + [1145] = {.lex_state = 37}, + [1146] = {.lex_state = 37}, + [1147] = {.lex_state = 37}, + [1148] = {.lex_state = 37}, + [1149] = {.lex_state = 37}, + [1150] = {.lex_state = 37}, + [1151] = {.lex_state = 37}, + [1152] = {.lex_state = 37}, + [1153] = {.lex_state = 37}, + [1154] = {.lex_state = 0}, + [1155] = {.lex_state = 37}, + [1156] = {.lex_state = 37}, + [1157] = {.lex_state = 37}, + [1158] = {.lex_state = 37}, + [1159] = {.lex_state = 37}, + [1160] = {.lex_state = 37}, + [1161] = {.lex_state = 37}, + [1162] = {.lex_state = 37}, + [1163] = {.lex_state = 37}, + [1164] = {.lex_state = 37}, + [1165] = {.lex_state = 37}, + [1166] = {.lex_state = 37}, + [1167] = {.lex_state = 37}, + [1168] = {.lex_state = 37}, + [1169] = {.lex_state = 37}, + [1170] = {.lex_state = 13}, + [1171] = {.lex_state = 37}, + [1172] = {.lex_state = 37}, + [1173] = {.lex_state = 37}, + [1174] = {.lex_state = 37}, + [1175] = {.lex_state = 37}, + [1176] = {.lex_state = 37}, + [1177] = {.lex_state = 37}, + [1178] = {.lex_state = 13}, + [1179] = {.lex_state = 37}, + [1180] = {.lex_state = 37}, + [1181] = {.lex_state = 37}, + [1182] = {.lex_state = 37}, + [1183] = {.lex_state = 37}, + [1184] = {.lex_state = 37}, + [1185] = {.lex_state = 37}, + [1186] = {.lex_state = 37}, + [1187] = {.lex_state = 37}, + [1188] = {.lex_state = 37}, + [1189] = {.lex_state = 37}, + [1190] = {.lex_state = 37}, + [1191] = {.lex_state = 0}, + [1192] = {.lex_state = 37}, + [1193] = {.lex_state = 37}, + [1194] = {.lex_state = 37}, + [1195] = {.lex_state = 37}, + [1196] = {.lex_state = 37}, + [1197] = {.lex_state = 37}, + [1198] = {.lex_state = 37}, + [1199] = {.lex_state = 6}, + [1200] = {.lex_state = 7}, + [1201] = {.lex_state = 7}, + [1202] = {.lex_state = 7}, + [1203] = {.lex_state = 6}, + [1204] = {.lex_state = 7}, + [1205] = {.lex_state = 37}, + [1206] = {.lex_state = 37}, + [1207] = {.lex_state = 37}, + [1208] = {.lex_state = 37}, + [1209] = {.lex_state = 7}, + [1210] = {.lex_state = 6}, + [1211] = {.lex_state = 6}, + [1212] = {.lex_state = 6}, + [1213] = {.lex_state = 37}, + [1214] = {.lex_state = 37}, + [1215] = {.lex_state = 37}, + [1216] = {.lex_state = 37}, + [1217] = {.lex_state = 37}, + [1218] = {.lex_state = 37}, + [1219] = {.lex_state = 37}, + [1220] = {.lex_state = 37}, + [1221] = {.lex_state = 37}, + [1222] = {.lex_state = 6}, + [1223] = {.lex_state = 37}, + [1224] = {.lex_state = 37}, + [1225] = {.lex_state = 37}, + [1226] = {.lex_state = 37}, + [1227] = {.lex_state = 37}, + [1228] = {.lex_state = 37}, + [1229] = {.lex_state = 37}, + [1230] = {.lex_state = 37}, + [1231] = {.lex_state = 37}, + [1232] = {.lex_state = 37}, + [1233] = {.lex_state = 37}, + [1234] = {.lex_state = 37}, + [1235] = {.lex_state = 37}, + [1236] = {.lex_state = 37}, + [1237] = {.lex_state = 6}, + [1238] = {.lex_state = 6}, + [1239] = {.lex_state = 37}, + [1240] = {.lex_state = 37}, + [1241] = {.lex_state = 37}, + [1242] = {.lex_state = 37}, + [1243] = {.lex_state = 6}, + [1244] = {.lex_state = 37}, + [1245] = {.lex_state = 7}, + [1246] = {.lex_state = 37}, + [1247] = {.lex_state = 37}, + [1248] = {.lex_state = 37}, + [1249] = {.lex_state = 6}, + [1250] = {.lex_state = 37}, + [1251] = {.lex_state = 37}, + [1252] = {.lex_state = 37}, + [1253] = {.lex_state = 37}, + [1254] = {.lex_state = 37}, + [1255] = {.lex_state = 6}, + [1256] = {.lex_state = 37}, + [1257] = {.lex_state = 37}, + [1258] = {.lex_state = 6}, + [1259] = {.lex_state = 37}, + [1260] = {.lex_state = 37}, + [1261] = {.lex_state = 37}, + [1262] = {.lex_state = 37}, + [1263] = {.lex_state = 37}, + [1264] = {.lex_state = 6}, + [1265] = {.lex_state = 37}, + [1266] = {.lex_state = 37}, + [1267] = {.lex_state = 7}, + [1268] = {.lex_state = 37}, + [1269] = {.lex_state = 7}, + [1270] = {.lex_state = 37}, + [1271] = {.lex_state = 7}, + [1272] = {.lex_state = 7}, + [1273] = {.lex_state = 7}, + [1274] = {.lex_state = 7}, + [1275] = {.lex_state = 37}, + [1276] = {.lex_state = 37}, + [1277] = {.lex_state = 7}, + [1278] = {.lex_state = 37}, + [1279] = {.lex_state = 37}, + [1280] = {.lex_state = 37}, + [1281] = {.lex_state = 37}, + [1282] = {.lex_state = 37}, + [1283] = {.lex_state = 37}, + [1284] = {.lex_state = 37}, + [1285] = {.lex_state = 37}, + [1286] = {.lex_state = 37}, + [1287] = {.lex_state = 37}, + [1288] = {.lex_state = 37}, + [1289] = {.lex_state = 37}, + [1290] = {.lex_state = 37}, + [1291] = {.lex_state = 37}, + [1292] = {.lex_state = 37}, + [1293] = {.lex_state = 37}, + [1294] = {.lex_state = 37}, + [1295] = {.lex_state = 37}, + [1296] = {.lex_state = 37}, + [1297] = {.lex_state = 37}, + [1298] = {.lex_state = 37}, + [1299] = {.lex_state = 37}, + [1300] = {.lex_state = 37}, + [1301] = {.lex_state = 37}, + [1302] = {.lex_state = 13}, + [1303] = {.lex_state = 37}, + [1304] = {.lex_state = 37}, + [1305] = {.lex_state = 37}, + [1306] = {.lex_state = 37}, + [1307] = {.lex_state = 37}, + [1308] = {.lex_state = 37}, + [1309] = {.lex_state = 6}, + [1310] = {.lex_state = 37}, + [1311] = {.lex_state = 37}, + [1312] = {.lex_state = 37}, + [1313] = {.lex_state = 37}, + [1314] = {.lex_state = 37}, + [1315] = {.lex_state = 37}, + [1316] = {.lex_state = 6}, + [1317] = {.lex_state = 6}, + [1318] = {.lex_state = 37}, + [1319] = {.lex_state = 37}, + [1320] = {.lex_state = 37}, + [1321] = {.lex_state = 37}, + [1322] = {.lex_state = 37}, + [1323] = {.lex_state = 37}, + [1324] = {.lex_state = 37}, + [1325] = {.lex_state = 37}, + [1326] = {.lex_state = 37}, + [1327] = {.lex_state = 37}, + [1328] = {.lex_state = 37}, + [1329] = {.lex_state = 37}, + [1330] = {.lex_state = 37}, + [1331] = {.lex_state = 37}, + [1332] = {.lex_state = 37}, + [1333] = {.lex_state = 37}, + [1334] = {.lex_state = 13}, + [1335] = {.lex_state = 37}, + [1336] = {.lex_state = 37}, + [1337] = {.lex_state = 13}, + [1338] = {.lex_state = 37}, + [1339] = {.lex_state = 37}, + [1340] = {.lex_state = 37}, + [1341] = {.lex_state = 37}, + [1342] = {.lex_state = 37}, + [1343] = {.lex_state = 37}, + [1344] = {.lex_state = 37}, + [1345] = {.lex_state = 37}, + [1346] = {.lex_state = 13}, + [1347] = {.lex_state = 37}, + [1348] = {.lex_state = 6}, + [1349] = {.lex_state = 37}, + [1350] = {.lex_state = 37}, + [1351] = {.lex_state = 37}, + [1352] = {.lex_state = 37}, + [1353] = {.lex_state = 37}, + [1354] = {.lex_state = 37}, + [1355] = {.lex_state = 37}, + [1356] = {.lex_state = 37}, + [1357] = {.lex_state = 37}, + [1358] = {.lex_state = 37}, + [1359] = {.lex_state = 37}, + [1360] = {.lex_state = 37}, + [1361] = {.lex_state = 37}, + [1362] = {.lex_state = 37}, + [1363] = {.lex_state = 37}, + [1364] = {.lex_state = 37}, + [1365] = {.lex_state = 37}, + [1366] = {.lex_state = 37}, + [1367] = {.lex_state = 37}, + [1368] = {.lex_state = 37}, + [1369] = {.lex_state = 37}, + [1370] = {.lex_state = 6}, + [1371] = {.lex_state = 37}, + [1372] = {.lex_state = 37}, + [1373] = {.lex_state = 37}, + [1374] = {.lex_state = 37}, + [1375] = {.lex_state = 37}, + [1376] = {.lex_state = 37}, + [1377] = {.lex_state = 37}, + [1378] = {.lex_state = 37}, + [1379] = {.lex_state = 37}, + [1380] = {.lex_state = 37}, + [1381] = {.lex_state = 37}, + [1382] = {.lex_state = 37}, + [1383] = {.lex_state = 37}, + [1384] = {.lex_state = 37}, + [1385] = {.lex_state = 37}, + [1386] = {.lex_state = 37}, + [1387] = {.lex_state = 37}, + [1388] = {.lex_state = 7}, + [1389] = {.lex_state = 37}, + [1390] = {.lex_state = 37}, + [1391] = {.lex_state = 37}, + [1392] = {.lex_state = 37}, + [1393] = {.lex_state = 37}, + [1394] = {.lex_state = 37}, + [1395] = {.lex_state = 37}, + [1396] = {.lex_state = 7}, + [1397] = {.lex_state = 6}, + [1398] = {.lex_state = 37}, + [1399] = {.lex_state = 37}, + [1400] = {.lex_state = 37}, + [1401] = {.lex_state = 37}, + [1402] = {.lex_state = 37}, + [1403] = {.lex_state = 37}, + [1404] = {.lex_state = 37}, + [1405] = {.lex_state = 37}, + [1406] = {.lex_state = 37}, + [1407] = {.lex_state = 37}, + [1408] = {.lex_state = 37}, + [1409] = {.lex_state = 37}, + [1410] = {.lex_state = 37}, + [1411] = {.lex_state = 37}, + [1412] = {.lex_state = 37}, + [1413] = {.lex_state = 37}, + [1414] = {.lex_state = 37}, + [1415] = {.lex_state = 37}, + [1416] = {.lex_state = 37}, + [1417] = {.lex_state = 37}, + [1418] = {.lex_state = 37}, + [1419] = {.lex_state = 37}, + [1420] = {.lex_state = 37}, + [1421] = {.lex_state = 37}, + [1422] = {.lex_state = 37}, + [1423] = {.lex_state = 7}, + [1424] = {.lex_state = 37}, + [1425] = {.lex_state = 37}, + [1426] = {.lex_state = 37}, + [1427] = {.lex_state = 37}, + [1428] = {.lex_state = 37}, + [1429] = {.lex_state = 37}, + [1430] = {.lex_state = 37}, + [1431] = {.lex_state = 37}, + [1432] = {.lex_state = 7}, + [1433] = {.lex_state = 37}, + [1434] = {.lex_state = 37}, + [1435] = {.lex_state = 37}, + [1436] = {.lex_state = 37}, + [1437] = {.lex_state = 37}, + [1438] = {.lex_state = 7}, + [1439] = {.lex_state = 37}, + [1440] = {.lex_state = 37}, + [1441] = {.lex_state = 37}, + [1442] = {.lex_state = 6}, + [1443] = {.lex_state = 7}, + [1444] = {.lex_state = 37}, + [1445] = {.lex_state = 37}, + [1446] = {.lex_state = 37}, + [1447] = {.lex_state = 37}, + [1448] = {.lex_state = 37}, + [1449] = {.lex_state = 37}, + [1450] = {.lex_state = 37}, + [1451] = {.lex_state = 7}, + [1452] = {.lex_state = 7}, + [1453] = {.lex_state = 37}, + [1454] = {.lex_state = 7}, + [1455] = {.lex_state = 7}, + [1456] = {.lex_state = 37}, + [1457] = {.lex_state = 37}, + [1458] = {.lex_state = 37}, + [1459] = {.lex_state = 37}, + [1460] = {.lex_state = 37}, + [1461] = {.lex_state = 37}, + [1462] = {.lex_state = 37}, + [1463] = {.lex_state = 37}, + [1464] = {.lex_state = 37}, + [1465] = {.lex_state = 37}, + [1466] = {.lex_state = 37}, + [1467] = {.lex_state = 37}, + [1468] = {.lex_state = 6}, + [1469] = {.lex_state = 37}, + [1470] = {.lex_state = 37}, + [1471] = {.lex_state = 37}, + [1472] = {.lex_state = 37}, + [1473] = {.lex_state = 37}, + [1474] = {.lex_state = 37}, + [1475] = {.lex_state = 37}, + [1476] = {.lex_state = 37}, + [1477] = {.lex_state = 37}, + [1478] = {.lex_state = 37}, + [1479] = {.lex_state = 37}, + [1480] = {.lex_state = 37}, + [1481] = {.lex_state = 37}, + [1482] = {.lex_state = 37}, + [1483] = {.lex_state = 37}, + [1484] = {.lex_state = 37}, + [1485] = {.lex_state = 37}, + [1486] = {.lex_state = 37}, + [1487] = {.lex_state = 37}, + [1488] = {.lex_state = 37}, + [1489] = {.lex_state = 37}, + [1490] = {.lex_state = 6}, + [1491] = {.lex_state = 37}, + [1492] = {.lex_state = 37}, + [1493] = {.lex_state = 37}, + [1494] = {.lex_state = 37}, + [1495] = {.lex_state = 37}, + [1496] = {.lex_state = 37}, + [1497] = {.lex_state = 37}, + [1498] = {.lex_state = 37}, + [1499] = {.lex_state = 37}, + [1500] = {.lex_state = 37}, + [1501] = {.lex_state = 37}, + [1502] = {.lex_state = 37}, + [1503] = {.lex_state = 37}, + [1504] = {.lex_state = 37}, + [1505] = {.lex_state = 37}, + [1506] = {.lex_state = 37}, + [1507] = {.lex_state = 6}, + [1508] = {.lex_state = 37}, + [1509] = {.lex_state = 37}, + [1510] = {.lex_state = 37}, + [1511] = {.lex_state = 37}, + [1512] = {.lex_state = 37}, + [1513] = {.lex_state = 37}, + [1514] = {.lex_state = 37}, + [1515] = {.lex_state = 6}, + [1516] = {.lex_state = 37}, + [1517] = {.lex_state = 37}, + [1518] = {.lex_state = 37}, + [1519] = {.lex_state = 37}, + [1520] = {.lex_state = 6}, + [1521] = {.lex_state = 37}, + [1522] = {.lex_state = 37}, + [1523] = {.lex_state = 37}, + [1524] = {.lex_state = 37}, + [1525] = {.lex_state = 37}, + [1526] = {.lex_state = 37}, + [1527] = {.lex_state = 37}, + [1528] = {.lex_state = 7}, + [1529] = {.lex_state = 37}, + [1530] = {.lex_state = 37}, + [1531] = {.lex_state = 6}, + [1532] = {.lex_state = 7}, + [1533] = {.lex_state = 7}, + [1534] = {.lex_state = 37}, + [1535] = {.lex_state = 37}, + [1536] = {.lex_state = 37}, + [1537] = {.lex_state = 37}, + [1538] = {.lex_state = 7}, + [1539] = {.lex_state = 37}, + [1540] = {.lex_state = 7}, + [1541] = {.lex_state = 37}, + [1542] = {.lex_state = 7}, + [1543] = {.lex_state = 37}, + [1544] = {.lex_state = 37}, + [1545] = {.lex_state = 37}, + [1546] = {.lex_state = 37}, + [1547] = {.lex_state = 37}, + [1548] = {.lex_state = 37}, + [1549] = {.lex_state = 37}, + [1550] = {.lex_state = 37}, + [1551] = {.lex_state = 37}, + [1552] = {.lex_state = 37}, + [1553] = {.lex_state = 37}, + [1554] = {.lex_state = 7}, + [1555] = {.lex_state = 6}, + [1556] = {.lex_state = 37}, + [1557] = {.lex_state = 37}, + [1558] = {.lex_state = 37}, + [1559] = {.lex_state = 37}, + [1560] = {.lex_state = 37}, + [1561] = {.lex_state = 6}, + [1562] = {.lex_state = 37}, + [1563] = {.lex_state = 37}, + [1564] = {.lex_state = 37}, + [1565] = {.lex_state = 37}, + [1566] = {.lex_state = 37}, + [1567] = {.lex_state = 37}, + [1568] = {.lex_state = 37}, + [1569] = {.lex_state = 37}, + [1570] = {.lex_state = 37}, + [1571] = {.lex_state = 37}, + [1572] = {.lex_state = 37}, + [1573] = {.lex_state = 37}, + [1574] = {.lex_state = 37}, + [1575] = {.lex_state = 37}, + [1576] = {.lex_state = 37}, + [1577] = {.lex_state = 37}, + [1578] = {.lex_state = 37}, + [1579] = {.lex_state = 7}, + [1580] = {.lex_state = 37}, + [1581] = {.lex_state = 37}, + [1582] = {.lex_state = 37}, + [1583] = {.lex_state = 37}, + [1584] = {.lex_state = 37}, + [1585] = {.lex_state = 37}, + [1586] = {.lex_state = 6}, + [1587] = {.lex_state = 37}, + [1588] = {.lex_state = 37}, + [1589] = {.lex_state = 37}, + [1590] = {.lex_state = 37}, + [1591] = {.lex_state = 37}, + [1592] = {.lex_state = 37}, + [1593] = {.lex_state = 37}, + [1594] = {.lex_state = 37}, + [1595] = {.lex_state = 37}, + [1596] = {.lex_state = 37}, + [1597] = {.lex_state = 37}, + [1598] = {.lex_state = 37}, + [1599] = {.lex_state = 37}, + [1600] = {.lex_state = 37}, + [1601] = {.lex_state = 37}, + [1602] = {.lex_state = 37}, + [1603] = {.lex_state = 37}, + [1604] = {.lex_state = 37}, + [1605] = {.lex_state = 37}, + [1606] = {.lex_state = 6}, + [1607] = {.lex_state = 37}, + [1608] = {.lex_state = 6}, + [1609] = {.lex_state = 37}, + [1610] = {.lex_state = 37}, + [1611] = {.lex_state = 37}, + [1612] = {.lex_state = 6}, + [1613] = {.lex_state = 37}, + [1614] = {.lex_state = 37}, + [1615] = {.lex_state = 37}, + [1616] = {.lex_state = 37}, + [1617] = {.lex_state = 37}, + [1618] = {.lex_state = 37}, + [1619] = {.lex_state = 37}, + [1620] = {.lex_state = 37}, + [1621] = {.lex_state = 37}, + [1622] = {.lex_state = 37}, + [1623] = {.lex_state = 37}, + [1624] = {.lex_state = 6}, + [1625] = {.lex_state = 37}, + [1626] = {.lex_state = 37}, + [1627] = {.lex_state = 37}, + [1628] = {.lex_state = 7}, + [1629] = {.lex_state = 37}, + [1630] = {.lex_state = 37}, + [1631] = {.lex_state = 37}, + [1632] = {.lex_state = 37}, + [1633] = {.lex_state = 6}, + [1634] = {.lex_state = 37}, + [1635] = {.lex_state = 7}, + [1636] = {.lex_state = 7}, + [1637] = {.lex_state = 37}, + [1638] = {.lex_state = 6}, + [1639] = {.lex_state = 7}, + [1640] = {.lex_state = 37}, + [1641] = {.lex_state = 37}, + [1642] = {.lex_state = 37}, + [1643] = {.lex_state = 37}, + [1644] = {.lex_state = 37}, + [1645] = {.lex_state = 37}, + [1646] = {.lex_state = 37}, + [1647] = {.lex_state = 7}, + [1648] = {.lex_state = 7}, + [1649] = {.lex_state = 37}, + [1650] = {.lex_state = 37}, + [1651] = {.lex_state = 37}, + [1652] = {.lex_state = 6}, + [1653] = {.lex_state = 37}, + [1654] = {.lex_state = 37}, + [1655] = {.lex_state = 37}, + [1656] = {.lex_state = 37}, + [1657] = {.lex_state = 6}, + [1658] = {.lex_state = 37}, + [1659] = {.lex_state = 37}, + [1660] = {.lex_state = 37}, + [1661] = {.lex_state = 37}, + [1662] = {.lex_state = 6}, + [1663] = {.lex_state = 37}, + [1664] = {.lex_state = 37}, + [1665] = {.lex_state = 6}, + [1666] = {.lex_state = 37}, + [1667] = {.lex_state = 6}, + [1668] = {.lex_state = 37}, + [1669] = {.lex_state = 37}, + [1670] = {.lex_state = 37}, + [1671] = {.lex_state = 37}, + [1672] = {.lex_state = 37}, + [1673] = {.lex_state = 37}, + [1674] = {.lex_state = 37}, + [1675] = {.lex_state = 7}, + [1676] = {.lex_state = 37}, + [1677] = {.lex_state = 37}, + [1678] = {.lex_state = 37}, + [1679] = {.lex_state = 37}, + [1680] = {.lex_state = 7}, + [1681] = {.lex_state = 37}, + [1682] = {.lex_state = 6}, + [1683] = {.lex_state = 37}, + [1684] = {.lex_state = 37}, + [1685] = {.lex_state = 37}, + [1686] = {.lex_state = 6}, + [1687] = {.lex_state = 37}, + [1688] = {.lex_state = 37}, + [1689] = {.lex_state = 37}, + [1690] = {.lex_state = 37}, + [1691] = {.lex_state = 37}, + [1692] = {.lex_state = 37}, + [1693] = {.lex_state = 37}, + [1694] = {.lex_state = 37}, + [1695] = {.lex_state = 37}, + [1696] = {.lex_state = 37}, + [1697] = {.lex_state = 37}, + [1698] = {.lex_state = 37}, + [1699] = {.lex_state = 37}, + [1700] = {.lex_state = 7}, + [1701] = {.lex_state = 37}, + [1702] = {.lex_state = 37}, + [1703] = {.lex_state = 37}, + [1704] = {.lex_state = 37}, + [1705] = {.lex_state = 37}, + [1706] = {.lex_state = 37}, + [1707] = {.lex_state = 37}, + [1708] = {.lex_state = 37}, + [1709] = {.lex_state = 37}, + [1710] = {.lex_state = 37}, + [1711] = {.lex_state = 37}, + [1712] = {.lex_state = 37}, + [1713] = {.lex_state = 37}, + [1714] = {.lex_state = 37}, + [1715] = {.lex_state = 37}, + [1716] = {.lex_state = 37}, + [1717] = {.lex_state = 37}, + [1718] = {.lex_state = 37}, + [1719] = {.lex_state = 6}, + [1720] = {.lex_state = 37}, + [1721] = {.lex_state = 37}, + [1722] = {.lex_state = 37}, + [1723] = {.lex_state = 37}, + [1724] = {.lex_state = 37}, + [1725] = {.lex_state = 37}, + [1726] = {.lex_state = 6}, + [1727] = {.lex_state = 37}, + [1728] = {.lex_state = 37}, + [1729] = {.lex_state = 37}, + [1730] = {.lex_state = 37}, + [1731] = {.lex_state = 6}, + [1732] = {.lex_state = 37}, + [1733] = {.lex_state = 37}, + [1734] = {.lex_state = 37}, + [1735] = {.lex_state = 37}, + [1736] = {.lex_state = 37}, + [1737] = {.lex_state = 37}, + [1738] = {.lex_state = 37}, + [1739] = {.lex_state = 37}, + [1740] = {.lex_state = 37}, + [1741] = {.lex_state = 37}, + [1742] = {.lex_state = 37}, + [1743] = {.lex_state = 37}, + [1744] = {.lex_state = 37}, + [1745] = {.lex_state = 37}, + [1746] = {.lex_state = 37}, + [1747] = {.lex_state = 37}, + [1748] = {.lex_state = 37}, + [1749] = {.lex_state = 37}, + [1750] = {.lex_state = 37}, + [1751] = {.lex_state = 37}, + [1752] = {.lex_state = 37}, + [1753] = {.lex_state = 37}, + [1754] = {.lex_state = 37}, + [1755] = {.lex_state = 37}, + [1756] = {.lex_state = 37}, + [1757] = {.lex_state = 37}, + [1758] = {.lex_state = 37}, + [1759] = {.lex_state = 37}, + [1760] = {.lex_state = 37}, + [1761] = {.lex_state = 37}, + [1762] = {.lex_state = 6}, + [1763] = {.lex_state = 37}, + [1764] = {.lex_state = 37}, + [1765] = {.lex_state = 6}, + [1766] = {.lex_state = 37}, + [1767] = {.lex_state = 37}, + [1768] = {.lex_state = 37}, + [1769] = {.lex_state = 37}, + [1770] = {.lex_state = 37}, + [1771] = {.lex_state = 37}, + [1772] = {.lex_state = 6}, + [1773] = {.lex_state = 6}, + [1774] = {.lex_state = 37}, + [1775] = {.lex_state = 37}, + [1776] = {.lex_state = 7}, + [1777] = {.lex_state = 37}, + [1778] = {.lex_state = 37}, + [1779] = {.lex_state = 37}, + [1780] = {.lex_state = 37}, + [1781] = {.lex_state = 37}, + [1782] = {.lex_state = 6}, + [1783] = {.lex_state = 37}, + [1784] = {.lex_state = 37}, + [1785] = {.lex_state = 37}, + [1786] = {.lex_state = 37}, + [1787] = {.lex_state = 37}, + [1788] = {.lex_state = 37}, + [1789] = {.lex_state = 7}, + [1790] = {.lex_state = 37}, + [1791] = {.lex_state = 37}, + [1792] = {.lex_state = 37}, + [1793] = {.lex_state = 37}, + [1794] = {.lex_state = 37}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -5710,6 +7041,14 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_identifier] = ACTIONS(1), [anon_sym_import] = ACTIONS(1), [anon_sym_DOT] = ACTIONS(1), + [anon_sym_COLON_COLON] = ACTIONS(1), + [anon_sym_as] = ACTIONS(1), + [anon_sym_LBRACE] = ACTIONS(1), + [anon_sym_RBRACE] = ACTIONS(1), + [anon_sym_STAR] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_namespace] = ACTIONS(1), + [anon_sym_SEMI] = ACTIONS(1), [anon_sym_let] = ACTIONS(1), [anon_sym_mut] = ACTIONS(1), [anon_sym_COLON] = ACTIONS(1), @@ -5721,13 +7060,10 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_RPAREN] = ACTIONS(1), [anon_sym_DASH_GT] = ACTIONS(1), [anon_sym_extern] = ACTIONS(1), - [anon_sym_COMMA] = ACTIONS(1), [anon_sym_type] = ACTIONS(1), [anon_sym_in] = ACTIONS(1), [anon_sym_out] = ACTIONS(1), [anon_sym_PIPE] = ACTIONS(1), - [anon_sym_LBRACE] = ACTIONS(1), - [anon_sym_RBRACE] = ACTIONS(1), [anon_sym_where] = ACTIONS(1), [anon_sym_effect] = ACTIONS(1), [anon_sym_BANG] = ACTIONS(1), @@ -5748,7 +7084,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_GT_EQ] = ACTIONS(1), [anon_sym_PLUS] = ACTIONS(1), [anon_sym_DASH] = ACTIONS(1), - [anon_sym_STAR] = ACTIONS(1), [anon_sym_SLASH] = ACTIONS(1), [anon_sym_PERCENT] = ACTIONS(1), [anon_sym_await] = ACTIONS(1), @@ -5762,7 +7097,12 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_resume] = ACTIONS(1), [anon_sym__] = ACTIONS(1), [anon_sym_DOT_DOT_DOT] = ACTIONS(1), + [anon_sym_state] = ACTIONS(1), [anon_sym_module] = ACTIONS(1), + [anon_sym_extra] = ACTIONS(1), + [anon_sym_export] = ACTIONS(1), + [anon_sym_opaque] = ACTIONS(1), + [anon_sym_signature] = ACTIONS(1), [anon_sym_true] = ACTIONS(1), [anon_sym_false] = ACTIONS(1), [sym_float] = ACTIONS(1), @@ -5773,1568 +7113,2077 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_line_comment] = ACTIONS(3), }, [1] = { - [sym_source_file] = STATE(1431), - [sym_statement] = STATE(10), - [sym_import_statement] = STATE(616), - [sym_let_declaration] = STATE(616), - [sym_assignment] = STATE(616), - [sym_function_declaration] = STATE(616), - [sym_extern_declaration] = STATE(616), - [sym_type_declaration] = STATE(616), - [sym_effect_declaration] = STATE(616), - [sym_expression_statement] = STATE(616), - [sym_expression] = STATE(451), - [sym_match_expression] = STATE(338), - [sym_if_expression] = STATE(338), - [sym_handler_expression] = STATE(338), - [sym_select_expression] = STATE(338), - [sym_ternary_expression] = STATE(338), - [sym_binary_expression] = STATE(338), - [sym_unary_expression] = STATE(338), - [sym_pipe_expression] = STATE(338), - [sym_call_expression] = STATE(338), - [sym_primary_expression] = STATE(338), - [sym_spawn_expression] = STATE(283), - [sym_yield_expression] = STATE(283), - [sym_await_call] = STATE(283), - [sym_send_call] = STATE(283), - [sym_recv_call] = STATE(283), - [sym_perform_expression] = STATE(283), - [sym_resume_expression] = STATE(283), - [sym_type_constructor] = STATE(283), - [sym_update_expression] = STATE(283), - [sym_block] = STATE(283), - [sym_object_literal] = STATE(283), - [sym_lambda_expression] = STATE(283), - [sym_literal] = STATE(283), - [sym_list_literal] = STATE(332), - [sym_map_literal] = STATE(332), - [sym_module_declaration] = STATE(616), - [sym_boolean] = STATE(332), - [sym_doc_comment] = STATE(894), - [aux_sym_source_file_repeat1] = STATE(10), - [aux_sym_doc_comment_repeat1] = STATE(824), + [sym_source_file] = STATE(1600), + [sym_statement] = STATE(12), + [sym_import_statement] = STATE(617), + [sym_namespace_declaration] = STATE(617), + [sym_let_declaration] = STATE(617), + [sym_assignment] = STATE(617), + [sym_function_declaration] = STATE(617), + [sym_extern_declaration] = STATE(617), + [sym_type_declaration] = STATE(617), + [sym_effect_declaration] = STATE(617), + [sym_expression_statement] = STATE(617), + [sym_expression] = STATE(379), + [sym_match_expression] = STATE(60), + [sym_if_expression] = STATE(60), + [sym_handler_expression] = STATE(60), + [sym_select_expression] = STATE(60), + [sym_ternary_expression] = STATE(60), + [sym_binary_expression] = STATE(60), + [sym_unary_expression] = STATE(60), + [sym_pipe_expression] = STATE(60), + [sym_call_expression] = STATE(60), + [sym_primary_expression] = STATE(60), + [sym_spawn_expression] = STATE(62), + [sym_yield_expression] = STATE(62), + [sym_await_call] = STATE(62), + [sym_send_call] = STATE(62), + [sym_recv_call] = STATE(62), + [sym_perform_expression] = STATE(62), + [sym_resume_expression] = STATE(62), + [sym_type_constructor] = STATE(62), + [sym_update_expression] = STATE(62), + [sym_block] = STATE(62), + [sym_object_literal] = STATE(62), + [sym_lambda_expression] = STATE(62), + [sym_literal] = STATE(62), + [sym_list_literal] = STATE(78), + [sym_map_literal] = STATE(78), + [sym_module_declaration] = STATE(617), + [sym_signature_declaration] = STATE(617), + [sym_qualified_path] = STATE(39), + [sym_boolean] = STATE(78), + [sym_doc_comment] = STATE(1013), + [aux_sym_source_file_repeat1] = STATE(12), + [aux_sym_doc_comment_repeat1] = STATE(968), [ts_builtin_sym_end] = ACTIONS(5), [sym_identifier] = ACTIONS(7), [anon_sym_import] = ACTIONS(9), - [anon_sym_let] = ACTIONS(11), - [anon_sym_mut] = ACTIONS(11), - [anon_sym_fn] = ACTIONS(13), - [anon_sym_LPAREN] = ACTIONS(15), - [anon_sym_extern] = ACTIONS(17), - [anon_sym_type] = ACTIONS(19), - [anon_sym_PIPE] = ACTIONS(21), - [anon_sym_LBRACE] = ACTIONS(23), - [anon_sym_effect] = ACTIONS(25), - [anon_sym_BANG] = ACTIONS(27), - [anon_sym_LBRACK] = ACTIONS(29), - [anon_sym_match] = ACTIONS(31), - [anon_sym_if] = ACTIONS(33), - [anon_sym_handle] = ACTIONS(35), - [anon_sym_select] = ACTIONS(37), - [anon_sym_PLUS] = ACTIONS(27), - [anon_sym_DASH] = ACTIONS(27), - [anon_sym_await] = ACTIONS(39), - [anon_sym_spawn] = ACTIONS(41), - [anon_sym_yield] = ACTIONS(43), - [anon_sym_send] = ACTIONS(45), - [anon_sym_recv] = ACTIONS(47), - [anon_sym_perform] = ACTIONS(49), - [anon_sym_resume] = ACTIONS(51), - [anon_sym_module] = ACTIONS(53), - [anon_sym_true] = ACTIONS(55), - [anon_sym_false] = ACTIONS(55), - [sym_float] = ACTIONS(57), - [sym_integer] = ACTIONS(59), - [sym_string] = ACTIONS(59), - [sym_interpolated_string] = ACTIONS(59), - [sym__doc_comment_line] = ACTIONS(61), + [anon_sym_LBRACE] = ACTIONS(11), + [anon_sym_namespace] = ACTIONS(13), + [anon_sym_let] = ACTIONS(15), + [anon_sym_mut] = ACTIONS(15), + [anon_sym_fn] = ACTIONS(17), + [anon_sym_LPAREN] = ACTIONS(19), + [anon_sym_extern] = ACTIONS(21), + [anon_sym_type] = ACTIONS(23), + [anon_sym_PIPE] = ACTIONS(25), + [anon_sym_effect] = ACTIONS(27), + [anon_sym_BANG] = ACTIONS(29), + [anon_sym_LBRACK] = ACTIONS(31), + [anon_sym_match] = ACTIONS(33), + [anon_sym_if] = ACTIONS(35), + [anon_sym_handle] = ACTIONS(37), + [anon_sym_select] = ACTIONS(39), + [anon_sym_PLUS] = ACTIONS(29), + [anon_sym_DASH] = ACTIONS(29), + [anon_sym_await] = ACTIONS(41), + [anon_sym_spawn] = ACTIONS(43), + [anon_sym_yield] = ACTIONS(45), + [anon_sym_send] = ACTIONS(47), + [anon_sym_recv] = ACTIONS(49), + [anon_sym_perform] = ACTIONS(51), + [anon_sym_resume] = ACTIONS(53), + [anon_sym_state] = ACTIONS(55), + [anon_sym_module] = ACTIONS(57), + [anon_sym_signature] = ACTIONS(59), + [anon_sym_true] = ACTIONS(61), + [anon_sym_false] = ACTIONS(61), + [sym_float] = ACTIONS(63), + [sym_integer] = ACTIONS(65), + [sym_string] = ACTIONS(65), + [sym_interpolated_string] = ACTIONS(65), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [2] = { - [sym_expression] = STATE(351), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_boolean] = STATE(341), - [sym_identifier] = ACTIONS(63), - [anon_sym_import] = ACTIONS(65), - [anon_sym_DOT] = ACTIONS(67), - [anon_sym_let] = ACTIONS(65), - [anon_sym_mut] = ACTIONS(65), - [anon_sym_COLON] = ACTIONS(67), - [anon_sym_fn] = ACTIONS(69), - [anon_sym_LT] = ACTIONS(65), - [anon_sym_GT] = ACTIONS(65), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(65), - [anon_sym_type] = ACTIONS(65), - [anon_sym_PIPE] = ACTIONS(73), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(67), - [anon_sym_effect] = ACTIONS(65), - [anon_sym_BANG] = ACTIONS(77), - [anon_sym_LBRACK] = ACTIONS(79), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_QMARK] = ACTIONS(67), - [anon_sym_PIPE_PIPE] = ACTIONS(67), - [anon_sym_AMP_AMP] = ACTIONS(67), - [anon_sym_EQ_EQ] = ACTIONS(67), - [anon_sym_BANG_EQ] = ACTIONS(67), - [anon_sym_LT_EQ] = ACTIONS(67), - [anon_sym_GT_EQ] = ACTIONS(67), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_STAR] = ACTIONS(67), - [anon_sym_SLASH] = ACTIONS(65), - [anon_sym_PERCENT] = ACTIONS(67), - [anon_sym_await] = ACTIONS(91), - [anon_sym_PIPE_GT] = ACTIONS(67), - [anon_sym_LBRACK2] = ACTIONS(67), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(65), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), + [sym_statement] = STATE(18), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(124), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_field_assignments] = STATE(1621), + [sym_field_assignment] = STATE(1375), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_map_entry] = STATE(1385), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(18), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(69), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(75), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [3] = { - [sym_statement] = STATE(7), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(309), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_field_assignments] = STATE(1360), - [sym_field_assignment] = STATE(1070), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_map_entry] = STATE(1080), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(7), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(111), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(125), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [sym_statement] = STATE(14), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(332), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_field_assignments] = STATE(1527), + [sym_field_assignment] = STATE(1375), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_map_entry] = STATE(1384), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(14), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(69), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(131), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [4] = { - [sym_statement] = STATE(14), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(304), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_field_assignments] = STATE(1344), - [sym_field_assignment] = STATE(1070), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_map_entry] = STATE(1077), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(14), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(111), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), + [sym_statement] = STATE(20), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(339), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_field_assignments] = STATE(1556), + [sym_field_assignment] = STATE(1375), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_map_entry] = STATE(1290), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(20), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(69), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), [anon_sym_RBRACE] = ACTIONS(133), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [5] = { - [sym_statement] = STATE(17), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(316), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_field_assignments] = STATE(1365), - [sym_field_assignment] = STATE(1070), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_map_entry] = STATE(1045), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(17), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(111), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(135), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [sym_expression] = STATE(164), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_identifier] = ACTIONS(135), + [anon_sym_import] = ACTIONS(137), + [anon_sym_DOT] = ACTIONS(139), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(139), + [anon_sym_STAR] = ACTIONS(139), + [anon_sym_namespace] = ACTIONS(137), + [anon_sym_let] = ACTIONS(137), + [anon_sym_mut] = ACTIONS(137), + [anon_sym_COLON] = ACTIONS(139), + [anon_sym_fn] = ACTIONS(141), + [anon_sym_LT] = ACTIONS(137), + [anon_sym_GT] = ACTIONS(137), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(137), + [anon_sym_type] = ACTIONS(137), + [anon_sym_PIPE] = ACTIONS(143), + [anon_sym_effect] = ACTIONS(137), + [anon_sym_BANG] = ACTIONS(145), + [anon_sym_LBRACK] = ACTIONS(147), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_QMARK] = ACTIONS(139), + [anon_sym_PIPE_PIPE] = ACTIONS(139), + [anon_sym_AMP_AMP] = ACTIONS(139), + [anon_sym_EQ_EQ] = ACTIONS(139), + [anon_sym_BANG_EQ] = ACTIONS(139), + [anon_sym_LT_EQ] = ACTIONS(139), + [anon_sym_GT_EQ] = ACTIONS(139), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_SLASH] = ACTIONS(137), + [anon_sym_PERCENT] = ACTIONS(139), + [anon_sym_await] = ACTIONS(105), + [anon_sym_PIPE_GT] = ACTIONS(139), + [anon_sym_LBRACK2] = ACTIONS(139), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(137), + [anon_sym_module] = ACTIONS(137), + [anon_sym_signature] = ACTIONS(137), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(139), [sym_line_comment] = ACTIONS(3), }, [6] = { - [sym_expression] = STATE(442), - [sym_match_expression] = STATE(338), - [sym_if_expression] = STATE(338), - [sym_handler_expression] = STATE(338), - [sym_select_expression] = STATE(338), - [sym_ternary_expression] = STATE(338), - [sym_binary_expression] = STATE(338), - [sym_unary_expression] = STATE(338), - [sym_pipe_expression] = STATE(338), - [sym_call_expression] = STATE(338), - [sym_primary_expression] = STATE(338), - [sym_spawn_expression] = STATE(283), - [sym_yield_expression] = STATE(283), - [sym_await_call] = STATE(283), - [sym_send_call] = STATE(283), - [sym_recv_call] = STATE(283), - [sym_perform_expression] = STATE(283), - [sym_resume_expression] = STATE(283), - [sym_type_constructor] = STATE(283), - [sym_update_expression] = STATE(283), - [sym_block] = STATE(283), - [sym_object_literal] = STATE(283), - [sym_lambda_expression] = STATE(283), - [sym_literal] = STATE(283), - [sym_list_literal] = STATE(332), - [sym_map_literal] = STATE(332), - [sym_boolean] = STATE(332), - [ts_builtin_sym_end] = ACTIONS(67), - [sym_identifier] = ACTIONS(137), - [anon_sym_import] = ACTIONS(65), - [anon_sym_DOT] = ACTIONS(67), - [anon_sym_let] = ACTIONS(65), - [anon_sym_mut] = ACTIONS(65), - [anon_sym_fn] = ACTIONS(139), - [anon_sym_LT] = ACTIONS(65), - [anon_sym_GT] = ACTIONS(65), - [anon_sym_LPAREN] = ACTIONS(15), - [anon_sym_extern] = ACTIONS(65), - [anon_sym_type] = ACTIONS(65), - [anon_sym_PIPE] = ACTIONS(141), - [anon_sym_LBRACE] = ACTIONS(23), - [anon_sym_effect] = ACTIONS(65), - [anon_sym_BANG] = ACTIONS(143), - [anon_sym_LBRACK] = ACTIONS(145), - [anon_sym_match] = ACTIONS(31), - [anon_sym_if] = ACTIONS(33), - [anon_sym_handle] = ACTIONS(35), - [anon_sym_select] = ACTIONS(37), - [anon_sym_QMARK] = ACTIONS(67), - [anon_sym_PIPE_PIPE] = ACTIONS(67), - [anon_sym_AMP_AMP] = ACTIONS(67), - [anon_sym_EQ_EQ] = ACTIONS(67), - [anon_sym_BANG_EQ] = ACTIONS(67), - [anon_sym_LT_EQ] = ACTIONS(67), - [anon_sym_GT_EQ] = ACTIONS(67), - [anon_sym_PLUS] = ACTIONS(27), - [anon_sym_DASH] = ACTIONS(27), - [anon_sym_STAR] = ACTIONS(67), - [anon_sym_SLASH] = ACTIONS(65), - [anon_sym_PERCENT] = ACTIONS(67), - [anon_sym_await] = ACTIONS(39), - [anon_sym_PIPE_GT] = ACTIONS(67), - [anon_sym_LBRACK2] = ACTIONS(67), - [anon_sym_spawn] = ACTIONS(41), - [anon_sym_yield] = ACTIONS(43), - [anon_sym_send] = ACTIONS(45), - [anon_sym_recv] = ACTIONS(47), - [anon_sym_perform] = ACTIONS(49), - [anon_sym_resume] = ACTIONS(51), - [anon_sym_module] = ACTIONS(65), - [anon_sym_true] = ACTIONS(55), - [anon_sym_false] = ACTIONS(55), - [sym_float] = ACTIONS(57), - [sym_integer] = ACTIONS(59), - [sym_string] = ACTIONS(59), - [sym_interpolated_string] = ACTIONS(59), + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(460), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(151), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [7] = { - [sym_statement] = STATE(8), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(384), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(8), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(147), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(149), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(459), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(153), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [8] = { [sym_statement] = STATE(8), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(394), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), + [sym_import_statement] = STATE(617), + [sym_namespace_declaration] = STATE(617), + [sym_let_declaration] = STATE(617), + [sym_assignment] = STATE(617), + [sym_function_declaration] = STATE(617), + [sym_extern_declaration] = STATE(617), + [sym_type_declaration] = STATE(617), + [sym_effect_declaration] = STATE(617), + [sym_expression_statement] = STATE(617), + [sym_expression] = STATE(379), + [sym_match_expression] = STATE(60), + [sym_if_expression] = STATE(60), + [sym_handler_expression] = STATE(60), + [sym_select_expression] = STATE(60), + [sym_ternary_expression] = STATE(60), + [sym_binary_expression] = STATE(60), + [sym_unary_expression] = STATE(60), + [sym_pipe_expression] = STATE(60), + [sym_call_expression] = STATE(60), + [sym_primary_expression] = STATE(60), + [sym_spawn_expression] = STATE(62), + [sym_yield_expression] = STATE(62), + [sym_await_call] = STATE(62), + [sym_send_call] = STATE(62), + [sym_recv_call] = STATE(62), + [sym_perform_expression] = STATE(62), + [sym_resume_expression] = STATE(62), + [sym_type_constructor] = STATE(62), + [sym_update_expression] = STATE(62), + [sym_block] = STATE(62), + [sym_object_literal] = STATE(62), + [sym_lambda_expression] = STATE(62), + [sym_literal] = STATE(62), + [sym_list_literal] = STATE(78), + [sym_map_literal] = STATE(78), + [sym_module_declaration] = STATE(617), + [sym_signature_declaration] = STATE(617), + [sym_qualified_path] = STATE(39), + [sym_boolean] = STATE(78), + [sym_doc_comment] = STATE(1013), [aux_sym_source_file_repeat1] = STATE(8), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(151), - [anon_sym_import] = ACTIONS(154), - [anon_sym_let] = ACTIONS(157), - [anon_sym_mut] = ACTIONS(157), - [anon_sym_fn] = ACTIONS(160), - [anon_sym_LPAREN] = ACTIONS(163), - [anon_sym_extern] = ACTIONS(166), - [anon_sym_type] = ACTIONS(169), - [anon_sym_PIPE] = ACTIONS(172), - [anon_sym_LBRACE] = ACTIONS(175), - [anon_sym_RBRACE] = ACTIONS(178), - [anon_sym_effect] = ACTIONS(180), - [anon_sym_BANG] = ACTIONS(183), - [anon_sym_LBRACK] = ACTIONS(186), - [anon_sym_match] = ACTIONS(189), - [anon_sym_if] = ACTIONS(192), - [anon_sym_handle] = ACTIONS(195), - [anon_sym_select] = ACTIONS(198), - [anon_sym_PLUS] = ACTIONS(183), - [anon_sym_DASH] = ACTIONS(183), - [anon_sym_await] = ACTIONS(201), - [anon_sym_spawn] = ACTIONS(204), - [anon_sym_yield] = ACTIONS(207), - [anon_sym_send] = ACTIONS(210), - [anon_sym_recv] = ACTIONS(213), - [anon_sym_perform] = ACTIONS(216), - [anon_sym_resume] = ACTIONS(219), - [anon_sym_module] = ACTIONS(222), - [anon_sym_true] = ACTIONS(225), - [anon_sym_false] = ACTIONS(225), - [sym_float] = ACTIONS(228), - [sym_integer] = ACTIONS(231), - [sym_string] = ACTIONS(231), - [sym_interpolated_string] = ACTIONS(231), - [sym__doc_comment_line] = ACTIONS(234), + [aux_sym_doc_comment_repeat1] = STATE(968), + [ts_builtin_sym_end] = ACTIONS(155), + [sym_identifier] = ACTIONS(157), + [anon_sym_import] = ACTIONS(160), + [anon_sym_LBRACE] = ACTIONS(163), + [anon_sym_namespace] = ACTIONS(166), + [anon_sym_let] = ACTIONS(169), + [anon_sym_mut] = ACTIONS(169), + [anon_sym_fn] = ACTIONS(172), + [anon_sym_LPAREN] = ACTIONS(175), + [anon_sym_extern] = ACTIONS(178), + [anon_sym_type] = ACTIONS(181), + [anon_sym_PIPE] = ACTIONS(184), + [anon_sym_effect] = ACTIONS(187), + [anon_sym_BANG] = ACTIONS(190), + [anon_sym_LBRACK] = ACTIONS(193), + [anon_sym_match] = ACTIONS(196), + [anon_sym_if] = ACTIONS(199), + [anon_sym_handle] = ACTIONS(202), + [anon_sym_select] = ACTIONS(205), + [anon_sym_PLUS] = ACTIONS(190), + [anon_sym_DASH] = ACTIONS(190), + [anon_sym_await] = ACTIONS(208), + [anon_sym_spawn] = ACTIONS(211), + [anon_sym_yield] = ACTIONS(214), + [anon_sym_send] = ACTIONS(217), + [anon_sym_recv] = ACTIONS(220), + [anon_sym_perform] = ACTIONS(223), + [anon_sym_resume] = ACTIONS(226), + [anon_sym_state] = ACTIONS(229), + [anon_sym_module] = ACTIONS(232), + [anon_sym_signature] = ACTIONS(235), + [anon_sym_true] = ACTIONS(238), + [anon_sym_false] = ACTIONS(238), + [sym_float] = ACTIONS(241), + [sym_integer] = ACTIONS(244), + [sym_string] = ACTIONS(244), + [sym_interpolated_string] = ACTIONS(244), + [sym__doc_comment_line] = ACTIONS(247), [sym_line_comment] = ACTIONS(3), }, [9] = { - [sym_statement] = STATE(9), - [sym_import_statement] = STATE(616), - [sym_let_declaration] = STATE(616), - [sym_assignment] = STATE(616), - [sym_function_declaration] = STATE(616), - [sym_extern_declaration] = STATE(616), - [sym_type_declaration] = STATE(616), - [sym_effect_declaration] = STATE(616), - [sym_expression_statement] = STATE(616), - [sym_expression] = STATE(451), - [sym_match_expression] = STATE(338), - [sym_if_expression] = STATE(338), - [sym_handler_expression] = STATE(338), - [sym_select_expression] = STATE(338), - [sym_ternary_expression] = STATE(338), - [sym_binary_expression] = STATE(338), - [sym_unary_expression] = STATE(338), - [sym_pipe_expression] = STATE(338), - [sym_call_expression] = STATE(338), - [sym_primary_expression] = STATE(338), - [sym_spawn_expression] = STATE(283), - [sym_yield_expression] = STATE(283), - [sym_await_call] = STATE(283), - [sym_send_call] = STATE(283), - [sym_recv_call] = STATE(283), - [sym_perform_expression] = STATE(283), - [sym_resume_expression] = STATE(283), - [sym_type_constructor] = STATE(283), - [sym_update_expression] = STATE(283), - [sym_block] = STATE(283), - [sym_object_literal] = STATE(283), - [sym_lambda_expression] = STATE(283), - [sym_literal] = STATE(283), - [sym_list_literal] = STATE(332), - [sym_map_literal] = STATE(332), - [sym_module_declaration] = STATE(616), - [sym_boolean] = STATE(332), - [sym_doc_comment] = STATE(894), - [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(824), - [ts_builtin_sym_end] = ACTIONS(178), - [sym_identifier] = ACTIONS(237), - [anon_sym_import] = ACTIONS(240), - [anon_sym_let] = ACTIONS(243), - [anon_sym_mut] = ACTIONS(243), - [anon_sym_fn] = ACTIONS(246), - [anon_sym_LPAREN] = ACTIONS(249), - [anon_sym_extern] = ACTIONS(252), - [anon_sym_type] = ACTIONS(255), - [anon_sym_PIPE] = ACTIONS(258), - [anon_sym_LBRACE] = ACTIONS(261), - [anon_sym_effect] = ACTIONS(264), - [anon_sym_BANG] = ACTIONS(267), - [anon_sym_LBRACK] = ACTIONS(270), - [anon_sym_match] = ACTIONS(273), - [anon_sym_if] = ACTIONS(276), - [anon_sym_handle] = ACTIONS(279), - [anon_sym_select] = ACTIONS(282), - [anon_sym_PLUS] = ACTIONS(267), - [anon_sym_DASH] = ACTIONS(267), - [anon_sym_await] = ACTIONS(285), - [anon_sym_spawn] = ACTIONS(288), - [anon_sym_yield] = ACTIONS(291), - [anon_sym_send] = ACTIONS(294), - [anon_sym_recv] = ACTIONS(297), - [anon_sym_perform] = ACTIONS(300), - [anon_sym_resume] = ACTIONS(303), - [anon_sym_module] = ACTIONS(306), - [anon_sym_true] = ACTIONS(309), - [anon_sym_false] = ACTIONS(309), - [sym_float] = ACTIONS(312), - [sym_integer] = ACTIONS(315), - [sym_string] = ACTIONS(315), - [sym_interpolated_string] = ACTIONS(315), - [sym__doc_comment_line] = ACTIONS(234), + [sym_statement] = STATE(10), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(438), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(10), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(250), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [10] = { - [sym_statement] = STATE(9), - [sym_import_statement] = STATE(616), - [sym_let_declaration] = STATE(616), - [sym_assignment] = STATE(616), - [sym_function_declaration] = STATE(616), - [sym_extern_declaration] = STATE(616), - [sym_type_declaration] = STATE(616), - [sym_effect_declaration] = STATE(616), - [sym_expression_statement] = STATE(616), - [sym_expression] = STATE(451), - [sym_match_expression] = STATE(338), - [sym_if_expression] = STATE(338), - [sym_handler_expression] = STATE(338), - [sym_select_expression] = STATE(338), - [sym_ternary_expression] = STATE(338), - [sym_binary_expression] = STATE(338), - [sym_unary_expression] = STATE(338), - [sym_pipe_expression] = STATE(338), - [sym_call_expression] = STATE(338), - [sym_primary_expression] = STATE(338), - [sym_spawn_expression] = STATE(283), - [sym_yield_expression] = STATE(283), - [sym_await_call] = STATE(283), - [sym_send_call] = STATE(283), - [sym_recv_call] = STATE(283), - [sym_perform_expression] = STATE(283), - [sym_resume_expression] = STATE(283), - [sym_type_constructor] = STATE(283), - [sym_update_expression] = STATE(283), - [sym_block] = STATE(283), - [sym_object_literal] = STATE(283), - [sym_lambda_expression] = STATE(283), - [sym_literal] = STATE(283), - [sym_list_literal] = STATE(332), - [sym_map_literal] = STATE(332), - [sym_module_declaration] = STATE(616), - [sym_boolean] = STATE(332), - [sym_doc_comment] = STATE(894), - [aux_sym_source_file_repeat1] = STATE(9), - [aux_sym_doc_comment_repeat1] = STATE(824), - [ts_builtin_sym_end] = ACTIONS(318), - [sym_identifier] = ACTIONS(7), - [anon_sym_import] = ACTIONS(9), - [anon_sym_let] = ACTIONS(11), - [anon_sym_mut] = ACTIONS(11), - [anon_sym_fn] = ACTIONS(13), - [anon_sym_LPAREN] = ACTIONS(15), - [anon_sym_extern] = ACTIONS(17), - [anon_sym_type] = ACTIONS(19), - [anon_sym_PIPE] = ACTIONS(21), - [anon_sym_LBRACE] = ACTIONS(23), - [anon_sym_effect] = ACTIONS(25), - [anon_sym_BANG] = ACTIONS(27), - [anon_sym_LBRACK] = ACTIONS(29), - [anon_sym_match] = ACTIONS(31), - [anon_sym_if] = ACTIONS(33), - [anon_sym_handle] = ACTIONS(35), - [anon_sym_select] = ACTIONS(37), - [anon_sym_PLUS] = ACTIONS(27), - [anon_sym_DASH] = ACTIONS(27), - [anon_sym_await] = ACTIONS(39), - [anon_sym_spawn] = ACTIONS(41), - [anon_sym_yield] = ACTIONS(43), - [anon_sym_send] = ACTIONS(45), - [anon_sym_recv] = ACTIONS(47), - [anon_sym_perform] = ACTIONS(49), - [anon_sym_resume] = ACTIONS(51), - [anon_sym_module] = ACTIONS(53), - [anon_sym_true] = ACTIONS(55), - [anon_sym_false] = ACTIONS(55), - [sym_float] = ACTIONS(57), - [sym_integer] = ACTIONS(59), - [sym_string] = ACTIONS(59), - [sym_interpolated_string] = ACTIONS(59), - [sym__doc_comment_line] = ACTIONS(61), + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(438), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(252), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [11] = { - [sym_statement] = STATE(16), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(357), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(16), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(147), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(320), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [sym_statement] = STATE(7), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(404), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(7), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(254), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [12] = { - [sym_expression] = STATE(650), - [sym_match_expression] = STATE(622), - [sym_if_expression] = STATE(622), - [sym_handler_expression] = STATE(622), - [sym_select_expression] = STATE(622), - [sym_ternary_expression] = STATE(622), - [sym_binary_expression] = STATE(622), - [sym_unary_expression] = STATE(622), - [sym_pipe_expression] = STATE(622), - [sym_call_expression] = STATE(622), - [sym_primary_expression] = STATE(622), - [sym_spawn_expression] = STATE(634), - [sym_yield_expression] = STATE(634), - [sym_await_call] = STATE(634), - [sym_send_call] = STATE(634), - [sym_recv_call] = STATE(634), - [sym_perform_expression] = STATE(634), - [sym_resume_expression] = STATE(634), - [sym_type_constructor] = STATE(634), - [sym_update_expression] = STATE(634), - [sym_block] = STATE(634), - [sym_object_literal] = STATE(634), - [sym_lambda_expression] = STATE(634), - [sym_literal] = STATE(634), - [sym_list_literal] = STATE(633), - [sym_map_literal] = STATE(633), - [sym_boolean] = STATE(633), - [sym_identifier] = ACTIONS(322), - [anon_sym_DOT] = ACTIONS(67), - [anon_sym_COLON] = ACTIONS(67), - [anon_sym_fn] = ACTIONS(324), - [anon_sym_LT] = ACTIONS(65), - [anon_sym_GT] = ACTIONS(65), - [anon_sym_LPAREN] = ACTIONS(326), - [anon_sym_RPAREN] = ACTIONS(67), - [anon_sym_COMMA] = ACTIONS(67), - [anon_sym_in] = ACTIONS(65), - [anon_sym_PIPE] = ACTIONS(328), - [anon_sym_LBRACE] = ACTIONS(330), - [anon_sym_RBRACE] = ACTIONS(67), - [anon_sym_BANG] = ACTIONS(332), - [anon_sym_LBRACK] = ACTIONS(334), - [anon_sym_RBRACK] = ACTIONS(67), - [anon_sym_match] = ACTIONS(336), - [anon_sym_if] = ACTIONS(338), - [anon_sym_handle] = ACTIONS(340), - [anon_sym_select] = ACTIONS(342), - [anon_sym_QMARK] = ACTIONS(67), - [anon_sym_PIPE_PIPE] = ACTIONS(67), - [anon_sym_AMP_AMP] = ACTIONS(67), - [anon_sym_EQ_EQ] = ACTIONS(67), - [anon_sym_BANG_EQ] = ACTIONS(67), - [anon_sym_LT_EQ] = ACTIONS(67), - [anon_sym_GT_EQ] = ACTIONS(67), - [anon_sym_PLUS] = ACTIONS(344), - [anon_sym_DASH] = ACTIONS(344), - [anon_sym_STAR] = ACTIONS(67), - [anon_sym_SLASH] = ACTIONS(65), - [anon_sym_PERCENT] = ACTIONS(67), - [anon_sym_await] = ACTIONS(346), - [anon_sym_PIPE_GT] = ACTIONS(67), - [anon_sym_LBRACK2] = ACTIONS(67), - [anon_sym_spawn] = ACTIONS(348), - [anon_sym_yield] = ACTIONS(350), - [anon_sym_send] = ACTIONS(352), - [anon_sym_recv] = ACTIONS(354), - [anon_sym_perform] = ACTIONS(356), - [anon_sym_resume] = ACTIONS(358), - [anon_sym__] = ACTIONS(65), - [anon_sym_true] = ACTIONS(360), - [anon_sym_false] = ACTIONS(360), - [sym_float] = ACTIONS(362), - [sym_integer] = ACTIONS(364), - [sym_string] = ACTIONS(364), - [sym_interpolated_string] = ACTIONS(364), - [sym_line_comment] = ACTIONS(366), - }, - [13] = { [sym_statement] = STATE(8), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(450), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), + [sym_import_statement] = STATE(617), + [sym_namespace_declaration] = STATE(617), + [sym_let_declaration] = STATE(617), + [sym_assignment] = STATE(617), + [sym_function_declaration] = STATE(617), + [sym_extern_declaration] = STATE(617), + [sym_type_declaration] = STATE(617), + [sym_effect_declaration] = STATE(617), + [sym_expression_statement] = STATE(617), + [sym_expression] = STATE(379), + [sym_match_expression] = STATE(60), + [sym_if_expression] = STATE(60), + [sym_handler_expression] = STATE(60), + [sym_select_expression] = STATE(60), + [sym_ternary_expression] = STATE(60), + [sym_binary_expression] = STATE(60), + [sym_unary_expression] = STATE(60), + [sym_pipe_expression] = STATE(60), + [sym_call_expression] = STATE(60), + [sym_primary_expression] = STATE(60), + [sym_spawn_expression] = STATE(62), + [sym_yield_expression] = STATE(62), + [sym_await_call] = STATE(62), + [sym_send_call] = STATE(62), + [sym_recv_call] = STATE(62), + [sym_perform_expression] = STATE(62), + [sym_resume_expression] = STATE(62), + [sym_type_constructor] = STATE(62), + [sym_update_expression] = STATE(62), + [sym_block] = STATE(62), + [sym_object_literal] = STATE(62), + [sym_lambda_expression] = STATE(62), + [sym_literal] = STATE(62), + [sym_list_literal] = STATE(78), + [sym_map_literal] = STATE(78), + [sym_module_declaration] = STATE(617), + [sym_signature_declaration] = STATE(617), + [sym_qualified_path] = STATE(39), + [sym_boolean] = STATE(78), + [sym_doc_comment] = STATE(1013), [aux_sym_source_file_repeat1] = STATE(8), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(147), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(368), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [aux_sym_doc_comment_repeat1] = STATE(968), + [ts_builtin_sym_end] = ACTIONS(256), + [sym_identifier] = ACTIONS(7), + [anon_sym_import] = ACTIONS(9), + [anon_sym_LBRACE] = ACTIONS(11), + [anon_sym_namespace] = ACTIONS(13), + [anon_sym_let] = ACTIONS(15), + [anon_sym_mut] = ACTIONS(15), + [anon_sym_fn] = ACTIONS(17), + [anon_sym_LPAREN] = ACTIONS(19), + [anon_sym_extern] = ACTIONS(21), + [anon_sym_type] = ACTIONS(23), + [anon_sym_PIPE] = ACTIONS(25), + [anon_sym_effect] = ACTIONS(27), + [anon_sym_BANG] = ACTIONS(29), + [anon_sym_LBRACK] = ACTIONS(31), + [anon_sym_match] = ACTIONS(33), + [anon_sym_if] = ACTIONS(35), + [anon_sym_handle] = ACTIONS(37), + [anon_sym_select] = ACTIONS(39), + [anon_sym_PLUS] = ACTIONS(29), + [anon_sym_DASH] = ACTIONS(29), + [anon_sym_await] = ACTIONS(41), + [anon_sym_spawn] = ACTIONS(43), + [anon_sym_yield] = ACTIONS(45), + [anon_sym_send] = ACTIONS(47), + [anon_sym_recv] = ACTIONS(49), + [anon_sym_perform] = ACTIONS(51), + [anon_sym_resume] = ACTIONS(53), + [anon_sym_state] = ACTIONS(55), + [anon_sym_module] = ACTIONS(57), + [anon_sym_signature] = ACTIONS(59), + [anon_sym_true] = ACTIONS(61), + [anon_sym_false] = ACTIONS(61), + [sym_float] = ACTIONS(63), + [sym_integer] = ACTIONS(65), + [sym_string] = ACTIONS(65), + [sym_interpolated_string] = ACTIONS(65), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, - [14] = { - [sym_statement] = STATE(8), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(445), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(8), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(147), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(370), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [13] = { + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(438), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(258), + [anon_sym_import] = ACTIONS(261), + [anon_sym_LBRACE] = ACTIONS(264), + [anon_sym_RBRACE] = ACTIONS(155), + [anon_sym_namespace] = ACTIONS(267), + [anon_sym_let] = ACTIONS(270), + [anon_sym_mut] = ACTIONS(270), + [anon_sym_fn] = ACTIONS(273), + [anon_sym_LPAREN] = ACTIONS(276), + [anon_sym_extern] = ACTIONS(279), + [anon_sym_type] = ACTIONS(282), + [anon_sym_PIPE] = ACTIONS(285), + [anon_sym_effect] = ACTIONS(288), + [anon_sym_BANG] = ACTIONS(291), + [anon_sym_LBRACK] = ACTIONS(294), + [anon_sym_match] = ACTIONS(297), + [anon_sym_if] = ACTIONS(300), + [anon_sym_handle] = ACTIONS(303), + [anon_sym_select] = ACTIONS(306), + [anon_sym_PLUS] = ACTIONS(291), + [anon_sym_DASH] = ACTIONS(291), + [anon_sym_await] = ACTIONS(309), + [anon_sym_spawn] = ACTIONS(312), + [anon_sym_yield] = ACTIONS(315), + [anon_sym_send] = ACTIONS(318), + [anon_sym_recv] = ACTIONS(321), + [anon_sym_perform] = ACTIONS(324), + [anon_sym_resume] = ACTIONS(327), + [anon_sym_state] = ACTIONS(330), + [anon_sym_module] = ACTIONS(333), + [anon_sym_signature] = ACTIONS(336), + [anon_sym_true] = ACTIONS(339), + [anon_sym_false] = ACTIONS(339), + [sym_float] = ACTIONS(342), + [sym_integer] = ACTIONS(345), + [sym_string] = ACTIONS(345), + [sym_interpolated_string] = ACTIONS(345), + [sym__doc_comment_line] = ACTIONS(247), [sym_line_comment] = ACTIONS(3), }, - [15] = { + [14] = { [sym_statement] = STATE(13), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(446), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(453), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), [aux_sym_source_file_repeat1] = STATE(13), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(147), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(372), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(348), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), + [sym_line_comment] = ACTIONS(3), + }, + [15] = { + [sym_statement] = STATE(17), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(438), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(17), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(350), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [16] = { - [sym_statement] = STATE(8), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(449), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(8), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(147), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(374), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [sym_statement] = STATE(6), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(455), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(6), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(352), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [17] = { - [sym_statement] = STATE(8), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(448), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(8), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(147), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(376), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(438), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(354), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [18] = { - [sym_statement] = STATE(7), - [sym_import_statement] = STATE(534), - [sym_let_declaration] = STATE(534), - [sym_assignment] = STATE(534), - [sym_function_declaration] = STATE(534), - [sym_extern_declaration] = STATE(534), - [sym_type_declaration] = STATE(534), - [sym_effect_declaration] = STATE(534), - [sym_expression_statement] = STATE(534), - [sym_expression] = STATE(453), - [sym_match_expression] = STATE(342), - [sym_if_expression] = STATE(342), - [sym_handler_expression] = STATE(342), - [sym_select_expression] = STATE(342), - [sym_ternary_expression] = STATE(342), - [sym_binary_expression] = STATE(342), - [sym_unary_expression] = STATE(342), - [sym_pipe_expression] = STATE(342), - [sym_call_expression] = STATE(342), - [sym_primary_expression] = STATE(342), - [sym_spawn_expression] = STATE(343), - [sym_yield_expression] = STATE(343), - [sym_await_call] = STATE(343), - [sym_send_call] = STATE(343), - [sym_recv_call] = STATE(343), - [sym_perform_expression] = STATE(343), - [sym_resume_expression] = STATE(343), - [sym_type_constructor] = STATE(343), - [sym_update_expression] = STATE(343), - [sym_block] = STATE(343), - [sym_object_literal] = STATE(343), - [sym_lambda_expression] = STATE(343), - [sym_literal] = STATE(343), - [sym_list_literal] = STATE(341), - [sym_map_literal] = STATE(341), - [sym_module_declaration] = STATE(534), - [sym_boolean] = STATE(341), - [sym_doc_comment] = STATE(893), - [aux_sym_source_file_repeat1] = STATE(7), - [aux_sym_doc_comment_repeat1] = STATE(824), - [sym_identifier] = ACTIONS(147), - [anon_sym_import] = ACTIONS(113), - [anon_sym_let] = ACTIONS(115), - [anon_sym_mut] = ACTIONS(115), - [anon_sym_fn] = ACTIONS(117), - [anon_sym_LPAREN] = ACTIONS(71), - [anon_sym_extern] = ACTIONS(119), - [anon_sym_type] = ACTIONS(121), - [anon_sym_PIPE] = ACTIONS(123), - [anon_sym_LBRACE] = ACTIONS(75), - [anon_sym_RBRACE] = ACTIONS(320), - [anon_sym_effect] = ACTIONS(127), - [anon_sym_BANG] = ACTIONS(89), - [anon_sym_LBRACK] = ACTIONS(129), - [anon_sym_match] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_handle] = ACTIONS(85), - [anon_sym_select] = ACTIONS(87), - [anon_sym_PLUS] = ACTIONS(89), - [anon_sym_DASH] = ACTIONS(89), - [anon_sym_await] = ACTIONS(91), - [anon_sym_spawn] = ACTIONS(93), - [anon_sym_yield] = ACTIONS(95), - [anon_sym_send] = ACTIONS(97), - [anon_sym_recv] = ACTIONS(99), - [anon_sym_perform] = ACTIONS(101), - [anon_sym_resume] = ACTIONS(103), - [anon_sym_module] = ACTIONS(131), - [anon_sym_true] = ACTIONS(105), - [anon_sym_false] = ACTIONS(105), - [sym_float] = ACTIONS(107), - [sym_integer] = ACTIONS(109), - [sym_string] = ACTIONS(109), - [sym_interpolated_string] = ACTIONS(109), - [sym__doc_comment_line] = ACTIONS(61), + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(446), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(356), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, [19] = { - [sym_expression] = STATE(688), - [sym_match_expression] = STATE(338), - [sym_if_expression] = STATE(338), - [sym_handler_expression] = STATE(338), - [sym_select_expression] = STATE(338), - [sym_ternary_expression] = STATE(338), - [sym_binary_expression] = STATE(338), - [sym_unary_expression] = STATE(338), - [sym_pipe_expression] = STATE(338), - [sym_call_expression] = STATE(338), - [sym_primary_expression] = STATE(338), - [sym_spawn_expression] = STATE(283), - [sym_yield_expression] = STATE(283), - [sym_await_call] = STATE(283), - [sym_send_call] = STATE(283), - [sym_recv_call] = STATE(283), - [sym_perform_expression] = STATE(283), - [sym_resume_expression] = STATE(283), - [sym_type_constructor] = STATE(283), - [sym_update_expression] = STATE(283), - [sym_block] = STATE(283), - [sym_object_literal] = STATE(283), - [sym_lambda_expression] = STATE(283), - [sym_literal] = STATE(283), - [sym_list_literal] = STATE(332), - [sym_map_literal] = STATE(332), - [sym_boolean] = STATE(332), - [sym_identifier] = ACTIONS(137), - [anon_sym_DOT] = ACTIONS(67), - [anon_sym_let] = ACTIONS(65), - [anon_sym_mut] = ACTIONS(65), - [anon_sym_fn] = ACTIONS(378), - [anon_sym_LT] = ACTIONS(65), - [anon_sym_GT] = ACTIONS(65), - [anon_sym_LPAREN] = ACTIONS(15), - [anon_sym_type] = ACTIONS(65), - [anon_sym_PIPE] = ACTIONS(380), - [anon_sym_LBRACE] = ACTIONS(23), - [anon_sym_RBRACE] = ACTIONS(67), - [anon_sym_BANG] = ACTIONS(382), - [anon_sym_LBRACK] = ACTIONS(145), - [anon_sym_match] = ACTIONS(31), - [anon_sym_if] = ACTIONS(33), - [anon_sym_handle] = ACTIONS(384), - [anon_sym_select] = ACTIONS(37), - [anon_sym_QMARK] = ACTIONS(67), - [anon_sym_PIPE_PIPE] = ACTIONS(67), - [anon_sym_AMP_AMP] = ACTIONS(67), - [anon_sym_EQ_EQ] = ACTIONS(67), - [anon_sym_BANG_EQ] = ACTIONS(67), - [anon_sym_LT_EQ] = ACTIONS(67), - [anon_sym_GT_EQ] = ACTIONS(67), - [anon_sym_PLUS] = ACTIONS(386), - [anon_sym_DASH] = ACTIONS(386), - [anon_sym_STAR] = ACTIONS(67), - [anon_sym_SLASH] = ACTIONS(65), - [anon_sym_PERCENT] = ACTIONS(67), - [anon_sym_await] = ACTIONS(388), - [anon_sym_PIPE_GT] = ACTIONS(67), - [anon_sym_LBRACK2] = ACTIONS(67), - [anon_sym_spawn] = ACTIONS(390), - [anon_sym_yield] = ACTIONS(392), - [anon_sym_send] = ACTIONS(45), - [anon_sym_recv] = ACTIONS(47), - [anon_sym_perform] = ACTIONS(49), - [anon_sym_resume] = ACTIONS(51), - [anon_sym_true] = ACTIONS(55), - [anon_sym_false] = ACTIONS(55), - [sym_float] = ACTIONS(57), - [sym_integer] = ACTIONS(59), - [sym_string] = ACTIONS(59), - [sym_interpolated_string] = ACTIONS(59), + [sym_expression] = STATE(444), + [sym_match_expression] = STATE(60), + [sym_if_expression] = STATE(60), + [sym_handler_expression] = STATE(60), + [sym_select_expression] = STATE(60), + [sym_ternary_expression] = STATE(60), + [sym_binary_expression] = STATE(60), + [sym_unary_expression] = STATE(60), + [sym_pipe_expression] = STATE(60), + [sym_call_expression] = STATE(60), + [sym_primary_expression] = STATE(60), + [sym_spawn_expression] = STATE(62), + [sym_yield_expression] = STATE(62), + [sym_await_call] = STATE(62), + [sym_send_call] = STATE(62), + [sym_recv_call] = STATE(62), + [sym_perform_expression] = STATE(62), + [sym_resume_expression] = STATE(62), + [sym_type_constructor] = STATE(62), + [sym_update_expression] = STATE(62), + [sym_block] = STATE(62), + [sym_object_literal] = STATE(62), + [sym_lambda_expression] = STATE(62), + [sym_literal] = STATE(62), + [sym_list_literal] = STATE(78), + [sym_map_literal] = STATE(78), + [sym_qualified_path] = STATE(39), + [sym_boolean] = STATE(78), + [ts_builtin_sym_end] = ACTIONS(139), + [sym_identifier] = ACTIONS(358), + [anon_sym_import] = ACTIONS(137), + [anon_sym_DOT] = ACTIONS(139), + [anon_sym_LBRACE] = ACTIONS(11), + [anon_sym_STAR] = ACTIONS(139), + [anon_sym_namespace] = ACTIONS(137), + [anon_sym_let] = ACTIONS(137), + [anon_sym_mut] = ACTIONS(137), + [anon_sym_fn] = ACTIONS(360), + [anon_sym_LT] = ACTIONS(137), + [anon_sym_GT] = ACTIONS(137), + [anon_sym_LPAREN] = ACTIONS(19), + [anon_sym_extern] = ACTIONS(137), + [anon_sym_type] = ACTIONS(137), + [anon_sym_PIPE] = ACTIONS(362), + [anon_sym_effect] = ACTIONS(137), + [anon_sym_BANG] = ACTIONS(364), + [anon_sym_LBRACK] = ACTIONS(366), + [anon_sym_match] = ACTIONS(33), + [anon_sym_if] = ACTIONS(35), + [anon_sym_handle] = ACTIONS(37), + [anon_sym_select] = ACTIONS(39), + [anon_sym_QMARK] = ACTIONS(139), + [anon_sym_PIPE_PIPE] = ACTIONS(139), + [anon_sym_AMP_AMP] = ACTIONS(139), + [anon_sym_EQ_EQ] = ACTIONS(139), + [anon_sym_BANG_EQ] = ACTIONS(139), + [anon_sym_LT_EQ] = ACTIONS(139), + [anon_sym_GT_EQ] = ACTIONS(139), + [anon_sym_PLUS] = ACTIONS(29), + [anon_sym_DASH] = ACTIONS(29), + [anon_sym_SLASH] = ACTIONS(137), + [anon_sym_PERCENT] = ACTIONS(139), + [anon_sym_await] = ACTIONS(41), + [anon_sym_PIPE_GT] = ACTIONS(139), + [anon_sym_LBRACK2] = ACTIONS(139), + [anon_sym_spawn] = ACTIONS(43), + [anon_sym_yield] = ACTIONS(45), + [anon_sym_send] = ACTIONS(47), + [anon_sym_recv] = ACTIONS(49), + [anon_sym_perform] = ACTIONS(51), + [anon_sym_resume] = ACTIONS(53), + [anon_sym_state] = ACTIONS(137), + [anon_sym_module] = ACTIONS(137), + [anon_sym_signature] = ACTIONS(137), + [anon_sym_true] = ACTIONS(61), + [anon_sym_false] = ACTIONS(61), + [sym_float] = ACTIONS(63), + [sym_integer] = ACTIONS(65), + [sym_string] = ACTIONS(65), + [sym_interpolated_string] = ACTIONS(65), + [sym__doc_comment_line] = ACTIONS(139), + [sym_line_comment] = ACTIONS(3), + }, + [20] = { + [sym_statement] = STATE(13), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(457), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(13), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(368), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), + [sym__doc_comment_line] = ACTIONS(67), + [sym_line_comment] = ACTIONS(3), + }, + [21] = { + [sym_statement] = STATE(18), + [sym_import_statement] = STATE(622), + [sym_namespace_declaration] = STATE(622), + [sym_let_declaration] = STATE(622), + [sym_assignment] = STATE(622), + [sym_function_declaration] = STATE(622), + [sym_extern_declaration] = STATE(622), + [sym_type_declaration] = STATE(622), + [sym_effect_declaration] = STATE(622), + [sym_expression_statement] = STATE(622), + [sym_expression] = STATE(371), + [sym_match_expression] = STATE(156), + [sym_if_expression] = STATE(156), + [sym_handler_expression] = STATE(156), + [sym_select_expression] = STATE(156), + [sym_ternary_expression] = STATE(156), + [sym_binary_expression] = STATE(156), + [sym_unary_expression] = STATE(156), + [sym_pipe_expression] = STATE(156), + [sym_call_expression] = STATE(156), + [sym_primary_expression] = STATE(156), + [sym_spawn_expression] = STATE(157), + [sym_yield_expression] = STATE(157), + [sym_await_call] = STATE(157), + [sym_send_call] = STATE(157), + [sym_recv_call] = STATE(157), + [sym_perform_expression] = STATE(157), + [sym_resume_expression] = STATE(157), + [sym_type_constructor] = STATE(157), + [sym_update_expression] = STATE(157), + [sym_block] = STATE(157), + [sym_object_literal] = STATE(157), + [sym_lambda_expression] = STATE(157), + [sym_literal] = STATE(157), + [sym_list_literal] = STATE(155), + [sym_map_literal] = STATE(155), + [sym_module_declaration] = STATE(622), + [sym_signature_declaration] = STATE(622), + [sym_qualified_path] = STATE(57), + [sym_boolean] = STATE(155), + [sym_doc_comment] = STATE(1016), + [aux_sym_source_file_repeat1] = STATE(18), + [aux_sym_doc_comment_repeat1] = STATE(968), + [sym_identifier] = ACTIONS(149), + [anon_sym_import] = ACTIONS(71), + [anon_sym_LBRACE] = ACTIONS(73), + [anon_sym_RBRACE] = ACTIONS(254), + [anon_sym_namespace] = ACTIONS(77), + [anon_sym_let] = ACTIONS(79), + [anon_sym_mut] = ACTIONS(79), + [anon_sym_fn] = ACTIONS(81), + [anon_sym_LPAREN] = ACTIONS(83), + [anon_sym_extern] = ACTIONS(85), + [anon_sym_type] = ACTIONS(87), + [anon_sym_PIPE] = ACTIONS(89), + [anon_sym_effect] = ACTIONS(91), + [anon_sym_BANG] = ACTIONS(93), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_match] = ACTIONS(97), + [anon_sym_if] = ACTIONS(99), + [anon_sym_handle] = ACTIONS(101), + [anon_sym_select] = ACTIONS(103), + [anon_sym_PLUS] = ACTIONS(93), + [anon_sym_DASH] = ACTIONS(93), + [anon_sym_await] = ACTIONS(105), + [anon_sym_spawn] = ACTIONS(107), + [anon_sym_yield] = ACTIONS(109), + [anon_sym_send] = ACTIONS(111), + [anon_sym_recv] = ACTIONS(113), + [anon_sym_perform] = ACTIONS(115), + [anon_sym_resume] = ACTIONS(117), + [anon_sym_state] = ACTIONS(119), + [anon_sym_module] = ACTIONS(121), + [anon_sym_signature] = ACTIONS(123), + [anon_sym_true] = ACTIONS(125), + [anon_sym_false] = ACTIONS(125), + [sym_float] = ACTIONS(127), + [sym_integer] = ACTIONS(129), + [sym_string] = ACTIONS(129), + [sym_interpolated_string] = ACTIONS(129), [sym__doc_comment_line] = ACTIONS(67), [sym_line_comment] = ACTIONS(3), }, + [22] = { + [sym_expression] = STATE(778), + [sym_match_expression] = STATE(60), + [sym_if_expression] = STATE(60), + [sym_handler_expression] = STATE(60), + [sym_select_expression] = STATE(60), + [sym_ternary_expression] = STATE(60), + [sym_binary_expression] = STATE(60), + [sym_unary_expression] = STATE(60), + [sym_pipe_expression] = STATE(60), + [sym_call_expression] = STATE(60), + [sym_primary_expression] = STATE(60), + [sym_spawn_expression] = STATE(62), + [sym_yield_expression] = STATE(62), + [sym_await_call] = STATE(62), + [sym_send_call] = STATE(62), + [sym_recv_call] = STATE(62), + [sym_perform_expression] = STATE(62), + [sym_resume_expression] = STATE(62), + [sym_type_constructor] = STATE(62), + [sym_update_expression] = STATE(62), + [sym_block] = STATE(62), + [sym_object_literal] = STATE(62), + [sym_lambda_expression] = STATE(62), + [sym_literal] = STATE(62), + [sym_list_literal] = STATE(78), + [sym_map_literal] = STATE(78), + [sym_qualified_path] = STATE(39), + [sym_boolean] = STATE(78), + [sym_identifier] = ACTIONS(358), + [anon_sym_DOT] = ACTIONS(139), + [anon_sym_LBRACE] = ACTIONS(11), + [anon_sym_RBRACE] = ACTIONS(139), + [anon_sym_STAR] = ACTIONS(139), + [anon_sym_let] = ACTIONS(137), + [anon_sym_mut] = ACTIONS(137), + [anon_sym_fn] = ACTIONS(370), + [anon_sym_LT] = ACTIONS(137), + [anon_sym_GT] = ACTIONS(137), + [anon_sym_LPAREN] = ACTIONS(19), + [anon_sym_extern] = ACTIONS(137), + [anon_sym_type] = ACTIONS(137), + [anon_sym_PIPE] = ACTIONS(372), + [anon_sym_effect] = ACTIONS(137), + [anon_sym_BANG] = ACTIONS(374), + [anon_sym_LBRACK] = ACTIONS(366), + [anon_sym_match] = ACTIONS(33), + [anon_sym_if] = ACTIONS(35), + [anon_sym_handle] = ACTIONS(376), + [anon_sym_select] = ACTIONS(39), + [anon_sym_QMARK] = ACTIONS(139), + [anon_sym_PIPE_PIPE] = ACTIONS(139), + [anon_sym_AMP_AMP] = ACTIONS(139), + [anon_sym_EQ_EQ] = ACTIONS(139), + [anon_sym_BANG_EQ] = ACTIONS(139), + [anon_sym_LT_EQ] = ACTIONS(139), + [anon_sym_GT_EQ] = ACTIONS(139), + [anon_sym_PLUS] = ACTIONS(378), + [anon_sym_DASH] = ACTIONS(378), + [anon_sym_SLASH] = ACTIONS(137), + [anon_sym_PERCENT] = ACTIONS(139), + [anon_sym_await] = ACTIONS(380), + [anon_sym_PIPE_GT] = ACTIONS(139), + [anon_sym_LBRACK2] = ACTIONS(139), + [anon_sym_spawn] = ACTIONS(382), + [anon_sym_yield] = ACTIONS(384), + [anon_sym_send] = ACTIONS(47), + [anon_sym_recv] = ACTIONS(49), + [anon_sym_perform] = ACTIONS(51), + [anon_sym_resume] = ACTIONS(53), + [anon_sym_state] = ACTIONS(137), + [anon_sym_module] = ACTIONS(137), + [anon_sym_export] = ACTIONS(137), + [anon_sym_signature] = ACTIONS(137), + [anon_sym_true] = ACTIONS(61), + [anon_sym_false] = ACTIONS(61), + [sym_float] = ACTIONS(63), + [sym_integer] = ACTIONS(65), + [sym_string] = ACTIONS(65), + [sym_interpolated_string] = ACTIONS(65), + [sym__doc_comment_line] = ACTIONS(139), + [sym_line_comment] = ACTIONS(3), + }, + [23] = { + [sym_expression] = STATE(729), + [sym_match_expression] = STATE(724), + [sym_if_expression] = STATE(724), + [sym_handler_expression] = STATE(724), + [sym_select_expression] = STATE(724), + [sym_ternary_expression] = STATE(724), + [sym_binary_expression] = STATE(724), + [sym_unary_expression] = STATE(724), + [sym_pipe_expression] = STATE(724), + [sym_call_expression] = STATE(724), + [sym_primary_expression] = STATE(724), + [sym_spawn_expression] = STATE(725), + [sym_yield_expression] = STATE(725), + [sym_await_call] = STATE(725), + [sym_send_call] = STATE(725), + [sym_recv_call] = STATE(725), + [sym_perform_expression] = STATE(725), + [sym_resume_expression] = STATE(725), + [sym_type_constructor] = STATE(725), + [sym_update_expression] = STATE(725), + [sym_block] = STATE(725), + [sym_object_literal] = STATE(725), + [sym_lambda_expression] = STATE(725), + [sym_literal] = STATE(725), + [sym_list_literal] = STATE(723), + [sym_map_literal] = STATE(723), + [sym_qualified_path] = STATE(721), + [sym_boolean] = STATE(723), + [sym_identifier] = ACTIONS(386), + [anon_sym_DOT] = ACTIONS(139), + [anon_sym_LBRACE] = ACTIONS(388), + [anon_sym_RBRACE] = ACTIONS(139), + [anon_sym_STAR] = ACTIONS(139), + [anon_sym_COMMA] = ACTIONS(139), + [anon_sym_COLON] = ACTIONS(139), + [anon_sym_fn] = ACTIONS(390), + [anon_sym_LT] = ACTIONS(137), + [anon_sym_GT] = ACTIONS(137), + [anon_sym_LPAREN] = ACTIONS(392), + [anon_sym_RPAREN] = ACTIONS(139), + [anon_sym_in] = ACTIONS(137), + [anon_sym_PIPE] = ACTIONS(394), + [anon_sym_BANG] = ACTIONS(396), + [anon_sym_LBRACK] = ACTIONS(398), + [anon_sym_RBRACK] = ACTIONS(139), + [anon_sym_match] = ACTIONS(400), + [anon_sym_if] = ACTIONS(402), + [anon_sym_handle] = ACTIONS(404), + [anon_sym_select] = ACTIONS(406), + [anon_sym_QMARK] = ACTIONS(139), + [anon_sym_PIPE_PIPE] = ACTIONS(139), + [anon_sym_AMP_AMP] = ACTIONS(139), + [anon_sym_EQ_EQ] = ACTIONS(139), + [anon_sym_BANG_EQ] = ACTIONS(139), + [anon_sym_LT_EQ] = ACTIONS(139), + [anon_sym_GT_EQ] = ACTIONS(139), + [anon_sym_PLUS] = ACTIONS(408), + [anon_sym_DASH] = ACTIONS(408), + [anon_sym_SLASH] = ACTIONS(137), + [anon_sym_PERCENT] = ACTIONS(139), + [anon_sym_await] = ACTIONS(410), + [anon_sym_PIPE_GT] = ACTIONS(139), + [anon_sym_LBRACK2] = ACTIONS(139), + [anon_sym_spawn] = ACTIONS(412), + [anon_sym_yield] = ACTIONS(414), + [anon_sym_send] = ACTIONS(416), + [anon_sym_recv] = ACTIONS(418), + [anon_sym_perform] = ACTIONS(420), + [anon_sym_resume] = ACTIONS(422), + [anon_sym__] = ACTIONS(137), + [anon_sym_true] = ACTIONS(424), + [anon_sym_false] = ACTIONS(424), + [sym_float] = ACTIONS(426), + [sym_integer] = ACTIONS(428), + [sym_string] = ACTIONS(428), + [sym_interpolated_string] = ACTIONS(428), + [sym_line_comment] = ACTIONS(430), + }, }; static const uint16_t ts_small_parse_table[] = { - [0] = 30, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, + [0] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(436), 1, + anon_sym_COLON_COLON, + STATE(30), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(432), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(330), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(434), 36, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [70] = 31, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(394), 1, + ACTIONS(438), 1, sym_identifier, - ACTIONS(396), 1, + ACTIONS(440), 1, anon_sym_RPAREN, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(727), 1, + STATE(721), 1, + sym_qualified_path, + STATE(866), 1, sym_expression, - STATE(1067), 1, + STATE(1379), 1, sym_named_argument, - STATE(1304), 1, + STATE(1512), 1, sym_named_argument_list, - STATE(1438), 1, + STATE(1791), 1, sym_argument_list, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -7345,7 +9194,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -7359,71 +9208,73 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [119] = 30, - ACTIONS(324), 1, + [192] = 31, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(394), 1, + ACTIONS(438), 1, sym_identifier, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(402), 1, + ACTIONS(446), 1, anon_sym_RPAREN, - STATE(727), 1, + STATE(721), 1, + sym_qualified_path, + STATE(866), 1, sym_expression, - STATE(1067), 1, + STATE(1379), 1, sym_named_argument, - STATE(1296), 1, - sym_argument_list, - STATE(1304), 1, + STATE(1512), 1, sym_named_argument_list, - ACTIONS(360), 2, + STATE(1669), 1, + sym_argument_list, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -7434,7 +9285,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -7448,160 +9299,143 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [238] = 30, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [314] = 10, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(452), 1, + anon_sym_COLON_COLON, + ACTIONS(454), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(457), 1, + anon_sym_COLON, + ACTIONS(460), 1, + anon_sym_EQ, + ACTIONS(462), 1, + anon_sym_LT, + STATE(38), 1, + aux_sym_qualified_path_repeat1, + STATE(1707), 1, + sym_type_arguments, + ACTIONS(450), 18, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(448), 33, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(394), 1, - sym_identifier, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(404), 1, - anon_sym_RPAREN, - STATE(727), 1, - sym_expression, - STATE(1067), 1, - sym_named_argument, - STATE(1304), 1, - sym_named_argument_list, - STATE(1394), 1, - sym_argument_list, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [357] = 30, - ACTIONS(324), 1, + sym_identifier, + [394] = 31, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(394), 1, + ACTIONS(438), 1, sym_identifier, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(465), 1, anon_sym_RPAREN, - STATE(727), 1, + STATE(721), 1, + sym_qualified_path, + STATE(866), 1, sym_expression, - STATE(1067), 1, + STATE(1379), 1, sym_named_argument, - STATE(1304), 1, + STATE(1512), 1, sym_named_argument_list, - STATE(1359), 1, + STATE(1787), 1, sym_argument_list, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -7612,7 +9446,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -7626,71 +9460,73 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [476] = 30, - ACTIONS(324), 1, + [516] = 31, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(394), 1, + ACTIONS(438), 1, sym_identifier, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(408), 1, + ACTIONS(467), 1, anon_sym_RPAREN, - STATE(727), 1, + STATE(721), 1, + sym_qualified_path, + STATE(866), 1, sym_expression, - STATE(1067), 1, + STATE(1379), 1, sym_named_argument, - STATE(1243), 1, - sym_argument_list, - STATE(1304), 1, + STATE(1512), 1, sym_named_argument_list, - ACTIONS(360), 2, + STATE(1516), 1, + sym_argument_list, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -7701,7 +9537,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -7715,154 +9551,138 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [595] = 30, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [638] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(473), 1, + anon_sym_COLON_COLON, + STATE(30), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(469), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(471), 36, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(394), 1, - sym_identifier, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(410), 1, - anon_sym_RPAREN, - STATE(727), 1, - sym_expression, - STATE(1067), 1, - sym_named_argument, - STATE(1264), 1, - sym_argument_list, - STATE(1304), 1, - sym_named_argument_list, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [714] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, + [708] = 31, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(438), 1, + sym_identifier, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(412), 1, - anon_sym_COLON, - STATE(764), 1, + ACTIONS(476), 1, + anon_sym_RPAREN, + STATE(721), 1, + sym_qualified_path, + STATE(866), 1, sym_expression, - ACTIONS(360), 2, + STATE(1379), 1, + sym_named_argument, + STATE(1512), 1, + sym_named_argument_list, + STATE(1559), 1, + sym_argument_list, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -7873,7 +9693,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -7887,148 +9707,141 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [824] = 27, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [830] = 8, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(436), 1, + anon_sym_COLON_COLON, + ACTIONS(462), 1, + anon_sym_LT, + ACTIONS(478), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + STATE(24), 1, + aux_sym_qualified_path_repeat1, + STATE(1703), 1, + sym_type_arguments, + ACTIONS(450), 19, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(448), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(414), 1, - anon_sym_COLON, - STATE(747), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [934] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, + [906] = 31, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(438), 1, + sym_identifier, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(746), 1, + ACTIONS(481), 1, + anon_sym_RPAREN, + STATE(721), 1, + sym_qualified_path, + STATE(866), 1, sym_expression, - STATE(1204), 1, - sym_map_entry, - ACTIONS(360), 2, + STATE(1379), 1, + sym_named_argument, + STATE(1512), 1, + sym_named_argument_list, + STATE(1717), 1, + sym_argument_list, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -8039,7 +9852,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -8053,1138 +9866,882 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [1044] = 27, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1028] = 9, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(436), 1, + anon_sym_COLON_COLON, + ACTIONS(462), 1, + anon_sym_LT, + ACTIONS(478), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(483), 1, + anon_sym_EQ, + STATE(24), 1, + aux_sym_qualified_path_repeat1, + STATE(1703), 1, + sym_type_arguments, + ACTIONS(450), 18, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(448), 33, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(416), 1, - sym_identifier, - STATE(754), 1, - sym_expression, - STATE(1414), 1, - sym_field_pattern, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1154] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1105] = 9, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(452), 1, + anon_sym_COLON_COLON, + ACTIONS(454), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(460), 1, + anon_sym_EQ, + ACTIONS(462), 1, + anon_sym_LT, + STATE(38), 1, + aux_sym_qualified_path_repeat1, + STATE(1707), 1, + sym_type_arguments, + ACTIONS(450), 18, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(448), 33, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(418), 1, - anon_sym_RBRACK, - STATE(726), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1264] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, - anon_sym_match, - ACTIONS(338), 1, + [1182] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(469), 21, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(471), 36, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(420), 1, - anon_sym_RBRACK, - STATE(728), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1374] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1247] = 8, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(452), 1, + anon_sym_COLON_COLON, + ACTIONS(454), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(462), 1, + anon_sym_LT, + STATE(38), 1, + aux_sym_qualified_path_repeat1, + STATE(1707), 1, + sym_type_arguments, + ACTIONS(450), 18, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(448), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_COLON, + anon_sym_fn, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(422), 1, - anon_sym_RPAREN, - STATE(772), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1484] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1322] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(452), 1, + anon_sym_COLON_COLON, + STATE(40), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(432), 19, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(434), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_COLON, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(424), 1, - anon_sym_COLON, - STATE(738), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1594] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1390] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(462), 1, + anon_sym_LT, + ACTIONS(485), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + STATE(1703), 1, + sym_type_arguments, + ACTIONS(450), 19, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(448), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(426), 1, - anon_sym_RBRACK, - STATE(730), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1704] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1460] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(488), 1, + anon_sym_COLON_COLON, + STATE(40), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(469), 19, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(471), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_COLON, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(428), 1, - anon_sym_RPAREN, - STATE(759), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1814] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1528] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(491), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(493), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(430), 1, - anon_sym_COLON, - STATE(760), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [1924] = 27, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1591] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(495), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(498), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(432), 1, - anon_sym_RPAREN, - STATE(745), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [2034] = 27, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + sym_identifier, + [1654] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(501), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(503), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(416), 1, - sym_identifier, - STATE(769), 1, - sym_expression, - STATE(1414), 1, - sym_field_pattern, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [2144] = 27, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + sym_identifier, + [1717] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(505), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(507), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(416), 1, - sym_identifier, - STATE(771), 1, - sym_expression, - STATE(1414), 1, - sym_field_pattern, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [2254] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [1780] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(509), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(511), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(748), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [2361] = 26, - ACTIONS(15), 1, + sym_identifier, + [1843] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(513), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(515), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(414), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [2468] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, + [1906] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(729), 1, + ACTIONS(517), 1, + anon_sym_COLON, + STATE(721), 1, + sym_qualified_path, + STATE(894), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -9195,7 +10752,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -9209,954 +10766,730 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [2575] = 26, - ACTIONS(15), 1, + [2019] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(519), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(522), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(416), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [2682] = 26, - ACTIONS(15), 1, + sym_identifier, + [2082] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(525), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(527), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(443), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [2789] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + sym_identifier, + [2145] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(529), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(531), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(441), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [2896] = 26, - ACTIONS(15), 1, + sym_identifier, + [2208] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(533), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(535), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(444), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3003] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [2271] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(537), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(539), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(734), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3110] = 26, - ACTIONS(15), 1, + sym_identifier, + [2334] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(541), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(543), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(447), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3217] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [2397] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(545), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(547), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(669), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3324] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [2460] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(549), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(551), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(766), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3431] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [2523] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(553), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(555), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(736), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3538] = 26, - ACTIONS(15), 1, + sym_identifier, + [2586] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(462), 1, + anon_sym_LT, + ACTIONS(557), 1, + anon_sym_LBRACE, + STATE(1707), 1, + sym_type_arguments, + ACTIONS(450), 19, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(448), 33, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(452), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3645] = 26, - ACTIONS(15), 1, + sym_identifier, + [2655] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(560), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(562), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(401), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3752] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + sym_identifier, + [2718] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(354), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(877), 1, sym_expression, - ACTIONS(55), 2, + STATE(1470), 1, + sym_map_entry, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10167,7 +11500,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10181,468 +11514,367 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [3859] = 26, - ACTIONS(15), 1, + [2831] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(564), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(566), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(355), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [3966] = 26, - ACTIONS(15), 1, + sym_identifier, + [2894] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(469), 20, + anon_sym_DOT, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(471), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_COLON, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(356), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [4073] = 26, - ACTIONS(15), 1, + sym_identifier, + [2957] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(450), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(448), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(440), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [4180] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [3020] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(568), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(570), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(670), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [4287] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [3083] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(572), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(336), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(574), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(338), 1, anon_sym_if, - ACTIONS(340), 1, anon_sym_handle, - ACTIONS(342), 1, anon_sym_select, - ACTIONS(346), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(348), 1, anon_sym_spawn, - ACTIONS(350), 1, anon_sym_yield, - ACTIONS(352), 1, anon_sym_send, - ACTIONS(354), 1, anon_sym_recv, - ACTIONS(356), 1, anon_sym_perform, - ACTIONS(358), 1, anon_sym_resume, - ACTIONS(362), 1, - sym_float, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(733), 1, - sym_expression, - ACTIONS(360), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(622), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(634), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [4394] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, + [3146] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(751), 1, + ACTIONS(576), 1, + anon_sym_RBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(865), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10653,7 +11885,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10667,144 +11899,127 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4501] = 26, - ACTIONS(15), 1, + [3259] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(578), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(580), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(358), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [4608] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + sym_identifier, + [3322] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(359), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(582), 1, + anon_sym_RBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(862), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10815,7 +12030,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10829,144 +12044,127 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4715] = 26, - ACTIONS(15), 1, + [3435] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(584), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(586), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(360), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [4822] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + sym_identifier, + [3498] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(361), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(588), 1, + anon_sym_RPAREN, + STATE(721), 1, + sym_qualified_path, + STATE(888), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -10977,7 +12175,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -10991,63 +12189,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [4929] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [3611] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(362), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(590), 1, + anon_sym_RPAREN, + STATE(721), 1, + sym_qualified_path, + STATE(883), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11058,7 +12260,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11072,63 +12274,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5036] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [3724] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(363), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(592), 1, + anon_sym_COLON, + STATE(721), 1, + sym_qualified_path, + STATE(889), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11139,7 +12345,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11153,225 +12359,370 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5143] = 26, - ACTIONS(15), 1, + [3837] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(594), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(596), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, - sym_line_comment, - STATE(364), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [5250] = 26, - ACTIONS(15), 1, + sym_identifier, + [3900] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(598), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(600), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + [3963] = 6, + ACTIONS(3), 1, sym_line_comment, - STATE(365), 1, - sym_expression, - ACTIONS(55), 2, + ACTIONS(606), 1, + anon_sym_DOT, + ACTIONS(608), 1, + anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(602), 17, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + sym_float, + sym__doc_comment_line, + ACTIONS(604), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [4032] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(612), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(614), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [4095] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(616), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(618), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [5357] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, + [4158] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(744), 1, + ACTIONS(620), 1, + anon_sym_RBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(864), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11382,7 +12733,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11396,63 +12747,187 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5464] = 26, - ACTIONS(15), 1, + [4271] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(622), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(624), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [4334] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(626), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(137), 1, + sym__doc_comment_line, + ACTIONS(628), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(139), 1, + [4397] = 28, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, + anon_sym_match, + ACTIONS(402), 1, + anon_sym_if, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, + anon_sym_select, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, + anon_sym_send, + ACTIONS(418), 1, + anon_sym_recv, + ACTIONS(420), 1, + anon_sym_perform, + ACTIONS(422), 1, + anon_sym_resume, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, sym_line_comment, - STATE(366), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_RPAREN, + STATE(721), 1, + sym_qualified_path, + STATE(901), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11463,7 +12938,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11477,63 +12952,127 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5571] = 26, - ACTIONS(15), 1, + [4510] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(632), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(634), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [4573] = 28, + ACTIONS(386), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, + anon_sym_match, + ACTIONS(402), 1, + anon_sym_if, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, + anon_sym_select, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, + anon_sym_send, + ACTIONS(418), 1, + anon_sym_recv, + ACTIONS(420), 1, + anon_sym_perform, + ACTIONS(422), 1, + anon_sym_resume, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, sym_line_comment, - STATE(367), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(636), 1, + anon_sym_COLON, + STATE(721), 1, + sym_qualified_path, + STATE(902), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11544,7 +13083,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11558,63 +13097,247 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5678] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [4686] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(638), 20, + ts_builtin_sym_end, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, - anon_sym_match, - ACTIONS(33), 1, - anon_sym_if, - ACTIONS(35), 1, - anon_sym_handle, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(39), 1, - anon_sym_await, - ACTIONS(41), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(640), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [4749] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(642), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(645), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [4812] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(648), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(137), 1, + sym__doc_comment_line, + ACTIONS(650), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [4875] = 28, + ACTIONS(386), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, + anon_sym_match, + ACTIONS(402), 1, + anon_sym_if, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, + anon_sym_select, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, + anon_sym_send, + ACTIONS(418), 1, + anon_sym_recv, + ACTIONS(420), 1, + anon_sym_perform, + ACTIONS(422), 1, + anon_sym_resume, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, sym_line_comment, - STATE(368), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(652), 1, + anon_sym_COLON, + STATE(721), 1, + sym_qualified_path, + STATE(907), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11625,7 +13348,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11639,63 +13362,127 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5785] = 26, - ACTIONS(15), 1, + [4988] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(654), 20, + ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(21), 1, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(656), 35, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(35), 1, anon_sym_handle, - ACTIONS(37), 1, anon_sym_select, - ACTIONS(39), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(41), 1, anon_sym_spawn, - ACTIONS(43), 1, anon_sym_yield, - ACTIONS(45), 1, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(139), 1, + [5051] = 28, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, + anon_sym_match, + ACTIONS(402), 1, + anon_sym_if, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, + anon_sym_select, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, + anon_sym_send, + ACTIONS(418), 1, + anon_sym_recv, + ACTIONS(420), 1, + anon_sym_perform, + ACTIONS(422), 1, + anon_sym_resume, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, sym_line_comment, - STATE(369), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(658), 1, + sym_identifier, + STATE(721), 1, + sym_qualified_path, + STATE(910), 1, sym_expression, - ACTIONS(55), 2, + STATE(1771), 1, + sym_field_pattern, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11706,7 +13493,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11720,63 +13507,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5892] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [5164] = 28, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(370), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(658), 1, + sym_identifier, + STATE(721), 1, + sym_qualified_path, + STATE(912), 1, sym_expression, - ACTIONS(55), 2, + STATE(1771), 1, + sym_field_pattern, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11787,7 +13578,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11801,63 +13592,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [5999] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [5277] = 28, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(371), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + ACTIONS(658), 1, + sym_identifier, + STATE(721), 1, + sym_qualified_path, + STATE(881), 1, sym_expression, - ACTIONS(55), 2, + STATE(1771), 1, + sym_field_pattern, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11868,7 +13663,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11882,65 +13677,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6106] = 27, - ACTIONS(322), 1, + [5390] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(731), 1, - sym_call_expression, - STATE(773), 1, + ACTIONS(660), 1, + anon_sym_LPAREN, + STATE(721), 1, + sym_qualified_path, + STATE(726), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 9, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -11949,8 +13744,9 @@ static const uint16_t ts_small_parse_table[] = { sym_binary_expression, sym_unary_expression, sym_pipe_expression, + sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -11964,63 +13760,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6215] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [5500] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(372), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(917), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12031,7 +13829,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12045,63 +13843,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6322] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [5610] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(373), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(871), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12112,7 +13912,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12126,63 +13926,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6429] = 26, - ACTIONS(15), 1, + [5720] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(374), 1, + STATE(39), 1, + sym_qualified_path, + STATE(448), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12193,7 +13995,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12207,63 +14009,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6536] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [5830] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(375), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(826), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12274,7 +14078,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12288,63 +14092,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6643] = 26, - ACTIONS(15), 1, + [5940] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(376), 1, + STATE(39), 1, + sym_qualified_path, + STATE(451), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12355,7 +14161,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12369,63 +14175,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6750] = 26, - ACTIONS(15), 1, + [6050] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(377), 1, + STATE(39), 1, + sym_qualified_path, + STATE(452), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12436,7 +14244,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12450,63 +14258,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6857] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [6160] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(378), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(892), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12517,7 +14327,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12531,63 +14341,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [6964] = 26, - ACTIONS(15), 1, + [6270] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(379), 1, + STATE(39), 1, + sym_qualified_path, + STATE(454), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12598,7 +14410,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12612,63 +14424,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7071] = 26, - ACTIONS(15), 1, + [6380] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(380), 1, + STATE(39), 1, + sym_qualified_path, + STATE(74), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12679,7 +14493,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12693,63 +14507,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7178] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [6490] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(381), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(891), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12760,7 +14576,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12774,63 +14590,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7285] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [6600] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(382), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(873), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12841,7 +14659,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12855,63 +14673,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7392] = 26, - ACTIONS(15), 1, + [6710] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(383), 1, + STATE(39), 1, + sym_qualified_path, + STATE(427), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -12922,7 +14742,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -12936,63 +14756,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7499] = 26, - ACTIONS(15), 1, + [6820] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(385), 1, + STATE(39), 1, + sym_qualified_path, + STATE(368), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13003,7 +14825,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13017,63 +14839,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7606] = 26, - ACTIONS(15), 1, + [6930] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(386), 1, + STATE(39), 1, + sym_qualified_path, + STATE(383), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13084,7 +14908,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13098,63 +14922,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7713] = 26, - ACTIONS(15), 1, + [7040] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(387), 1, + STATE(39), 1, + sym_qualified_path, + STATE(391), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13165,7 +14991,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13179,63 +15005,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7820] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [7150] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(388), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(870), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13246,7 +15074,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13260,63 +15088,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [7927] = 26, - ACTIONS(15), 1, + [7260] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(25), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, + anon_sym_if, ACTIONS(37), 1, - anon_sym_select, + anon_sym_handle, ACTIONS(39), 1, - anon_sym_await, + anon_sym_select, ACTIONS(41), 1, - anon_sym_spawn, + anon_sym_await, ACTIONS(43), 1, - anon_sym_yield, + anon_sym_spawn, ACTIONS(45), 1, - anon_sym_send, + anon_sym_yield, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(360), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(389), 1, + STATE(39), 1, + sym_qualified_path, + STATE(407), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13327,7 +15157,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13341,63 +15171,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8034] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [7370] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(390), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(825), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13408,7 +15240,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13422,63 +15254,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8141] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [7480] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(391), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(872), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13489,7 +15323,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13503,63 +15337,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8248] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [7590] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(392), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(868), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13570,7 +15406,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13584,63 +15420,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8355] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [7700] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(393), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(875), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13651,7 +15489,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13665,63 +15503,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8462] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [7810] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(395), 1, + STATE(39), 1, + sym_qualified_path, + STATE(439), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13732,7 +15572,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13746,63 +15586,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8569] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [7920] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(636), 1, + STATE(39), 1, + sym_qualified_path, + STATE(440), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13813,7 +15655,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13827,63 +15669,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8676] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [8030] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(647), 1, + STATE(39), 1, + sym_qualified_path, + STATE(441), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13894,7 +15738,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13908,63 +15752,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8783] = 26, - ACTIONS(322), 1, + [8140] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(663), 1, + STATE(721), 1, + sym_qualified_path, + STATE(922), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -13975,7 +15821,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -13989,63 +15835,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8890] = 26, - ACTIONS(322), 1, + [8250] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(668), 1, + STATE(721), 1, + sym_qualified_path, + STATE(914), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14056,7 +15904,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14070,63 +15918,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [8997] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [8360] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(625), 1, + STATE(39), 1, + sym_qualified_path, + STATE(449), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14137,7 +15987,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14151,63 +16001,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9104] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [8470] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(627), 1, + STATE(39), 1, + sym_qualified_path, + STATE(450), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14218,7 +16070,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14232,63 +16084,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9211] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [8580] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(396), 1, + STATE(39), 1, + sym_qualified_path, + STATE(461), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14299,7 +16153,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14313,63 +16167,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9318] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [8690] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(635), 1, + STATE(39), 1, + sym_qualified_path, + STATE(462), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14380,7 +16236,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14394,63 +16250,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9425] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [8800] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(665), 1, + STATE(39), 1, + sym_qualified_path, + STATE(463), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14461,7 +16319,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14475,63 +16333,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9532] = 26, - ACTIONS(322), 1, + [8910] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(643), 1, + STATE(721), 1, + sym_qualified_path, + STATE(878), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14542,7 +16402,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14556,63 +16416,139 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9639] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, + [9020] = 18, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(668), 1, + anon_sym_RBRACE, + ACTIONS(673), 1, + anon_sym_COLON, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(330), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, + sym_float, + sym__doc_comment_line, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(662), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [9112] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(659), 1, + STATE(39), 1, + sym_qualified_path, + STATE(466), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14623,7 +16559,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14637,63 +16573,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9746] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [9222] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(624), 1, + STATE(39), 1, + sym_qualified_path, + STATE(374), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14704,7 +16642,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14718,63 +16656,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9853] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [9332] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(398), 1, + STATE(39), 1, + sym_qualified_path, + STATE(423), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14785,7 +16725,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14799,63 +16739,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [9960] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [9442] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(399), 1, + STATE(39), 1, + sym_qualified_path, + STATE(373), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14866,7 +16808,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14880,63 +16822,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10067] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [9552] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(667), 1, + STATE(39), 1, + sym_qualified_path, + STATE(375), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -14947,7 +16891,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -14961,63 +16905,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10174] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [9662] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(400), 1, + STATE(39), 1, + sym_qualified_path, + STATE(376), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15028,7 +16974,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15042,63 +16988,67 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10281] = 26, - ACTIONS(322), 1, + [9772] = 28, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(626), 1, + STATE(721), 1, + sym_qualified_path, + STATE(867), 1, + sym_call_expression, + STATE(923), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 9, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15107,9 +17057,8 @@ static const uint16_t ts_small_parse_table[] = { sym_binary_expression, sym_unary_expression, sym_pipe_expression, - sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15123,63 +17072,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10388] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [9884] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(402), 1, + STATE(39), 1, + sym_qualified_path, + STATE(382), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15190,7 +17141,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15204,63 +17155,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10495] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [9994] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(403), 1, + STATE(39), 1, + sym_qualified_path, + STATE(387), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15271,7 +17224,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15285,63 +17238,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10602] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [10104] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(405), 1, + STATE(39), 1, + sym_qualified_path, + STATE(394), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15352,7 +17307,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15366,63 +17321,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10709] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [10214] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(406), 1, + STATE(39), 1, + sym_qualified_path, + STATE(395), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15433,7 +17390,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15447,63 +17404,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10816] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [10324] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(661), 1, + STATE(39), 1, + sym_qualified_path, + STATE(398), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15514,7 +17473,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15528,63 +17487,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [10923] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [10434] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(407), 1, + STATE(39), 1, + sym_qualified_path, + STATE(401), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15595,7 +17556,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15609,63 +17570,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11030] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [10544] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(408), 1, + STATE(39), 1, + sym_qualified_path, + STATE(409), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15676,7 +17639,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15690,63 +17653,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11137] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [10654] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(630), 1, + STATE(39), 1, + sym_qualified_path, + STATE(411), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15757,7 +17722,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15771,63 +17736,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11244] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [10764] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(409), 1, + STATE(39), 1, + sym_qualified_path, + STATE(418), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15838,7 +17805,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15852,63 +17819,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11351] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [10874] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(410), 1, + STATE(39), 1, + sym_qualified_path, + STATE(425), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -15919,7 +17888,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -15933,63 +17902,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11458] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [10984] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(411), 1, + STATE(39), 1, + sym_qualified_path, + STATE(426), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16000,7 +17971,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16014,63 +17985,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11565] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11094] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(412), 1, + STATE(39), 1, + sym_qualified_path, + STATE(367), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16081,7 +18054,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16095,63 +18068,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11672] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11204] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(413), 1, + STATE(39), 1, + sym_qualified_path, + STATE(428), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16162,7 +18137,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16176,63 +18151,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11779] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11314] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(415), 1, + STATE(39), 1, + sym_qualified_path, + STATE(429), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16243,7 +18220,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16257,63 +18234,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11886] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11424] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(417), 1, + STATE(39), 1, + sym_qualified_path, + STATE(430), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16324,7 +18303,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16338,63 +18317,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [11993] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11534] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(419), 1, + STATE(39), 1, + sym_qualified_path, + STATE(431), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16405,7 +18386,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16419,63 +18400,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12100] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11644] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(420), 1, + STATE(39), 1, + sym_qualified_path, + STATE(432), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16486,7 +18469,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16500,63 +18483,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12207] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11754] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(421), 1, + STATE(39), 1, + sym_qualified_path, + STATE(433), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16567,7 +18552,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16581,63 +18566,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12314] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11864] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(422), 1, + STATE(39), 1, + sym_qualified_path, + STATE(434), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16648,7 +18635,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16662,63 +18649,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12421] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [11974] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(423), 1, + STATE(39), 1, + sym_qualified_path, + STATE(435), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16729,7 +18718,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16743,63 +18732,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12528] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [12084] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(424), 1, + STATE(39), 1, + sym_qualified_path, + STATE(436), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16810,7 +18801,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16824,63 +18815,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12635] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [12194] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(425), 1, + STATE(39), 1, + sym_qualified_path, + STATE(456), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -16891,7 +18884,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -16905,306 +18898,301 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [12742] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [12304] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(513), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(81), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(515), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, - sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(426), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [12849] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [12366] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(622), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(81), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(624), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, - sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(427), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [12956] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [12428] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(564), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(81), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(566), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [12490] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(450), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(123), 1, + sym__doc_comment_line, + ACTIONS(448), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(129), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(428), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [13063] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [12552] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(429), 1, + STATE(39), 1, + sym_qualified_path, + STATE(465), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17215,7 +19203,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17229,144 +19217,124 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13170] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [12662] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(519), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(81), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(522), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, - sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(430), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [13277] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, + [12724] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(71), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(75), 1, - anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(123), 1, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(129), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(431), 1, + STATE(721), 1, + sym_qualified_path, + STATE(863), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17377,7 +19345,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17391,225 +19359,331 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13384] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, + [12834] = 7, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(75), 1, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(699), 16, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, - ACTIONS(83), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + sym_float, + sym__doc_comment_line, + ACTIONS(697), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [12904] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(584), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(123), 1, + sym__doc_comment_line, + ACTIONS(586), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(129), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(432), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [13491] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [12966] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(703), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(701), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [13054] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(707), 4, + anon_sym_RBRACE, + anon_sym_COLON, sym_float, - ACTIONS(123), 1, + sym__doc_comment_line, + ACTIONS(705), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(129), 1, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(433), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [13598] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [13142] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(434), 1, + STATE(57), 1, + sym_qualified_path, + STATE(443), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17620,7 +19694,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17634,63 +19708,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13705] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [13252] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(25), 1, + anon_sym_PIPE, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(37), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(41), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(43), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(45), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(435), 1, + ACTIONS(709), 1, + anon_sym_LPAREN, + STATE(39), 1, + sym_qualified_path, + STATE(437), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(29), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17701,7 +19777,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17715,63 +19791,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13812] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [13362] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(436), 1, + STATE(57), 1, + sym_qualified_path, + STATE(183), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17782,7 +19860,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17796,63 +19874,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [13919] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [13472] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(438), 1, + STATE(57), 1, + sym_qualified_path, + STATE(184), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17863,7 +19943,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17877,63 +19957,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14026] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [13582] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(284), 1, + STATE(57), 1, + sym_qualified_path, + STATE(187), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -17944,7 +20026,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -17958,63 +20040,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14133] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [13692] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(287), 1, + STATE(57), 1, + sym_qualified_path, + STATE(188), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18025,7 +20109,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18039,63 +20123,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14240] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [13802] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(288), 1, + STATE(57), 1, + sym_qualified_path, + STATE(189), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18106,7 +20192,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18120,63 +20206,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14347] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [13912] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(289), 1, + STATE(57), 1, + sym_qualified_path, + STATE(190), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18187,7 +20275,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18201,63 +20289,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14454] = 26, - ACTIONS(63), 1, + [14022] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(69), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(71), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(75), 1, - anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(123), 1, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(129), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(290), 1, + STATE(721), 1, + sym_qualified_path, + STATE(879), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18268,7 +20358,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18282,306 +20372,242 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14561] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [14132] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(549), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, - ACTIONS(83), 1, - anon_sym_if, - ACTIONS(85), 1, - anon_sym_handle, - ACTIONS(87), 1, - anon_sym_select, - ACTIONS(91), 1, - anon_sym_await, - ACTIONS(93), 1, - anon_sym_spawn, - ACTIONS(95), 1, - anon_sym_yield, - ACTIONS(97), 1, - anon_sym_send, - ACTIONS(99), 1, - anon_sym_recv, - ACTIONS(101), 1, - anon_sym_perform, - ACTIONS(103), 1, - anon_sym_resume, - ACTIONS(107), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(123), 1, + sym__doc_comment_line, + ACTIONS(551), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(291), 1, - sym_expression, - ACTIONS(105), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(89), 3, + anon_sym_effect, anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, - sym_integer, - sym_string, - sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [14668] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [14194] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(553), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(555), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(689), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, + sym_identifier, + [14256] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(560), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [14775] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(562), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, - anon_sym_LBRACE, - ACTIONS(81), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, - sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(293), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [14882] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [14318] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(307), 1, + STATE(57), 1, + sym_qualified_path, + STATE(458), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18592,7 +20618,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18606,144 +20632,124 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [14989] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [14428] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(568), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(81), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(570), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, - sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(314), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [15096] = 26, - ACTIONS(322), 1, sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [14490] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(782), 1, + STATE(57), 1, + sym_qualified_path, + STATE(194), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -18754,7 +20760,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -18768,468 +20774,430 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15203] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [14600] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(572), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(81), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(574), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, - sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(322), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [15310] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + sym_identifier, + [14662] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(578), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(580), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [14724] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(690), 1, - sym_expression, - ACTIONS(55), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, + ACTIONS(594), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [15417] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(596), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(691), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [15524] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, + [14786] = 7, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(75), 1, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(713), 16, anon_sym_LBRACE, - ACTIONS(81), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_match, - ACTIONS(83), 1, anon_sym_if, - ACTIONS(85), 1, anon_sym_handle, - ACTIONS(87), 1, anon_sym_select, - ACTIONS(91), 1, + anon_sym_SLASH, anon_sym_await, - ACTIONS(93), 1, anon_sym_spawn, - ACTIONS(95), 1, anon_sym_yield, - ACTIONS(97), 1, anon_sym_send, - ACTIONS(99), 1, anon_sym_recv, - ACTIONS(101), 1, anon_sym_perform, - ACTIONS(103), 1, anon_sym_resume, - ACTIONS(107), 1, - sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(324), 1, - sym_expression, - ACTIONS(105), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(342), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(343), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [15631] = 26, - ACTIONS(15), 1, + sym_identifier, + [14856] = 10, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(23), 1, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(713), 12, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 33, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [14932] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(598), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(600), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(692), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [15738] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [14994] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(331), 1, + STATE(57), 1, + sym_qualified_path, + STATE(204), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19240,7 +21208,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19254,387 +21222,447 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [15845] = 26, - ACTIONS(15), 1, + [15104] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(23), 1, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(713), 7, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(693), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, + sym_identifier, + [15186] = 12, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [15952] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(713), 8, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(694), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [16059] = 26, - ACTIONS(15), 1, + sym_identifier, + [15266] = 9, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(23), 1, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(713), 14, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 33, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [15340] = 6, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(602), 17, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + sym_float, + sym__doc_comment_line, + ACTIONS(604), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(695), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, + sym_identifier, + [15408] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(612), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [16166] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(614), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [15470] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(616), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(618), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(696), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [16273] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [15532] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(81), 1, - anon_sym_match, ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - STATE(340), 1, + STATE(57), 1, + sym_qualified_path, + STATE(210), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19645,7 +21673,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19659,63 +21687,255 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16380] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [15642] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(717), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(715), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [15730] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(626), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(628), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [15792] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(632), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(634), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - STATE(697), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, + sym_identifier, + [15854] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(214), 1, + sym_expression, + ACTIONS(125), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19726,7 +21946,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19740,144 +21960,124 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16487] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, - anon_sym_match, - ACTIONS(33), 1, - anon_sym_if, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(45), 1, - anon_sym_send, - ACTIONS(47), 1, - anon_sym_recv, - ACTIONS(49), 1, - anon_sym_perform, - ACTIONS(51), 1, - anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, + [15964] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, + ACTIONS(638), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(640), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - STATE(698), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [16594] = 26, - ACTIONS(63), 1, sym_identifier, - ACTIONS(69), 1, + [16026] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(71), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(75), 1, - anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(123), 1, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(129), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(344), 1, + STATE(721), 1, + sym_qualified_path, + STATE(893), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -19888,7 +22088,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -19902,306 +22102,373 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [16701] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [16136] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(648), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(650), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(723), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, + sym_identifier, + [16198] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(654), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [16808] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(656), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [16260] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(495), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(498), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(699), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, + sym_identifier, + [16322] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(501), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [16915] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(503), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [16384] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(721), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(719), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(700), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [17022] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + sym_identifier, + [16472] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(701), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(216), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20212,7 +22479,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20226,225 +22493,183 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17129] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [16582] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(505), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, - anon_sym_match, - ACTIONS(33), 1, - anon_sym_if, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(45), 1, - anon_sym_send, - ACTIONS(47), 1, - anon_sym_recv, - ACTIONS(49), 1, - anon_sym_perform, - ACTIONS(51), 1, - anon_sym_resume, - ACTIONS(57), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + sym__doc_comment_line, + ACTIONS(507), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(702), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, + sym_identifier, + [16644] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(509), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [17236] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(511), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(703), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [17343] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + sym_identifier, + [16706] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(704), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(369), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20455,7 +22680,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20469,63 +22694,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17450] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [16816] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(705), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(370), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20536,7 +22763,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20550,144 +22777,137 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17557] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [16926] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(725), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(723), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(706), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [17664] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + sym_identifier, + [17014] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(707), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(218), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20698,7 +22918,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20712,63 +22932,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17771] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [17124] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(708), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(372), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20779,7 +23001,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20793,144 +23015,327 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [17878] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [17234] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(491), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(493), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(709), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, - anon_sym_BANG, + sym_identifier, + [17296] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, - sym_list_literal, - sym_map_literal, - sym_boolean, - STATE(338), 10, - sym_match_expression, - sym_if_expression, - sym_handler_expression, - sym_select_expression, - sym_ternary_expression, - sym_binary_expression, - sym_unary_expression, - sym_pipe_expression, - sym_call_expression, - sym_primary_expression, - STATE(283), 13, - sym_spawn_expression, - sym_yield_expression, - sym_await_call, - sym_send_call, - sym_recv_call, - sym_perform_expression, - sym_resume_expression, - sym_type_constructor, - sym_update_expression, - sym_block, - sym_object_literal, - sym_lambda_expression, - sym_literal, - [17985] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(729), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(727), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [17384] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(525), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(527), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [17446] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(733), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(731), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - STATE(710), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, + sym_identifier, + [17534] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(225), 1, + sym_expression, + ACTIONS(125), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -20941,7 +23346,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -20955,63 +23360,137 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18092] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [17644] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(737), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(735), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, + [17732] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(388), 1, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(390), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(392), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(711), 1, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(377), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21022,7 +23501,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21036,63 +23515,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18199] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [17842] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(712), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(378), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21103,7 +23584,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21117,63 +23598,183 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18306] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [17952] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(529), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(531), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [18014] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(533), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(535), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(713), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, + sym_identifier, + [18076] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(380), 1, + sym_expression, + ACTIONS(125), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21184,7 +23785,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21198,63 +23799,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18413] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [18186] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(714), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(381), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21265,7 +23868,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21279,63 +23882,137 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18520] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, - anon_sym_match, - ACTIONS(33), 1, - anon_sym_if, - ACTIONS(37), 1, - anon_sym_select, - ACTIONS(45), 1, - anon_sym_send, - ACTIONS(47), 1, - anon_sym_recv, - ACTIONS(49), 1, - anon_sym_perform, - ACTIONS(51), 1, - anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, + [18296] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(741), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(739), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, anon_sym_PIPE, - STATE(715), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, + sym_identifier, + [18384] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(234), 1, + sym_expression, + ACTIONS(125), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21346,7 +24023,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21360,63 +24037,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18627] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [18494] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(716), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(384), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21427,7 +24106,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21441,63 +24120,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18734] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [18604] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(717), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(386), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21508,7 +24189,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21522,63 +24203,183 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18841] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [18714] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(537), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(539), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, + [18776] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(378), 1, + ACTIONS(541), 20, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(543), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, anon_sym_fn, - ACTIONS(384), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, anon_sym_handle, - ACTIONS(388), 1, + anon_sym_select, + anon_sym_SLASH, anon_sym_await, - ACTIONS(390), 1, anon_sym_spawn, - ACTIONS(392), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(718), 1, - sym_expression, - ACTIONS(55), 2, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, + sym_identifier, + [18838] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(238), 1, + sym_expression, + ACTIONS(125), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21589,7 +24390,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21603,63 +24404,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [18948] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [18948] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(719), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(388), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21670,7 +24473,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21684,63 +24487,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19055] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [19058] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(720), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(389), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21751,7 +24556,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21765,63 +24570,137 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19162] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [19168] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(745), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(743), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, + [19256] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(388), 1, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(390), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(392), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(721), 1, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(390), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21832,7 +24711,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21846,63 +24725,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19269] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [19366] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(722), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(392), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21913,7 +24794,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -21927,63 +24808,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19376] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [19476] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(672), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(393), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -21994,7 +24877,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22008,63 +24891,137 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19483] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [19586] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(749), 4, + anon_sym_RBRACE, + anon_sym_COLON, + sym_float, + sym__doc_comment_line, + ACTIONS(747), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, + [19674] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(388), 1, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(390), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(392), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(671), 1, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(396), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22075,7 +25032,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22089,63 +25046,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19590] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [19784] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(673), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(397), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22156,7 +25115,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22170,63 +25129,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19697] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [19894] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(674), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(399), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22237,7 +25198,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22251,63 +25212,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19804] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20004] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(675), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(400), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22318,7 +25281,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22332,63 +25295,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [19911] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20114] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(676), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(402), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22399,7 +25364,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22413,63 +25378,124 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20018] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20224] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(545), 20, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(29), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + sym__doc_comment_line, + ACTIONS(547), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, anon_sym_LBRACK, - ACTIONS(31), 1, anon_sym_match, - ACTIONS(33), 1, anon_sym_if, - ACTIONS(37), 1, + anon_sym_handle, anon_sym_select, - ACTIONS(45), 1, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, anon_sym_send, - ACTIONS(47), 1, anon_sym_recv, - ACTIONS(49), 1, anon_sym_perform, - ACTIONS(51), 1, anon_sym_resume, - ACTIONS(57), 1, - sym_float, - ACTIONS(137), 1, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, + [20286] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_match, + ACTIONS(99), 1, + anon_sym_if, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(388), 1, + ACTIONS(103), 1, + anon_sym_select, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(390), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(392), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(308), 1, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, + anon_sym_recv, + ACTIONS(115), 1, + anon_sym_perform, + ACTIONS(117), 1, + anon_sym_resume, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(403), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22480,7 +25506,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22494,63 +25520,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20125] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20396] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(677), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(405), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22561,7 +25589,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22575,63 +25603,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20232] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20506] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(678), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(406), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22642,7 +25672,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22656,63 +25686,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20339] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20616] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(679), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(408), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22723,7 +25755,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22737,63 +25769,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20446] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20726] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, - anon_sym_send, - ACTIONS(47), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, + anon_sym_send, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(680), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(410), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22804,7 +25838,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22818,63 +25852,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20553] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20836] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(681), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(412), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22885,7 +25921,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22899,63 +25935,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20660] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [20946] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(682), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(413), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -22966,7 +26004,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -22980,63 +26018,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20767] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [21056] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(683), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(414), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23047,7 +26087,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23061,63 +26101,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20874] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [21166] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(684), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(415), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23128,7 +26170,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23142,63 +26184,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [20981] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [21276] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(101), 1, + anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(105), 1, + anon_sym_await, + ACTIONS(107), 1, + anon_sym_spawn, + ACTIONS(109), 1, + anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, - anon_sym_PIPE, - STATE(685), 1, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(416), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(129), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23209,7 +26253,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23223,63 +26267,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21088] = 26, - ACTIONS(15), 1, + [21386] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(89), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(353), 1, + STATE(57), 1, + sym_qualified_path, + STATE(417), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23290,7 +26336,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23304,63 +26350,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21195] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [21496] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(628), 1, + STATE(57), 1, + sym_qualified_path, + STATE(419), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23371,7 +26419,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23385,63 +26433,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21302] = 26, - ACTIONS(15), 1, + [21606] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(89), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(418), 1, + STATE(57), 1, + sym_qualified_path, + STATE(420), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23452,7 +26502,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23466,63 +26516,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21409] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(330), 1, + [21716] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - ACTIONS(436), 1, - anon_sym_LPAREN, - STATE(628), 1, + STATE(57), 1, + sym_qualified_path, + STATE(421), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23533,7 +26585,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23547,63 +26599,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21516] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [21826] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, + anon_sym_PIPE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, - anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(641), 1, + STATE(57), 1, + sym_qualified_path, + STATE(422), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23614,7 +26668,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23628,63 +26682,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21623] = 26, - ACTIONS(15), 1, + [21936] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, anon_sym_LPAREN, - ACTIONS(21), 1, + ACTIONS(89), 1, anon_sym_PIPE, - ACTIONS(23), 1, - anon_sym_LBRACE, - ACTIONS(29), 1, + ACTIONS(95), 1, anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(97), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(99), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(101), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(103), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(105), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(107), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(109), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(111), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(113), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(115), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(117), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(127), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(135), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(141), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(308), 1, + STATE(57), 1, + sym_qualified_path, + STATE(467), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(93), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(155), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(156), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23695,7 +26751,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(157), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23709,126 +26765,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21730] = 8, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(442), 1, - anon_sym_COLON, - ACTIONS(445), 1, - anon_sym_EQ, - ACTIONS(447), 1, - anon_sym_LT, - ACTIONS(450), 1, - anon_sym_LBRACE, - STATE(1396), 1, - sym_type_arguments, - ACTIONS(440), 18, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(438), 30, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, + [22046] = 27, + ACTIONS(386), 1, sym_identifier, - [21801] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(740), 1, + STATE(721), 1, + sym_qualified_path, + STATE(880), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23839,7 +26834,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23853,63 +26848,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [21908] = 26, - ACTIONS(322), 1, + [22156] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(780), 1, + STATE(721), 1, + sym_qualified_path, + STATE(737), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -23920,7 +26917,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -23934,63 +26931,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22015] = 26, - ACTIONS(63), 1, + [22266] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(69), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(71), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(75), 1, - anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(123), 1, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(129), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(347), 1, + STATE(721), 1, + sym_qualified_path, + STATE(722), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24001,7 +27000,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24015,63 +27014,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22122] = 26, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [22376] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(453), 1, - anon_sym_LPAREN, - STATE(440), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(739), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24082,7 +27083,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24096,63 +27097,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22229] = 26, - ACTIONS(63), 1, + [22486] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(75), 1, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(123), 1, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(129), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(455), 1, - anon_sym_LPAREN, - STATE(347), 1, + STATE(721), 1, + sym_qualified_path, + STATE(740), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24163,7 +27166,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24177,63 +27180,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22336] = 26, - ACTIONS(63), 1, + [22596] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(69), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(71), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(75), 1, - anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(85), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(91), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(93), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(95), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(123), 1, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(129), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - ACTIONS(366), 1, - sym_line_comment, - STATE(349), 1, + STATE(721), 1, + sym_qualified_path, + STATE(741), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24244,7 +27249,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24258,63 +27263,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22443] = 26, - ACTIONS(322), 1, + [22706] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(749), 1, + STATE(721), 1, + sym_qualified_path, + STATE(742), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24325,7 +27332,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24339,63 +27346,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22550] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [22816] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, - ACTIONS(37), 1, - anon_sym_select, + anon_sym_if, ACTIONS(39), 1, - anon_sym_await, - ACTIONS(41), 1, - anon_sym_spawn, - ACTIONS(43), 1, - anon_sym_yield, - ACTIONS(45), 1, - anon_sym_send, + anon_sym_select, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(370), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - STATE(437), 1, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(774), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24406,7 +27415,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24420,63 +27429,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22657] = 26, - ACTIONS(322), 1, + [22926] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(752), 1, + STATE(721), 1, + sym_qualified_path, + STATE(745), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24487,7 +27498,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24501,63 +27512,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22764] = 26, - ACTIONS(322), 1, + [23036] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(753), 1, + STATE(721), 1, + sym_qualified_path, + STATE(754), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24568,7 +27581,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24582,63 +27595,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22871] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [23146] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(439), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(757), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24649,7 +27664,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24663,63 +27678,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [22978] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [23256] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, + ACTIONS(442), 1, anon_sym_PIPE, - STATE(686), 1, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(759), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(428), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24730,7 +27747,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24744,63 +27761,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23085] = 26, - ACTIONS(23), 1, + [23366] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(45), 1, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(378), 1, - anon_sym_fn, - ACTIONS(384), 1, - anon_sym_handle, - ACTIONS(388), 1, - anon_sym_await, - ACTIONS(390), 1, - anon_sym_spawn, - ACTIONS(392), 1, - anon_sym_yield, - ACTIONS(434), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(453), 1, - anon_sym_LPAREN, - STATE(686), 1, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(761), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, - sym_integer, - sym_string, - sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + ACTIONS(428), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24811,7 +27830,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24825,63 +27844,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23192] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(23), 1, + [23476] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, + anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(37), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(45), 1, - anon_sym_send, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(378), 1, + ACTIONS(370), 1, anon_sym_fn, - ACTIONS(384), 1, + ACTIONS(376), 1, anon_sym_handle, - ACTIONS(388), 1, + ACTIONS(380), 1, anon_sym_await, - ACTIONS(390), 1, + ACTIONS(382), 1, anon_sym_spawn, - ACTIONS(392), 1, + ACTIONS(384), 1, anon_sym_yield, - ACTIONS(434), 1, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, anon_sym_PIPE, - STATE(687), 1, + STATE(39), 1, + sym_qualified_path, + STATE(781), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - ACTIONS(386), 3, + ACTIONS(378), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - STATE(332), 3, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24892,7 +27913,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24906,63 +27927,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23299] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [23586] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, + ACTIONS(19), 1, + anon_sym_LPAREN, ACTIONS(31), 1, - anon_sym_match, + anon_sym_LBRACK, ACTIONS(33), 1, - anon_sym_if, + anon_sym_match, ACTIONS(35), 1, - anon_sym_handle, - ACTIONS(37), 1, - anon_sym_select, + anon_sym_if, ACTIONS(39), 1, - anon_sym_await, - ACTIONS(41), 1, - anon_sym_spawn, - ACTIONS(43), 1, - anon_sym_yield, - ACTIONS(45), 1, - anon_sym_send, + anon_sym_select, ACTIONS(47), 1, - anon_sym_recv, + anon_sym_send, ACTIONS(49), 1, - anon_sym_perform, + anon_sym_recv, ACTIONS(51), 1, + anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(137), 1, + ACTIONS(358), 1, sym_identifier, - ACTIONS(139), 1, + ACTIONS(370), 1, anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - STATE(397), 1, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(787), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -24973,7 +27996,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -24987,63 +28010,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23406] = 26, - ACTIONS(15), 1, - anon_sym_LPAREN, - ACTIONS(21), 1, - anon_sym_PIPE, - ACTIONS(23), 1, + [23696] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(29), 1, - anon_sym_LBRACK, - ACTIONS(31), 1, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(33), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(35), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(37), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(39), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(41), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(43), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(45), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(47), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(49), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(51), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(57), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(137), 1, - sym_identifier, - ACTIONS(139), 1, - anon_sym_fn, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - STATE(404), 1, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(762), 1, sym_expression, - ACTIONS(55), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(27), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(59), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(332), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(338), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25054,7 +28079,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(283), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25068,63 +28093,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23513] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [23806] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(778), 1, + STATE(39), 1, + sym_qualified_path, + STATE(775), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25135,7 +28162,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25149,63 +28176,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23620] = 26, - ACTIONS(322), 1, + [23916] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(750), 1, + STATE(721), 1, + sym_qualified_path, + STATE(765), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25216,7 +28245,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25230,63 +28259,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23727] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [24026] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(756), 1, + STATE(39), 1, + sym_qualified_path, + STATE(795), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25297,7 +28328,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25311,63 +28342,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23834] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [24136] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(767), 1, + STATE(39), 1, + sym_qualified_path, + STATE(796), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25378,7 +28411,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25392,63 +28425,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [23941] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [24246] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(739), 1, + STATE(39), 1, + sym_qualified_path, + STATE(776), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25459,7 +28494,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25473,63 +28508,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24048] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [24356] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(741), 1, + STATE(39), 1, + sym_qualified_path, + STATE(777), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25540,7 +28577,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25554,63 +28591,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24155] = 26, - ACTIONS(322), 1, + [24466] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(742), 1, + STATE(721), 1, + sym_qualified_path, + STATE(768), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25621,7 +28660,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25635,63 +28674,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24262] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [24576] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(743), 1, + STATE(39), 1, + sym_qualified_path, + STATE(779), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25702,7 +28743,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25716,63 +28757,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24369] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [24686] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(755), 1, + STATE(39), 1, + sym_qualified_path, + STATE(780), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25783,7 +28826,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25797,63 +28840,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24476] = 26, - ACTIONS(322), 1, + [24796] = 27, + ACTIONS(386), 1, sym_identifier, - ACTIONS(324), 1, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - ACTIONS(326), 1, + ACTIONS(392), 1, anon_sym_LPAREN, - ACTIONS(330), 1, - anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(400), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(402), 1, anon_sym_if, - ACTIONS(340), 1, + ACTIONS(404), 1, anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(406), 1, anon_sym_select, - ACTIONS(346), 1, + ACTIONS(410), 1, anon_sym_await, - ACTIONS(348), 1, + ACTIONS(412), 1, anon_sym_spawn, - ACTIONS(350), 1, + ACTIONS(414), 1, anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(416), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(418), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(420), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(422), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(426), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(442), 1, anon_sym_PIPE, - ACTIONS(400), 1, + ACTIONS(444), 1, anon_sym_LBRACK, - STATE(757), 1, + STATE(721), 1, + sym_qualified_path, + STATE(769), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, + ACTIONS(408), 3, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + STATE(723), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(724), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25864,7 +28909,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(725), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25878,63 +28923,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24583] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [24906] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(758), 1, + STATE(39), 1, + sym_qualified_path, + STATE(782), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -25945,7 +28992,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -25959,63 +29006,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24690] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25016] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(737), 1, + STATE(39), 1, + sym_qualified_path, + STATE(783), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26026,7 +29075,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26040,63 +29089,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24797] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25126] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(761), 1, + STATE(39), 1, + sym_qualified_path, + STATE(784), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26107,7 +29158,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26121,63 +29172,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [24904] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25236] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(762), 1, + STATE(39), 1, + sym_qualified_path, + STATE(785), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26188,7 +29241,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26202,63 +29255,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25011] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25346] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(763), 1, + STATE(39), 1, + sym_qualified_path, + STATE(786), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26269,7 +29324,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26283,63 +29338,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25118] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25456] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(765), 1, + STATE(39), 1, + sym_qualified_path, + STATE(788), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26350,7 +29407,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26364,63 +29421,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25225] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25566] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(774), 1, + STATE(39), 1, + sym_qualified_path, + STATE(789), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26431,7 +29490,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26445,63 +29504,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25332] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25676] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(775), 1, + STATE(39), 1, + sym_qualified_path, + STATE(790), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26512,7 +29573,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26526,63 +29587,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25439] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25786] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(768), 1, + STATE(39), 1, + sym_qualified_path, + STATE(791), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26593,7 +29656,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26607,63 +29670,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25546] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [25896] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(732), 1, + STATE(39), 1, + sym_qualified_path, + STATE(792), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26674,7 +29739,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26688,63 +29753,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25653] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [26006] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(770), 1, + STATE(39), 1, + sym_qualified_path, + STATE(793), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26755,7 +29822,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26769,63 +29836,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25760] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [26116] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(735), 1, + STATE(39), 1, + sym_qualified_path, + STATE(794), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26836,7 +29905,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26850,63 +29919,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25867] = 26, - ACTIONS(322), 1, - sym_identifier, - ACTIONS(324), 1, - anon_sym_fn, - ACTIONS(326), 1, - anon_sym_LPAREN, - ACTIONS(330), 1, + [26226] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(336), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(338), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(340), 1, - anon_sym_handle, - ACTIONS(342), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(346), 1, - anon_sym_await, - ACTIONS(348), 1, - anon_sym_spawn, - ACTIONS(350), 1, - anon_sym_yield, - ACTIONS(352), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(354), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(356), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(358), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(362), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(398), 1, + ACTIONS(751), 1, anon_sym_PIPE, - ACTIONS(400), 1, - anon_sym_LBRACK, - STATE(781), 1, + STATE(39), 1, + sym_qualified_path, + STATE(772), 1, sym_expression, - ACTIONS(360), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(344), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(364), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(633), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(622), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26917,7 +29988,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(634), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -26931,63 +30002,65 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [25974] = 26, - ACTIONS(63), 1, - sym_identifier, - ACTIONS(69), 1, - anon_sym_fn, - ACTIONS(71), 1, - anon_sym_LPAREN, - ACTIONS(75), 1, + [26336] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(81), 1, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, - ACTIONS(83), 1, + ACTIONS(35), 1, anon_sym_if, - ACTIONS(85), 1, - anon_sym_handle, - ACTIONS(87), 1, + ACTIONS(39), 1, anon_sym_select, - ACTIONS(91), 1, - anon_sym_await, - ACTIONS(93), 1, - anon_sym_spawn, - ACTIONS(95), 1, - anon_sym_yield, - ACTIONS(97), 1, + ACTIONS(47), 1, anon_sym_send, - ACTIONS(99), 1, + ACTIONS(49), 1, anon_sym_recv, - ACTIONS(101), 1, + ACTIONS(51), 1, anon_sym_perform, - ACTIONS(103), 1, + ACTIONS(53), 1, anon_sym_resume, - ACTIONS(107), 1, + ACTIONS(63), 1, sym_float, - ACTIONS(123), 1, - anon_sym_PIPE, - ACTIONS(129), 1, - anon_sym_LBRACK, - ACTIONS(366), 1, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, sym_line_comment, - STATE(319), 1, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(824), 1, sym_expression, - ACTIONS(105), 2, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, - ACTIONS(89), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(109), 3, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - STATE(341), 3, + ACTIONS(378), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + STATE(78), 3, sym_list_literal, sym_map_literal, sym_boolean, - STATE(342), 10, + STATE(60), 10, sym_match_expression, sym_if_expression, sym_handler_expression, @@ -26998,7 +30071,7 @@ static const uint16_t ts_small_parse_table[] = { sym_pipe_expression, sym_call_expression, sym_primary_expression, - STATE(343), 13, + STATE(62), 13, sym_spawn_expression, sym_yield_expression, sym_await_call, @@ -27012,1899 +30085,2627 @@ static const uint16_t ts_small_parse_table[] = { sym_object_literal, sym_lambda_expression, sym_literal, - [26081] = 6, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(447), 1, - anon_sym_LT, - ACTIONS(457), 1, + [26446] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - STATE(1330), 1, - sym_type_arguments, - ACTIONS(440), 19, - ts_builtin_sym_end, - anon_sym_DOT, + ACTIONS(19), 1, anon_sym_LPAREN, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(438), 30, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(797), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26147] = 7, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(445), 1, - anon_sym_EQ, - ACTIONS(447), 1, - anon_sym_LT, - ACTIONS(450), 1, - anon_sym_LBRACE, - STATE(1396), 1, - sym_type_arguments, - ACTIONS(440), 18, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(438), 30, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [26556] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, + anon_sym_LBRACK, + ACTIONS(33), 1, + anon_sym_match, + ACTIONS(35), 1, + anon_sym_if, + ACTIONS(39), 1, + anon_sym_select, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(798), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26215] = 7, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(447), 1, - anon_sym_LT, - ACTIONS(457), 1, - anon_sym_LBRACE, - ACTIONS(460), 1, - anon_sym_EQ, - STATE(1330), 1, - sym_type_arguments, - ACTIONS(440), 18, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(438), 30, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [26666] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(799), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26283] = 6, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(447), 1, - anon_sym_LT, - ACTIONS(450), 1, - anon_sym_LBRACE, - STATE(1396), 1, - sym_type_arguments, - ACTIONS(440), 19, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(438), 30, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [26776] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(800), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26349] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(464), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(462), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [26886] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(801), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26408] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(466), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(468), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [26996] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(802), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26467] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(470), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(472), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27106] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(803), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26526] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(474), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(476), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27216] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(804), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26585] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(478), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(481), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27326] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(805), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26644] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(484), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(486), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27436] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(806), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26703] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(488), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(490), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27546] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(807), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26762] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(492), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(494), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27656] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(808), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26821] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(498), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(496), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27766] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [26880] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(500), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(426), 1, sym_float, - sym__doc_comment_line, - ACTIONS(502), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(444), 1, anon_sym_LBRACK, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, + STATE(721), 1, + sym_qualified_path, + STATE(882), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26939] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(506), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27876] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(504), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(809), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [26998] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(510), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(508), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [27986] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(810), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27057] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(488), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(490), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28096] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(811), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27116] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(514), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(512), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28206] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(812), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27175] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(518), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(516), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28316] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(813), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27234] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(522), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(520), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28426] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(74), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27293] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(440), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(438), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28536] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(814), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27352] = 10, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(532), 2, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(528), 12, - anon_sym_COLON, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28646] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 30, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(815), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27425] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(544), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(542), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28756] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(816), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27484] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(546), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(548), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28866] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(817), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27543] = 13, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(532), 2, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(528), 7, - anon_sym_COLON, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [28976] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(818), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27622] = 12, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(532), 2, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(528), 8, - anon_sym_COLON, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [29086] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(819), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27699] = 9, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(528), 14, - anon_sym_COLON, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 30, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [29196] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(820), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27770] = 7, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(528), 16, - anon_sym_COLON, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [29306] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(821), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27837] = 6, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(558), 17, - anon_sym_COLON, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - sym_float, - sym__doc_comment_line, - ACTIONS(556), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [29416] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(822), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27902] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(464), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(462), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [29526] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(95), 1, anon_sym_LBRACK, + ACTIONS(97), 1, anon_sym_match, + ACTIONS(99), 1, anon_sym_if, + ACTIONS(101), 1, anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(105), 1, anon_sym_await, + ACTIONS(107), 1, anon_sym_spawn, + ACTIONS(109), 1, anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, + ACTIONS(113), 1, anon_sym_recv, + ACTIONS(115), 1, anon_sym_perform, + ACTIONS(117), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(161), 1, + sym_expression, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, + ACTIONS(93), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [27961] = 16, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + STATE(155), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(156), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(157), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [29636] = 27, + ACTIONS(73), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(562), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(560), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, + ACTIONS(89), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(95), 1, anon_sym_LBRACK, + ACTIONS(97), 1, anon_sym_match, + ACTIONS(99), 1, anon_sym_if, + ACTIONS(101), 1, anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, + ACTIONS(105), 1, anon_sym_await, + ACTIONS(107), 1, anon_sym_spawn, + ACTIONS(109), 1, anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, + ACTIONS(113), 1, anon_sym_recv, + ACTIONS(115), 1, anon_sym_perform, + ACTIONS(117), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(753), 1, + anon_sym_LPAREN, + STATE(57), 1, + sym_qualified_path, + STATE(161), 1, + sym_expression, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, + ACTIONS(93), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28046] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(572), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(570), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + STATE(155), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(156), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(157), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [29746] = 27, + ACTIONS(73), 1, + anon_sym_LBRACE, + ACTIONS(83), 1, + anon_sym_LPAREN, + ACTIONS(89), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(95), 1, anon_sym_LBRACK, + ACTIONS(97), 1, anon_sym_match, + ACTIONS(99), 1, anon_sym_if, + ACTIONS(101), 1, anon_sym_handle, + ACTIONS(103), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(105), 1, anon_sym_await, + ACTIONS(107), 1, anon_sym_spawn, + ACTIONS(109), 1, anon_sym_yield, + ACTIONS(111), 1, anon_sym_send, + ACTIONS(113), 1, anon_sym_recv, + ACTIONS(115), 1, anon_sym_perform, + ACTIONS(117), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(127), 1, + sym_float, + ACTIONS(135), 1, + sym_identifier, + ACTIONS(141), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(57), 1, + sym_qualified_path, + STATE(163), 1, + sym_expression, + ACTIONS(125), 2, anon_sym_true, anon_sym_false, + ACTIONS(93), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(129), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28105] = 3, + STATE(155), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(156), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(157), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [29856] = 18, ACTIONS(3), 1, sym_line_comment, - ACTIONS(576), 20, + ACTIONS(664), 1, anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(673), 1, anon_sym_COLON, + ACTIONS(677), 1, anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(755), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(574), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -28915,7 +32716,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -28923,436 +32723,561 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [28164] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(580), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + [29948] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(578), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, + ACTIONS(37), 1, anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(41), 1, anon_sym_await, + ACTIONS(43), 1, anon_sym_spawn, + ACTIONS(45), 1, anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(39), 1, + sym_qualified_path, + STATE(442), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(29), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28223] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(584), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [30058] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(582), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, + ACTIONS(37), 1, anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(41), 1, anon_sym_await, + ACTIONS(43), 1, anon_sym_spawn, + ACTIONS(45), 1, anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(39), 1, + sym_qualified_path, + STATE(385), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(29), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28282] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(586), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [30168] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(589), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, + ACTIONS(37), 1, anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(41), 1, anon_sym_await, + ACTIONS(43), 1, anon_sym_spawn, + ACTIONS(45), 1, anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(39), 1, + sym_qualified_path, + STATE(424), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(29), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [30278] = 27, + ACTIONS(386), 1, sym_identifier, - [28341] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(474), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(476), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(726), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28400] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(478), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [30388] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(481), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, + ACTIONS(37), 1, anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(41), 1, anon_sym_await, + ACTIONS(43), 1, anon_sym_spawn, + ACTIONS(45), 1, anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [28459] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(492), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(63), 1, sym_float, - sym__doc_comment_line, - ACTIONS(494), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, + ACTIONS(430), 1, + sym_line_comment, + STATE(39), 1, + sym_qualified_path, + STATE(437), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(29), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [30498] = 27, + ACTIONS(386), 1, sym_identifier, - [28518] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(506), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(504), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(728), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28577] = 3, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [30608] = 18, ACTIONS(3), 1, sym_line_comment, - ACTIONS(586), 20, + ACTIONS(664), 1, anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(673), 1, anon_sym_COLON, + ACTIONS(677), 1, anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(758), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(589), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -29363,7 +33288,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -29371,1479 +33295,2183 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [28636] = 18, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + [30700] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(594), 1, - anon_sym_COLON, - ACTIONS(596), 1, - anon_sym_RBRACE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, - sym_float, - sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, + ACTIONS(37), 1, anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, + ACTIONS(41), 1, anon_sym_await, + ACTIONS(43), 1, anon_sym_spawn, + ACTIONS(45), 1, anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(39), 1, + sym_qualified_path, + STATE(445), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(29), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28725] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(601), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [30810] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(604), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, + ACTIONS(37), 1, anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(41), 1, anon_sym_await, + ACTIONS(43), 1, anon_sym_spawn, + ACTIONS(45), 1, anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(39), 1, + sym_qualified_path, + STATE(447), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(29), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28784] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(609), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [30920] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(607), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, + ACTIONS(37), 1, anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(41), 1, anon_sym_await, + ACTIONS(43), 1, anon_sym_spawn, + ACTIONS(45), 1, anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(360), 1, + anon_sym_fn, + ACTIONS(430), 1, + sym_line_comment, + STATE(39), 1, + sym_qualified_path, + STATE(464), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(29), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28843] = 16, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31030] = 27, + ACTIONS(11), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(613), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(611), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(823), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28928] = 6, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(558), 17, - ts_builtin_sym_end, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - sym_float, - sym__doc_comment_line, - ACTIONS(556), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31140] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(709), 1, + anon_sym_LPAREN, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(823), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [28993] = 18, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(594), 1, - anon_sym_COLON, - ACTIONS(621), 1, - anon_sym_RBRACE, - ACTIONS(532), 2, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, - sym_float, - sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31250] = 27, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LPAREN, + ACTIONS(31), 1, anon_sym_LBRACK, + ACTIONS(33), 1, anon_sym_match, + ACTIONS(35), 1, anon_sym_if, - anon_sym_handle, + ACTIONS(39), 1, anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, + ACTIONS(47), 1, anon_sym_send, + ACTIONS(49), 1, anon_sym_recv, + ACTIONS(51), 1, anon_sym_perform, + ACTIONS(53), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(63), 1, + sym_float, + ACTIONS(358), 1, + sym_identifier, + ACTIONS(370), 1, + anon_sym_fn, + ACTIONS(376), 1, + anon_sym_handle, + ACTIONS(380), 1, + anon_sym_await, + ACTIONS(382), 1, + anon_sym_spawn, + ACTIONS(384), 1, + anon_sym_yield, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(751), 1, + anon_sym_PIPE, + STATE(39), 1, + sym_qualified_path, + STATE(773), 1, + sym_expression, + ACTIONS(61), 2, anon_sym_true, anon_sym_false, + ACTIONS(65), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [29082] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(626), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(378), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(624), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + STATE(78), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(60), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(62), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31360] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(884), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31470] = 27, + ACTIONS(386), 1, sym_identifier, - [29141] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(510), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(508), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(886), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31580] = 27, + ACTIONS(386), 1, sym_identifier, - [29200] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(609), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(607), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(887), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31690] = 27, + ACTIONS(386), 1, sym_identifier, - [29259] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(518), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(516), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(890), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31800] = 27, + ACTIONS(386), 1, sym_identifier, - [29318] = 16, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(630), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(628), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(913), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [31910] = 27, + ACTIONS(386), 1, sym_identifier, - [29403] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(626), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(624), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(895), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32020] = 27, + ACTIONS(386), 1, sym_identifier, - [29462] = 18, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(594), 1, - anon_sym_COLON, - ACTIONS(632), 1, - anon_sym_RBRACE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, - sym_float, - sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(896), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32130] = 27, + ACTIONS(386), 1, sym_identifier, - [29551] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(635), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(637), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(897), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32240] = 27, + ACTIONS(386), 1, sym_identifier, - [29610] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(641), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(639), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(899), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32350] = 27, + ACTIONS(386), 1, sym_identifier, - [29669] = 16, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(645), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(643), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [29754] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(498), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(426), 1, sym_float, - sym__doc_comment_line, - ACTIONS(496), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(444), 1, anon_sym_LBRACK, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, + STATE(721), 1, + sym_qualified_path, + STATE(900), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32460] = 27, + ACTIONS(386), 1, sym_identifier, - [29813] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(470), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(472), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(903), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32570] = 27, + ACTIONS(386), 1, sym_identifier, - [29872] = 16, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(649), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(647), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(904), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32680] = 27, + ACTIONS(386), 1, sym_identifier, - [29957] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(651), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(653), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(905), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32790] = 27, + ACTIONS(386), 1, sym_identifier, - [30016] = 16, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(388), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(657), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(655), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(906), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [32900] = 27, + ACTIONS(386), 1, sym_identifier, - [30101] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(572), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(570), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(908), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [30160] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(576), 20, - ts_builtin_sym_end, - anon_sym_DOT, - anon_sym_LPAREN, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [33010] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(574), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, + anon_sym_match, + ACTIONS(402), 1, + anon_sym_if, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, + anon_sym_select, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, + anon_sym_send, + ACTIONS(418), 1, + anon_sym_recv, + ACTIONS(420), 1, + anon_sym_perform, + ACTIONS(422), 1, + anon_sym_resume, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(444), 1, anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(924), 1, + sym_expression, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [33120] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(926), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [33230] = 27, + ACTIONS(386), 1, sym_identifier, - [30219] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(500), 20, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(388), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, + anon_sym_match, + ACTIONS(402), 1, + anon_sym_if, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, + anon_sym_select, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, + anon_sym_send, + ACTIONS(418), 1, + anon_sym_recv, + ACTIONS(420), 1, + anon_sym_perform, + ACTIONS(422), 1, + anon_sym_resume, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(909), 1, + sym_expression, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - sym__doc_comment_line, - ACTIONS(502), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, + ACTIONS(428), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [33340] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, + anon_sym_match, + ACTIONS(402), 1, + anon_sym_if, + ACTIONS(404), 1, + anon_sym_handle, + ACTIONS(406), 1, + anon_sym_select, + ACTIONS(410), 1, + anon_sym_await, + ACTIONS(412), 1, + anon_sym_spawn, + ACTIONS(414), 1, + anon_sym_yield, + ACTIONS(416), 1, + anon_sym_send, + ACTIONS(418), 1, + anon_sym_recv, + ACTIONS(420), 1, + anon_sym_perform, + ACTIONS(422), 1, + anon_sym_resume, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, + ACTIONS(444), 1, anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(911), 1, + sym_expression, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, + sym_integer, + sym_string, + sym_interpolated_string, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [33450] = 27, + ACTIONS(386), 1, + sym_identifier, + ACTIONS(388), 1, + anon_sym_LBRACE, + ACTIONS(390), 1, + anon_sym_fn, + ACTIONS(392), 1, + anon_sym_LPAREN, + ACTIONS(400), 1, anon_sym_match, + ACTIONS(402), 1, anon_sym_if, + ACTIONS(404), 1, anon_sym_handle, + ACTIONS(406), 1, anon_sym_select, - anon_sym_SLASH, + ACTIONS(410), 1, anon_sym_await, + ACTIONS(412), 1, anon_sym_spawn, + ACTIONS(414), 1, anon_sym_yield, + ACTIONS(416), 1, anon_sym_send, + ACTIONS(418), 1, anon_sym_recv, + ACTIONS(420), 1, anon_sym_perform, + ACTIONS(422), 1, anon_sym_resume, - anon_sym_module, + ACTIONS(426), 1, + sym_float, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(442), 1, + anon_sym_PIPE, + ACTIONS(444), 1, + anon_sym_LBRACK, + STATE(721), 1, + sym_qualified_path, + STATE(930), 1, + sym_expression, + ACTIONS(424), 2, anon_sym_true, anon_sym_false, + ACTIONS(408), 3, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(428), 3, sym_integer, sym_string, sym_interpolated_string, - sym_identifier, - [30278] = 3, + STATE(723), 3, + sym_list_literal, + sym_map_literal, + sym_boolean, + STATE(724), 10, + sym_match_expression, + sym_if_expression, + sym_handler_expression, + sym_select_expression, + sym_ternary_expression, + sym_binary_expression, + sym_unary_expression, + sym_pipe_expression, + sym_call_expression, + sym_primary_expression, + STATE(725), 13, + sym_spawn_expression, + sym_yield_expression, + sym_await_call, + sym_send_call, + sym_recv_call, + sym_perform_expression, + sym_resume_expression, + sym_type_constructor, + sym_update_expression, + sym_block, + sym_object_literal, + sym_lambda_expression, + sym_literal, + [33560] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(546), 20, + ACTIONS(642), 20, anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COLON, + anon_sym_LPAREN, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, @@ -30853,14 +35481,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, anon_sym_PERCENT, anon_sym_PIPE_GT, anon_sym_LBRACK2, sym_float, sym__doc_comment_line, - ACTIONS(548), 31, + ACTIONS(645), 34, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -30884,44 +35512,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30337] = 3, + [33622] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(580), 20, - ts_builtin_sym_end, + ACTIONS(606), 1, anon_sym_DOT, + ACTIONS(608), 1, anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(761), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(578), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(763), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -30932,7 +35576,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -30940,44 +35583,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30396] = 3, + [33709] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(584), 20, - ts_builtin_sym_end, + ACTIONS(606), 1, anon_sym_DOT, + ACTIONS(608), 1, anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(785), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(582), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(787), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -30988,7 +35647,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -30996,55 +35654,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30455] = 16, + [33796] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(554), 4, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(785), 3, + anon_sym_RBRACE, + sym_float, + sym__doc_comment_line, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(661), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(659), 28, + ACTIONS(787), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31065,44 +35725,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30540] = 3, + [33883] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(663), 20, - ts_builtin_sym_end, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(791), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(665), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(789), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31113,7 +35789,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31121,44 +35796,61 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30599] = 3, + [33970] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(522), 20, - ts_builtin_sym_end, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, + ACTIONS(668), 1, anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(520), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31169,7 +35861,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31177,44 +35868,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30658] = 3, + [34059] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(544), 20, - ts_builtin_sym_end, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(795), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(542), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(793), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31225,7 +35932,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31233,44 +35939,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30717] = 3, + [34146] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(635), 20, + ACTIONS(606), 1, anon_sym_DOT, - anon_sym_COLON, + ACTIONS(608), 1, anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(797), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(637), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(799), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31281,7 +36003,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31289,44 +36010,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30776] = 3, + [34233] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(651), 20, + ACTIONS(606), 1, anon_sym_DOT, - anon_sym_COLON, + ACTIONS(608), 1, anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(801), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(653), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(803), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31337,7 +36074,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31345,44 +36081,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30835] = 3, + [34320] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(641), 20, - ts_builtin_sym_end, + ACTIONS(606), 1, anon_sym_DOT, + ACTIONS(608), 1, anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(805), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(639), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(807), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31393,7 +36145,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31401,44 +36152,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30894] = 3, + [34407] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(667), 20, - ts_builtin_sym_end, + ACTIONS(606), 1, anon_sym_DOT, + ACTIONS(608), 1, anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(809), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(669), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(811), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31449,7 +36216,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31457,44 +36223,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [30953] = 3, + [34494] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(466), 20, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(815), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(468), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(813), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31505,7 +36287,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31513,55 +36294,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31012] = 16, + [34581] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(554), 4, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(819), 3, + anon_sym_RBRACE, + sym_float, + sym__doc_comment_line, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(673), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(671), 28, + ACTIONS(817), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31582,44 +36365,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31097] = 3, + [34668] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(663), 20, + ACTIONS(606), 1, anon_sym_DOT, - anon_sym_COLON, + ACTIONS(608), 1, anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(665), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31630,7 +36429,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31638,44 +36436,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31156] = 3, + [34755] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(667), 20, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(823), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(669), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(821), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31686,7 +36500,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31694,44 +36507,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31215] = 3, + [34842] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(440), 20, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(827), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(438), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(825), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31742,7 +36571,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31750,55 +36578,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31274] = 16, + [34929] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(554), 4, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(829), 3, + ts_builtin_sym_end, + sym_float, + sym__doc_comment_line, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(677), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(675), 28, + ACTIONS(831), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -31819,44 +36649,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31359] = 3, + [35016] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(514), 20, - ts_builtin_sym_end, + ACTIONS(606), 1, anon_sym_DOT, + ACTIONS(608), 1, anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(791), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(512), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(789), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31867,7 +36713,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31875,44 +36720,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31418] = 3, + [35103] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(601), 20, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(835), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(604), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(833), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31923,7 +36784,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31931,48 +36791,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31477] = 7, + [35190] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(681), 16, - anon_sym_COLON, + ACTIONS(765), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(771), 1, anon_sym_QMARK, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, + ACTIONS(775), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(721), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(679), 31, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(719), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -31983,7 +36855,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -31991,44 +36862,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31544] = 3, + [35277] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(685), 20, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(839), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(683), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(837), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -32039,7 +36926,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -32047,55 +36933,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31603] = 16, + [35364] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(554), 4, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(841), 3, + ts_builtin_sym_end, + sym_float, + sym__doc_comment_line, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(689), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(687), 28, + ACTIONS(843), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32116,44 +37004,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31688] = 3, + [35451] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(484), 20, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(801), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(486), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(803), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -32164,7 +37068,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -32172,55 +37075,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31747] = 16, + [35538] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(554), 4, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(847), 3, + anon_sym_RBRACE, + sym_float, + sym__doc_comment_line, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(693), 4, - anon_sym_COLON, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(691), 28, + ACTIONS(845), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32241,44 +37146,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31832] = 3, + [35625] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(685), 20, - ts_builtin_sym_end, + ACTIONS(664), 1, anon_sym_DOT, - anon_sym_LPAREN, + ACTIONS(666), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, anon_sym_PIPE_GT, + ACTIONS(693), 1, anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(797), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(683), 31, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(799), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -32289,7 +37210,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -32297,50 +37217,60 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31891] = 9, + [35712] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, + ACTIONS(765), 1, + anon_sym_LBRACE, + ACTIONS(771), 1, + anon_sym_QMARK, + ACTIONS(773), 1, + anon_sym_PIPE_PIPE, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, anon_sym_SLASH, - ACTIONS(699), 1, + ACTIONS(783), 1, anon_sym_PIPE_GT, - ACTIONS(695), 2, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(528), 13, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(737), 3, ts_builtin_sym_end, - anon_sym_LBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + sym_float, + sym__doc_comment_line, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 30, + ACTIONS(735), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -32358,54 +37288,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [31961] = 16, + [35799] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(701), 3, - ts_builtin_sym_end, + ACTIONS(805), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(703), 28, + ACTIONS(807), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32426,54 +37359,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32045] = 16, + [35886] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(657), 3, - ts_builtin_sym_end, + ACTIONS(809), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(655), 28, + ACTIONS(811), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32494,54 +37430,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32129] = 16, + [35973] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(719), 3, + ACTIONS(849), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(721), 28, + ACTIONS(851), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32562,55 +37501,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32213] = 17, + [36060] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(723), 1, - anon_sym_RBRACE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(599), 2, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(853), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(855), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32631,54 +37572,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32299] = 16, + [36147] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(661), 3, - ts_builtin_sym_end, + ACTIONS(829), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(659), 28, + ACTIONS(831), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32699,54 +37643,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32383] = 16, + [36234] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(726), 3, - ts_builtin_sym_end, + ACTIONS(841), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(728), 28, + ACTIONS(843), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32767,54 +37714,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32467] = 16, + [36321] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(730), 3, + ACTIONS(857), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(732), 28, + ACTIONS(859), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32835,54 +37785,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32551] = 16, + [36408] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(734), 3, - ts_builtin_sym_end, + ACTIONS(849), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(736), 28, + ACTIONS(851), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32903,54 +37856,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32635] = 16, + [36495] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(738), 3, - ts_builtin_sym_end, + ACTIONS(853), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(740), 28, + ACTIONS(855), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -32971,54 +37927,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32719] = 16, + [36582] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(673), 3, + ACTIONS(861), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(671), 28, + ACTIONS(863), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33039,54 +37998,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32803] = 16, + [36669] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(742), 3, - ts_builtin_sym_end, + ACTIONS(857), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(744), 28, + ACTIONS(859), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33107,54 +38069,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32887] = 16, + [36756] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(746), 3, - ts_builtin_sym_end, + ACTIONS(861), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(748), 28, + ACTIONS(863), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33175,54 +38140,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [32971] = 16, + [36843] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(865), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(677), 3, - ts_builtin_sym_end, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(675), 28, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33243,54 +38212,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33055] = 16, + [36932] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(750), 3, - ts_builtin_sym_end, + ACTIONS(870), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(752), 28, + ACTIONS(868), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33311,54 +38283,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33139] = 16, + [37019] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(754), 3, - ts_builtin_sym_end, + ACTIONS(874), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(756), 28, + ACTIONS(872), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33379,54 +38354,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33223] = 16, + [37106] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(758), 3, + ACTIONS(795), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(760), 28, + ACTIONS(793), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33447,54 +38425,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33307] = 16, + [37193] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(762), 3, - ts_builtin_sym_end, + ACTIONS(878), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(764), 28, + ACTIONS(876), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33515,54 +38496,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33391] = 16, + [37280] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(766), 3, + ACTIONS(870), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(768), 28, + ACTIONS(868), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33583,54 +38567,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33475] = 16, + [37367] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(770), 3, - ts_builtin_sym_end, + ACTIONS(882), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(772), 28, + ACTIONS(880), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33651,54 +38638,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33559] = 16, + [37454] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(774), 3, + ACTIONS(874), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(776), 28, + ACTIONS(872), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33719,54 +38709,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33643] = 16, + [37541] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(778), 3, - ts_builtin_sym_end, + ACTIONS(886), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(780), 28, + ACTIONS(884), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33787,54 +38780,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33727] = 16, + [37628] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(782), 3, - ts_builtin_sym_end, + ACTIONS(761), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(784), 28, + ACTIONS(763), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33855,54 +38851,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33811] = 16, + [37715] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(786), 3, - ts_builtin_sym_end, + ACTIONS(890), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(788), 28, + ACTIONS(888), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33923,54 +38922,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33895] = 16, + [37802] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(790), 3, - ts_builtin_sym_end, + ACTIONS(894), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(792), 28, + ACTIONS(892), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -33991,54 +38993,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [33979] = 16, + [37889] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(794), 3, - ts_builtin_sym_end, + ACTIONS(898), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(796), 28, + ACTIONS(896), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34059,54 +39064,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34063] = 16, + [37976] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(798), 3, - ts_builtin_sym_end, + ACTIONS(902), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(800), 28, + ACTIONS(900), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34127,54 +39135,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34147] = 16, + [38063] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(802), 3, + ACTIONS(878), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(804), 28, + ACTIONS(876), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34195,54 +39206,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34231] = 16, + [38150] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(806), 3, - ts_builtin_sym_end, + ACTIONS(906), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(808), 28, + ACTIONS(904), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34263,54 +39277,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34315] = 16, + [38237] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(810), 3, - ts_builtin_sym_end, + ACTIONS(910), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(812), 28, + ACTIONS(908), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34331,54 +39348,128 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34399] = 16, + [38324] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(699), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(675), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(914), 3, + anon_sym_RBRACE, + sym_float, + sym__doc_comment_line, + ACTIONS(685), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(912), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [38411] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(683), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(687), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(814), 3, - ts_builtin_sym_end, + ACTIONS(918), 3, + anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(816), 28, + ACTIONS(916), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34399,55 +39490,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34483] = 17, + [38498] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(818), 1, - anon_sym_RBRACE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(599), 2, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(847), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(845), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34468,54 +39561,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34569] = 16, + [38585] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(821), 3, + ACTIONS(920), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(823), 28, + ACTIONS(922), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34536,54 +39632,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34653] = 16, + [38672] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(825), 3, + ACTIONS(882), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(827), 28, + ACTIONS(880), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34604,54 +39703,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34737] = 16, + [38759] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(829), 3, + ACTIONS(886), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(831), 28, + ACTIONS(884), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34672,54 +39774,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34821] = 16, + [38846] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(833), 3, + ACTIONS(733), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(835), 28, + ACTIONS(731), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34740,54 +39845,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34905] = 16, + [38933] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(837), 3, + ACTIONS(890), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(839), 28, + ACTIONS(888), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34808,54 +39916,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [34989] = 16, + [39020] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(841), 3, + ACTIONS(894), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(843), 28, + ACTIONS(892), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34876,54 +39987,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35073] = 16, + [39107] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(845), 3, + ACTIONS(898), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(847), 28, + ACTIONS(896), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -34944,54 +40058,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35157] = 16, + [39194] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(849), 3, + ACTIONS(902), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(851), 28, + ACTIONS(900), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35012,54 +40129,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35241] = 16, + [39281] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(853), 3, + ACTIONS(906), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(855), 28, + ACTIONS(904), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35080,54 +40200,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35325] = 16, + [39368] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(599), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(910), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(908), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35148,54 +40271,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35409] = 16, + [39455] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(859), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(914), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(857), 28, + ACTIONS(912), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35216,54 +40342,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35493] = 16, + [39542] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(863), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(918), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(861), 28, + ACTIONS(916), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35284,54 +40413,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35577] = 16, + [39629] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(859), 3, + ACTIONS(924), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(857), 28, + ACTIONS(926), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35352,54 +40484,119 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35661] = 16, + [39716] = 7, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(699), 15, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, + anon_sym_STAR, anon_sym_QMARK, - ACTIONS(568), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, + anon_sym_PERCENT, + sym_float, + sym__doc_comment_line, + ACTIONS(697), 34, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_LT, + anon_sym_GT, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_SLASH, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [39785] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(867), 3, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 3, anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(865), 28, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35420,54 +40617,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35745] = 16, + [39872] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(701), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(741), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(703), 28, + ACTIONS(739), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35488,54 +40688,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35829] = 16, + [39959] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(719), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(815), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(721), 28, + ACTIONS(813), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35556,54 +40759,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35913] = 16, + [40046] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(709), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(711), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(713), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(867), 3, + ACTIONS(819), 3, ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(865), 28, + ACTIONS(817), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35624,54 +40830,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [35997] = 16, + [40133] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(726), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(703), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(728), 28, + ACTIONS(701), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35692,54 +40901,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36081] = 16, + [40220] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(730), 3, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(920), 3, anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(732), 28, + ACTIONS(922), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35760,35 +40972,101 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36165] = 10, + [40307] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, + ACTIONS(765), 1, + anon_sym_LBRACE, + ACTIONS(771), 1, + anon_sym_QMARK, + ACTIONS(773), 1, + anon_sym_PIPE_PIPE, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, anon_sym_SLASH, - ACTIONS(699), 1, + ACTIONS(783), 1, anon_sym_PIPE_GT, - ACTIONS(695), 2, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(717), 2, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(528), 11, + ACTIONS(707), 3, + ts_builtin_sym_end, + sym_float, + sym__doc_comment_line, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(705), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [40394] = 7, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(606), 1, + anon_sym_DOT, + ACTIONS(608), 1, + anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(713), 15, ts_builtin_sym_end, anon_sym_LBRACE, + anon_sym_STAR, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, @@ -35796,10 +41074,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, sym_float, sym__doc_comment_line, - ACTIONS(524), 30, + ACTIONS(711), 34, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35815,6 +41097,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -35822,54 +41105,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36237] = 16, + [40463] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(928), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(734), 3, - anon_sym_RBRACE, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(736), 28, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -35890,57 +41177,54 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36321] = 16, + [40552] = 10, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(781), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(783), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(767), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(713), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, anon_sym_QMARK, - ACTIONS(568), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(738), 3, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(554), 4, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(740), 28, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 33, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, + anon_sym_LT, + anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -35958,54 +41242,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36405] = 16, + [40627] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(742), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(729), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(744), 28, + ACTIONS(727), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36026,54 +41313,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36489] = 16, + [40714] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(746), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(823), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(748), 28, + ACTIONS(821), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36094,54 +41384,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36573] = 16, + [40801] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(750), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(827), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(752), 28, + ACTIONS(825), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36162,54 +41455,54 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36657] = 16, + [40888] = 13, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, + ACTIONS(775), 1, anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(754), 3, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(756), 28, + ACTIONS(713), 6, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36230,54 +41523,125 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36741] = 16, + [40969] = 12, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(781), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(783), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, + ACTIONS(767), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(769), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(777), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(713), 7, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, - ACTIONS(564), 1, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 31, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_effect, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [41048] = 17, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(664), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, + anon_sym_SLASH, + ACTIONS(691), 1, + anon_sym_PIPE_GT, + ACTIONS(693), 1, + anon_sym_LBRACK2, + ACTIONS(931), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(758), 3, - anon_sym_RBRACE, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(760), 28, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36298,57 +41662,53 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36825] = 16, + [41137] = 9, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(781), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(783), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(767), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(713), 13, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, anon_sym_QMARK, - ACTIONS(568), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(762), 3, - anon_sym_RBRACE, - sym_float, - sym__doc_comment_line, - ACTIONS(554), 4, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(764), 28, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(711), 33, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, + anon_sym_LT, + anon_sym_GT, anon_sym_extern, anon_sym_type, anon_sym_PIPE, @@ -36366,54 +41726,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36909] = 16, + [41210] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(934), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(766), 3, - anon_sym_RBRACE, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(768), 28, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36434,51 +41798,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [36993] = 13, + [41299] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(697), 1, + ACTIONS(765), 1, + anon_sym_LBRACE, + ACTIONS(771), 1, + anon_sym_QMARK, + ACTIONS(773), 1, + anon_sym_PIPE_PIPE, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, anon_sym_SLASH, - ACTIONS(699), 1, + ACTIONS(783), 1, anon_sym_PIPE_GT, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 2, + ACTIONS(779), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(715), 4, + ACTIONS(937), 3, + ts_builtin_sym_end, + sym_float, + sym__doc_comment_line, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(528), 6, - ts_builtin_sym_end, - anon_sym_LBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 28, + ACTIONS(939), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36499,54 +41869,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37071] = 16, + [41386] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(941), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(770), 3, - anon_sym_RBRACE, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(772), 28, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36567,118 +41941,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37155] = 12, + [41475] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(528), 7, - ts_builtin_sym_end, + ACTIONS(666), 1, anon_sym_LBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 28, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [37231] = 16, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(774), 3, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(937), 3, anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(776), 28, + ACTIONS(939), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36699,113 +42012,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37315] = 7, + [41562] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(528), 15, - ts_builtin_sym_end, + ACTIONS(666), 1, anon_sym_LBRACE, + ACTIONS(677), 1, + anon_sym_LPAREN, + ACTIONS(679), 1, anon_sym_QMARK, + ACTIONS(681), 1, anon_sym_PIPE_PIPE, + ACTIONS(683), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - sym_float, - sym__doc_comment_line, - ACTIONS(524), 31, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_LT, - anon_sym_GT, - anon_sym_extern, - anon_sym_type, - anon_sym_PIPE, - anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, + ACTIONS(689), 1, anon_sym_SLASH, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [37381] = 16, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(944), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(778), 3, - anon_sym_RBRACE, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(780), 28, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36826,54 +42084,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37465] = 16, + [41651] = 17, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(947), 1, + anon_sym_RBRACE, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(782), 3, - anon_sym_RBRACE, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(695), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(784), 28, + ACTIONS(662), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36894,54 +42156,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37549] = 16, + [41740] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(786), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(745), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(788), 28, + ACTIONS(743), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -36962,54 +42227,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37633] = 16, + [41827] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(790), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(835), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(792), 28, + ACTIONS(833), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -37030,54 +42298,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37717] = 16, + [41914] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(794), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(839), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(796), 28, + ACTIONS(837), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -37098,54 +42369,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37801] = 16, + [42001] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(798), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(725), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(800), 28, + ACTIONS(723), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -37166,54 +42440,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37885] = 16, + [42088] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(802), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(717), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(804), 28, + ACTIONS(715), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -37234,54 +42511,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [37969] = 16, + [42175] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(765), 1, anon_sym_LBRACE, - ACTIONS(566), 1, + ACTIONS(771), 1, anon_sym_QMARK, - ACTIONS(568), 1, + ACTIONS(773), 1, anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(775), 1, + anon_sym_AMP_AMP, + ACTIONS(781), 1, + anon_sym_SLASH, + ACTIONS(783), 1, + anon_sym_PIPE_GT, + ACTIONS(767), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(769), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(806), 3, - anon_sym_RBRACE, + ACTIONS(779), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(749), 3, + ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(777), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(808), 28, + ACTIONS(747), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -37302,54 +42582,57 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38053] = 16, + [42262] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, + ACTIONS(664), 1, anon_sym_DOT, - ACTIONS(530), 1, + ACTIONS(666), 1, + anon_sym_LBRACE, + ACTIONS(677), 1, anon_sym_LPAREN, - ACTIONS(536), 1, + ACTIONS(679), 1, + anon_sym_QMARK, + ACTIONS(681), 1, + anon_sym_PIPE_PIPE, + ACTIONS(683), 1, + anon_sym_AMP_AMP, + ACTIONS(689), 1, anon_sym_SLASH, - ACTIONS(538), 1, + ACTIONS(691), 1, anon_sym_PIPE_GT, - ACTIONS(540), 1, + ACTIONS(693), 1, anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, - anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(534), 2, + ACTIONS(671), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(550), 2, + ACTIONS(675), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(810), 3, + ACTIONS(687), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(924), 3, anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, + ACTIONS(685), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(812), 28, + ACTIONS(926), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -37370,63 +42653,45 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38137] = 16, + [42349] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(950), 1, + anon_sym_COLON_COLON, + STATE(468), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(469), 12, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_RBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(814), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(816), 28, + ACTIONS(471), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37438,63 +42703,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38221] = 16, + [42406] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(953), 1, + anon_sym_COLON_COLON, + STATE(468), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(432), 12, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_RBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(821), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(823), 28, + ACTIONS(434), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37506,63 +42755,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38305] = 16, + [42463] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(469), 13, + ts_builtin_sym_end, + anon_sym_COLON_COLON, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_RBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(825), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(827), 28, + ACTIONS(471), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37574,63 +42804,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38389] = 16, + [42515] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(953), 1, + anon_sym_COLON_COLON, + ACTIONS(959), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + STATE(469), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(955), 10, + ts_builtin_sym_end, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(829), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(831), 28, + ACTIONS(957), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37642,63 +42856,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38473] = 16, + [42572] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(961), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(833), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(835), 28, + ACTIONS(963), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37710,63 +42902,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38557] = 16, + [42622] = 7, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(953), 1, + anon_sym_COLON_COLON, + ACTIONS(969), 1, + anon_sym_LT, + ACTIONS(971), 1, + anon_sym_LBRACK, + STATE(469), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(965), 9, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(837), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(839), 28, + ACTIONS(967), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37778,63 +42955,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38641] = 16, + [42680] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(974), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(841), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(843), 28, + ACTIONS(976), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37846,63 +43000,42 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38725] = 16, + [42730] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(978), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(845), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(847), 28, + ACTIONS(980), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37914,63 +43047,42 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38809] = 16, + [42780] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(982), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(849), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(851), 28, + ACTIONS(984), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -37982,63 +43094,46 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38893] = 16, + [42830] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(986), 1, + anon_sym_COLON_COLON, + STATE(478), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(432), 11, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, + anon_sym_RBRACE, anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(863), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(861), 28, + ACTIONS(434), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38050,63 +43145,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [38977] = 16, + [42884] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(988), 1, + anon_sym_COLON_COLON, + STATE(478), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(469), 11, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(532), 2, + anon_sym_RBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(853), 3, - anon_sym_RBRACE, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(855), 28, + ACTIONS(471), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38118,63 +43194,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39061] = 16, + [42938] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(995), 1, + anon_sym_PIPE, + STATE(479), 1, + aux_sym_union_type_repeat1, + ACTIONS(991), 10, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(562), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(560), 28, + ACTIONS(993), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38186,58 +43242,49 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39145] = 7, + [42992] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1002), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(681), 15, + STATE(540), 1, + aux_sym_legacy_import_path_repeat1, + ACTIONS(998), 11, ts_builtin_sym_end, + anon_sym_COLON_COLON, anon_sym_LBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, sym_float, sym__doc_comment_line, - ACTIONS(679), 31, + ACTIONS(1000), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, - anon_sym_LT, - anon_sym_GT, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_SLASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -38245,63 +43292,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39211] = 16, + [43046] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1004), 1, anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + STATE(528), 1, + aux_sym_legacy_import_path_repeat1, + ACTIONS(998), 11, + anon_sym_COLON_COLON, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(689), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(687), 28, + ACTIONS(1000), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38313,63 +43341,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39295] = 16, + [43100] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(1010), 1, + anon_sym_PIPE, + STATE(479), 1, + aux_sym_union_type_repeat1, + ACTIONS(1006), 10, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(693), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(691), 28, + ACTIONS(1008), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38381,63 +43389,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39379] = 16, + [43154] = 7, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(953), 1, + anon_sym_COLON_COLON, + ACTIONS(959), 1, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, + ACTIONS(969), 1, anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + STATE(469), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(955), 9, + ts_builtin_sym_end, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(613), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(611), 28, + ACTIONS(957), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38449,63 +43441,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39463] = 16, + [43212] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(1016), 1, + anon_sym_where, + STATE(517), 1, + sym_type_validation, + ACTIONS(1012), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(630), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(628), 28, + ACTIONS(1014), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38517,64 +43489,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39547] = 17, + [43266] = 7, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(986), 1, + anon_sym_COLON_COLON, + ACTIONS(1018), 1, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(869), 1, + ACTIONS(1020), 1, + anon_sym_LT, + STATE(477), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(955), 9, anon_sym_RBRACE, - ACTIONS(532), 2, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(957), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38586,64 +43541,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39633] = 17, + [43324] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(1010), 1, + anon_sym_PIPE, + STATE(482), 1, + aux_sym_union_type_repeat1, + ACTIONS(1022), 10, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(872), 1, anon_sym_RBRACE, - ACTIONS(532), 2, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(1024), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38655,63 +43589,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39719] = 16, + [43378] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(1016), 1, + anon_sym_where, + STATE(518), 1, + sym_type_validation, + ACTIONS(1026), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(645), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(643), 28, + ACTIONS(1028), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38723,64 +43638,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39803] = 17, + [43432] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(1030), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(875), 1, anon_sym_RBRACE, - ACTIONS(532), 2, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(1032), 31, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38792,64 +43684,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39889] = 17, + [43482] = 7, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(986), 1, + anon_sym_COLON_COLON, + ACTIONS(1020), 1, + anon_sym_LT, + ACTIONS(1034), 1, + anon_sym_LBRACK, + STATE(477), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(965), 9, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(878), 1, anon_sym_RBRACE, - ACTIONS(532), 2, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(967), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, + anon_sym_where, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38861,64 +43737,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [39975] = 17, + [43540] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(1016), 1, + anon_sym_where, + STATE(593), 1, + sym_type_validation, + ACTIONS(1037), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(881), 1, anon_sym_RBRACE, - ACTIONS(532), 2, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(1039), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38930,63 +43785,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40061] = 16, + [43594] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(1016), 1, + anon_sym_where, + STATE(520), 1, + sym_type_validation, + ACTIONS(1041), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(599), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(1043), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -38998,63 +43834,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40145] = 16, + [43648] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(697), 1, - anon_sym_SLASH, - ACTIONS(699), 1, - anon_sym_PIPE_GT, - ACTIONS(707), 1, + ACTIONS(1049), 1, + anon_sym_COLON_COLON, + STATE(497), 1, + aux_sym_import_target_repeat1, + ACTIONS(1045), 10, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(709), 1, - anon_sym_QMARK, - ACTIONS(711), 1, - anon_sym_PIPE_PIPE, - ACTIONS(713), 1, - anon_sym_AMP_AMP, - ACTIONS(695), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(705), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(717), 2, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(649), 3, - ts_builtin_sym_end, sym_float, sym__doc_comment_line, - ACTIONS(715), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(647), 28, + ACTIONS(1047), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -39066,64 +43883,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40229] = 17, + [43701] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(526), 1, - anon_sym_DOT, - ACTIONS(530), 1, - anon_sym_LPAREN, - ACTIONS(536), 1, - anon_sym_SLASH, - ACTIONS(538), 1, - anon_sym_PIPE_GT, - ACTIONS(540), 1, - anon_sym_LBRACK2, - ACTIONS(552), 1, - anon_sym_AMP_AMP, - ACTIONS(564), 1, + ACTIONS(1051), 11, + ts_builtin_sym_end, anon_sym_LBRACE, - ACTIONS(566), 1, - anon_sym_QMARK, - ACTIONS(568), 1, - anon_sym_PIPE_PIPE, - ACTIONS(621), 1, anon_sym_RBRACE, - ACTIONS(532), 2, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(534), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(550), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(599), 2, sym_float, sym__doc_comment_line, - ACTIONS(554), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(592), 28, + ACTIONS(1053), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_PIPE, anon_sym_effect, - anon_sym_BANG, - anon_sym_LBRACK, anon_sym_match, anon_sym_if, anon_sym_handle, @@ -39135,34 +43927,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40315] = 5, + [43750] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(888), 1, - anon_sym_where, - STATE(525), 1, - sym_type_validation, - ACTIONS(884), 11, + ACTIONS(1059), 1, + anon_sym_COLON_COLON, + STATE(494), 1, + aux_sym_import_target_repeat1, + ACTIONS(1055), 10, ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(886), 25, + ACTIONS(1057), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39180,39 +43977,42 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40365] = 5, + [43803] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(894), 1, - anon_sym_PIPE, - STATE(455), 1, - aux_sym_union_type_repeat1, - ACTIONS(890), 10, - ts_builtin_sym_end, - anon_sym_LPAREN, + ACTIONS(1062), 1, + anon_sym_COLON_COLON, + STATE(495), 1, + aux_sym_import_target_repeat1, + ACTIONS(1055), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(892), 26, + ACTIONS(1057), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -39225,34 +44025,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40415] = 5, + [43856] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(888), 1, - anon_sym_where, - STATE(505), 1, - sym_type_validation, - ACTIONS(897), 11, + ACTIONS(1065), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(899), 25, + ACTIONS(1067), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39270,39 +44069,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40465] = 5, + [43905] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(905), 1, - anon_sym_PIPE, - STATE(458), 1, - aux_sym_union_type_repeat1, - ACTIONS(901), 10, + ACTIONS(1049), 1, + anon_sym_COLON_COLON, + STATE(494), 1, + aux_sym_import_target_repeat1, + ACTIONS(1069), 10, ts_builtin_sym_end, - anon_sym_LPAREN, anon_sym_LBRACE, - anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(903), 26, + ACTIONS(1071), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -39315,33 +44119,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40515] = 5, + [43958] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(905), 1, - anon_sym_PIPE, - STATE(455), 1, - aux_sym_union_type_repeat1, - ACTIONS(907), 10, - ts_builtin_sym_end, - anon_sym_LPAREN, + ACTIONS(469), 12, + anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LT, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(909), 26, + ACTIONS(471), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39360,34 +44165,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40565] = 5, + [44007] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(888), 1, - anon_sym_where, - STATE(517), 1, - sym_type_validation, - ACTIONS(911), 11, + ACTIONS(1073), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(913), 25, + ACTIONS(1075), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39405,34 +44209,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40615] = 5, + [44056] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(888), 1, - anon_sym_where, - STATE(478), 1, - sym_type_validation, - ACTIONS(915), 11, - ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1077), 1, + anon_sym_COLON_COLON, + STATE(495), 1, + aux_sym_import_target_repeat1, + ACTIONS(1069), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(917), 25, + ACTIONS(1071), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39450,30 +44259,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40665] = 3, + [44109] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(919), 11, + ACTIONS(991), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(921), 26, + ACTIONS(993), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39492,38 +44304,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40710] = 5, + [44158] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(927), 1, - anon_sym_DOT, - STATE(466), 1, - aux_sym_import_statement_repeat1, - ACTIONS(923), 10, - ts_builtin_sym_end, + ACTIONS(986), 1, + anon_sym_COLON_COLON, + ACTIONS(1018), 1, + anon_sym_LBRACE, + STATE(477), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(955), 9, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(925), 25, + ACTIONS(957), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -39536,31 +44354,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40759] = 4, + [44213] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(933), 1, - anon_sym_LBRACE, - ACTIONS(929), 10, + ACTIONS(1079), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(931), 26, + ACTIONS(1081), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39579,38 +44399,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40806] = 5, + [44262] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(935), 1, - anon_sym_where, - STATE(549), 1, - sym_type_validation, - ACTIONS(915), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1083), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(917), 25, + ACTIONS(1085), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -39623,38 +44445,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40855] = 5, + [44311] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(937), 1, - anon_sym_PIPE, - STATE(465), 1, - aux_sym_union_type_repeat1, - ACTIONS(890), 9, - anon_sym_LPAREN, + ACTIONS(1087), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(892), 26, + ACTIONS(1089), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -39667,33 +44490,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40904] = 5, + [44360] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(927), 1, - anon_sym_DOT, - STATE(477), 1, - aux_sym_import_statement_repeat1, - ACTIONS(940), 10, + ACTIONS(1095), 1, + anon_sym_COLON_COLON, + ACTIONS(1097), 1, + anon_sym_as, + STATE(642), 1, + sym_import_tail, + ACTIONS(1091), 10, ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(942), 25, + ACTIONS(1093), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39711,38 +44541,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [40953] = 5, + [44415] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(935), 1, - anon_sym_where, - STATE(567), 1, - sym_type_validation, - ACTIONS(897), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1099), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(899), 25, + ACTIONS(1101), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -39755,33 +44586,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41002] = 5, + [44464] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(944), 1, - anon_sym_DOT, - STATE(469), 1, - aux_sym_import_statement_repeat1, - ACTIONS(923), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1103), 1, + anon_sym_COLON_COLON, + ACTIONS(1105), 1, + anon_sym_as, + STATE(624), 1, + sym_import_tail, + ACTIONS(1091), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(925), 25, + ACTIONS(1093), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39799,33 +44636,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41051] = 5, + [44519] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(944), 1, - anon_sym_DOT, - STATE(470), 1, - aux_sym_import_statement_repeat1, - ACTIONS(940), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1077), 1, + anon_sym_COLON_COLON, + STATE(500), 1, + aux_sym_import_target_repeat1, + ACTIONS(1045), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(942), 25, + ACTIONS(1047), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39843,38 +44684,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41100] = 5, + [44572] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(948), 1, - anon_sym_DOT, - STATE(470), 1, - aux_sym_import_statement_repeat1, - ACTIONS(951), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(959), 1, anon_sym_LBRACE, + ACTIONS(955), 10, + ts_builtin_sym_end, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(946), 25, + ACTIONS(957), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -39887,33 +44730,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41149] = 5, + [44623] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(935), 1, - anon_sym_where, - STATE(536), 1, - sym_type_validation, - ACTIONS(884), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1107), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(886), 25, + ACTIONS(1109), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -39931,38 +44775,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41198] = 5, + [44672] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(953), 1, - anon_sym_PIPE, - STATE(475), 1, - aux_sym_union_type_repeat1, - ACTIONS(901), 9, - anon_sym_LPAREN, + ACTIONS(1111), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(903), 26, + ACTIONS(1113), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -39975,33 +44821,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41247] = 5, + [44721] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(935), 1, - anon_sym_where, - STATE(580), 1, - sym_type_validation, - ACTIONS(911), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1115), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(913), 25, + ACTIONS(1117), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40019,36 +44867,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41296] = 3, + [44770] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(955), 11, + ACTIONS(1119), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(957), 26, + ACTIONS(1121), 30, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -40061,38 +44913,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41341] = 5, + [44819] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(953), 1, - anon_sym_PIPE, - STATE(465), 1, - aux_sym_union_type_repeat1, - ACTIONS(907), 9, - anon_sym_LPAREN, + ACTIONS(1123), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(909), 26, + ACTIONS(1125), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -40105,36 +44959,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41390] = 3, + [44867] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(890), 11, + ACTIONS(1127), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(892), 26, + ACTIONS(1129), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -40147,33 +45004,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41435] = 5, + [44915] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(959), 1, - anon_sym_DOT, - STATE(477), 1, - aux_sym_import_statement_repeat1, - ACTIONS(951), 10, + ACTIONS(1131), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(946), 25, + ACTIONS(1133), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40191,30 +45049,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41484] = 3, + [44963] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(962), 11, + ACTIONS(1135), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(964), 25, + ACTIONS(1137), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40232,30 +45094,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41528] = 3, + [45011] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(966), 11, + ACTIONS(1139), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(968), 25, + ACTIONS(1141), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40273,30 +45139,82 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41572] = 3, + [45059] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(970), 11, + ACTIONS(1143), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1145), 29, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [45107] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1147), 1, + anon_sym_where, + STATE(696), 1, + sym_type_validation, + ACTIONS(1026), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(972), 25, + ACTIONS(1028), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40314,30 +45232,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41616] = 3, + [45159] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(974), 11, + ACTIONS(1149), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(976), 25, + ACTIONS(1151), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40355,30 +45276,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41660] = 3, + [45207] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(978), 11, + ACTIONS(1153), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(980), 25, + ACTIONS(1155), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40396,30 +45321,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41704] = 3, + [45255] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(982), 11, + ACTIONS(1157), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(984), 25, + ACTIONS(1159), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40437,30 +45366,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41748] = 3, + [45303] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(986), 11, + ACTIONS(1161), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(988), 25, + ACTIONS(1163), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40478,30 +45411,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41792] = 3, + [45351] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(990), 11, + ACTIONS(1165), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(992), 25, + ACTIONS(1167), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40519,30 +45456,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41836] = 3, + [45399] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(994), 11, + ACTIONS(1169), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(996), 25, + ACTIONS(1171), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40560,32 +45501,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41880] = 5, + [45447] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1002), 1, - anon_sym_LT, ACTIONS(1004), 1, - anon_sym_LBRACK, - ACTIONS(998), 9, - ts_builtin_sym_end, + anon_sym_DOT, + STATE(565), 1, + aux_sym_legacy_import_path_repeat1, + ACTIONS(1175), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1000), 25, + ACTIONS(1173), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40603,30 +45549,78 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41928] = 3, + [45499] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(951), 11, - anon_sym_DOT, + ACTIONS(1177), 11, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1179), 29, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [45547] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1181), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(946), 25, + ACTIONS(1183), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40644,36 +45638,42 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [41972] = 4, + [45595] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1007), 1, + ACTIONS(1147), 1, + anon_sym_where, + STATE(681), 1, + sym_type_validation, + ACTIONS(1037), 10, anon_sym_LBRACE, - ACTIONS(929), 9, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(931), 26, + ACTIONS(1039), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -40686,30 +45686,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42018] = 4, + [45647] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1013), 1, - anon_sym_DASH_GT, - ACTIONS(1009), 9, + ACTIONS(1185), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, + anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1011), 26, + ACTIONS(1187), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40720,7 +45723,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -40728,71 +45730,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42064] = 3, + [45695] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1015), 11, + ACTIONS(1189), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_PLUS, - anon_sym_DASH, - sym_float, - sym__doc_comment_line, - ACTIONS(1017), 25, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_effect, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [42108] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1023), 1, - anon_sym_DASH_GT, - ACTIONS(1021), 9, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, + anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1019), 26, + ACTIONS(1191), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40803,7 +45768,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -40811,30 +45775,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42154] = 3, + [45743] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1025), 11, + ACTIONS(1193), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1027), 25, + ACTIONS(1195), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40852,30 +45820,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42198] = 4, + [45791] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1033), 1, - anon_sym_DASH_GT, - ACTIONS(1029), 9, + ACTIONS(1197), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, + anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1031), 26, + ACTIONS(1199), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -40886,7 +45858,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -40894,41 +45865,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42244] = 4, + [45839] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1035), 1, - anon_sym_DASH_GT, - ACTIONS(1009), 9, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1020), 1, + anon_sym_LT, + ACTIONS(1034), 1, + anon_sym_LBRACK, + ACTIONS(965), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, - anon_sym_LBRACK, anon_sym_PLUS, + anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1011), 26, + ACTIONS(967), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -40936,35 +45913,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42290] = 3, + [45891] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(955), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1201), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(957), 26, + ACTIONS(1203), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -40977,29 +45957,36 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42334] = 3, + [45939] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(890), 10, - anon_sym_LPAREN, + ACTIONS(1205), 1, anon_sym_PIPE, + STATE(538), 1, + aux_sym_union_type_repeat1, + ACTIONS(991), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(892), 26, + ACTIONS(993), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41018,30 +46005,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42378] = 3, + [45991] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1037), 11, - ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(998), 11, + anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1039), 25, + ACTIONS(1000), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41059,30 +46050,36 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42422] = 4, + [46039] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1045), 1, - anon_sym_DASH_GT, - ACTIONS(1043), 9, + ACTIONS(1002), 1, + anon_sym_DOT, + STATE(561), 1, + aux_sym_legacy_import_path_repeat1, + ACTIONS(1175), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, + anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1041), 26, + ACTIONS(1173), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41093,7 +46090,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -41101,35 +46097,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42468] = 3, + [46091] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1047), 11, + ACTIONS(969), 1, + anon_sym_LT, + ACTIONS(971), 1, + anon_sym_LBRACK, + ACTIONS(965), 9, ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, - anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1049), 25, + ACTIONS(967), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -41142,35 +46144,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42512] = 3, + [46143] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(919), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1208), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(921), 26, + ACTIONS(1210), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, - anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -41183,30 +46188,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42556] = 3, + [46191] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1051), 11, + ACTIONS(1212), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1053), 25, + ACTIONS(1214), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41224,30 +46233,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42600] = 3, + [46239] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1055), 11, + ACTIONS(1216), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1057), 25, + ACTIONS(1218), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41265,30 +46278,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42644] = 4, + [46287] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1059), 1, - anon_sym_DASH_GT, - ACTIONS(1029), 9, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1220), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, + anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1031), 26, + ACTIONS(1222), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41299,7 +46316,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -41307,30 +46323,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42690] = 3, + [46335] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1061), 11, + ACTIONS(1224), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1063), 25, + ACTIONS(1226), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41348,30 +46368,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42734] = 3, + [46383] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1065), 11, + ACTIONS(1228), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1067), 25, + ACTIONS(1230), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41389,30 +46413,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42778] = 3, + [46431] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1069), 11, + ACTIONS(1232), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1071), 25, + ACTIONS(1234), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41430,30 +46458,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42822] = 3, + [46479] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1073), 11, + ACTIONS(1236), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1075), 25, + ACTIONS(1238), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41471,30 +46503,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42866] = 3, + [46527] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1077), 11, + ACTIONS(1240), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1079), 25, + ACTIONS(1242), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41512,35 +46548,42 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42910] = 3, + [46575] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1081), 11, - ts_builtin_sym_end, - anon_sym_LPAREN, + ACTIONS(1244), 1, anon_sym_PIPE, + STATE(538), 1, + aux_sym_union_type_repeat1, + ACTIONS(1006), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1083), 25, + ACTIONS(1008), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -41553,30 +46596,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42954] = 3, + [46627] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1085), 11, + ACTIONS(1246), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1087), 25, + ACTIONS(1248), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41594,30 +46640,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [42998] = 3, + [46675] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1089), 11, + ACTIONS(1250), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1091), 25, + ACTIONS(1252), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41635,30 +46685,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43042] = 3, + [46723] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1093), 11, + ACTIONS(1254), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1095), 25, + ACTIONS(1256), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41676,30 +46730,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43086] = 3, + [46771] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(951), 11, + ACTIONS(1258), 11, ts_builtin_sym_end, - anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(946), 25, + ACTIONS(1260), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41717,30 +46775,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43130] = 3, + [46819] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1097), 11, + ACTIONS(1262), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1099), 25, + ACTIONS(1264), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41758,30 +46820,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43174] = 3, + [46867] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1101), 11, + ACTIONS(998), 11, ts_builtin_sym_end, + anon_sym_COLON_COLON, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1103), 25, + ACTIONS(1000), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41799,30 +46866,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43218] = 3, + [46915] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1105), 11, + ACTIONS(1266), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1107), 25, + ACTIONS(1268), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41840,30 +46910,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43262] = 3, + [46963] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1109), 11, + ACTIONS(1270), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1111), 25, + ACTIONS(1272), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41881,32 +46955,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43306] = 5, + [47011] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1113), 1, - anon_sym_LT, - ACTIONS(1115), 1, - anon_sym_LBRACK, - ACTIONS(998), 9, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1274), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1000), 25, + ACTIONS(1276), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41924,30 +47000,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43354] = 3, + [47059] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1118), 11, + ACTIONS(1282), 1, + anon_sym_DOT, + STATE(561), 1, + aux_sym_legacy_import_path_repeat1, + ACTIONS(1278), 10, ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1120), 25, + ACTIONS(1280), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -41965,30 +47048,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43398] = 3, + [47111] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1122), 11, + ACTIONS(1285), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1124), 25, + ACTIONS(1287), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42006,30 +47092,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43442] = 3, + [47159] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1126), 11, + ACTIONS(1289), 11, ts_builtin_sym_end, + anon_sym_COLON_COLON, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1128), 25, + ACTIONS(1291), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42047,30 +47138,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43486] = 3, + [47207] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1130), 11, + ACTIONS(1293), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1132), 25, + ACTIONS(1295), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42088,30 +47182,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43530] = 4, + [47255] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1134), 1, - anon_sym_DASH_GT, - ACTIONS(1021), 9, - ts_builtin_sym_end, + ACTIONS(1297), 1, + anon_sym_DOT, + STATE(565), 1, + aux_sym_legacy_import_path_repeat1, + ACTIONS(1278), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, + anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1019), 26, + ACTIONS(1280), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42122,7 +47223,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -42130,30 +47230,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43576] = 3, + [47307] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1136), 11, - ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1289), 11, + anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1138), 25, + ACTIONS(1291), 29, anon_sym_import, + anon_sym_as, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42171,30 +47275,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43620] = 3, + [47355] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1140), 11, + ACTIONS(1300), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1142), 25, + ACTIONS(1302), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42212,30 +47319,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43664] = 4, + [47403] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1144), 1, - anon_sym_DASH_GT, - ACTIONS(1043), 9, + ACTIONS(1304), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, + anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1041), 26, + ACTIONS(1306), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42246,7 +47357,6 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, - anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -42254,30 +47364,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43710] = 3, + [47451] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1146), 11, + ACTIONS(1308), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1148), 25, + ACTIONS(1310), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42295,30 +47409,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43754] = 3, + [47499] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1150), 11, - ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1147), 1, + anon_sym_where, + STATE(661), 1, + sym_type_validation, + ACTIONS(1041), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1152), 25, + ACTIONS(1043), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42336,30 +47457,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43798] = 3, + [47551] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1154), 11, + ACTIONS(1312), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1156), 25, + ACTIONS(1314), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42377,30 +47501,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43842] = 3, + [47599] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1158), 11, + ACTIONS(1316), 11, ts_builtin_sym_end, - anon_sym_LPAREN, - anon_sym_PIPE, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1160), 25, + ACTIONS(1318), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42418,29 +47546,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43886] = 3, + [47647] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1073), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1320), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1075), 25, + ACTIONS(1322), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42458,29 +47591,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43929] = 3, + [47695] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1162), 10, + ACTIONS(1324), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1164), 25, + ACTIONS(1326), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42498,29 +47636,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [43972] = 3, + [47743] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1168), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1328), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1166), 25, + ACTIONS(1330), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42538,34 +47681,42 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44015] = 3, + [47791] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1130), 10, + ACTIONS(959), 1, + anon_sym_LBRACE, + ACTIONS(969), 1, + anon_sym_LT, + ACTIONS(955), 9, + ts_builtin_sym_end, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1132), 25, + ACTIONS(957), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -42578,29 +47729,36 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44058] = 3, + [47843] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1136), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1147), 1, + anon_sym_where, + STATE(643), 1, + sym_type_validation, + ACTIONS(1012), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1138), 25, + ACTIONS(1014), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42618,34 +47776,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44101] = 3, + [47895] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1172), 10, - anon_sym_LPAREN, + ACTIONS(1244), 1, anon_sym_PIPE, + STATE(551), 1, + aux_sym_union_type_repeat1, + ACTIONS(1022), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1170), 25, + ACTIONS(1024), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -42658,34 +47823,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44144] = 3, + [47947] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1176), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1018), 1, anon_sym_LBRACE, + ACTIONS(1020), 1, + anon_sym_LT, + ACTIONS(955), 9, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1174), 25, + ACTIONS(957), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -42698,29 +47870,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44187] = 3, + [47999] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1180), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1332), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1178), 25, + ACTIONS(1334), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42738,29 +47914,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44230] = 3, + [48047] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1184), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1336), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1182), 25, + ACTIONS(1338), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42778,29 +47959,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44273] = 3, + [48095] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1069), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1340), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1071), 25, + ACTIONS(1342), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42818,29 +48004,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44316] = 3, + [48143] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(970), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1344), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(972), 25, + ACTIONS(1346), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42858,29 +48049,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44359] = 3, + [48191] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(990), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1348), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(992), 25, + ACTIONS(1350), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42898,29 +48094,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44402] = 3, + [48239] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1047), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1352), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1049), 25, + ACTIONS(1354), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42938,29 +48139,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44445] = 3, + [48287] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1186), 10, + ACTIONS(1356), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1188), 25, + ACTIONS(1358), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -42978,29 +48184,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44488] = 3, + [48335] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1190), 10, + ACTIONS(1360), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1192), 25, + ACTIONS(1362), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43018,29 +48229,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44531] = 3, + [48383] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1194), 10, + ACTIONS(1364), 11, ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1196), 25, + ACTIONS(1366), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43058,29 +48274,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44574] = 3, + [48431] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1122), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1368), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1124), 25, + ACTIONS(1370), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43098,29 +48319,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44617] = 3, + [48479] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(962), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1372), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(964), 25, + ACTIONS(1374), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43138,29 +48364,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44660] = 3, + [48527] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1200), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1376), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1198), 25, + ACTIONS(1378), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43178,29 +48409,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44703] = 3, + [48575] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1162), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1380), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1164), 25, + ACTIONS(1382), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43218,29 +48454,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44746] = 3, + [48623] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1051), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1384), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1053), 25, + ACTIONS(1386), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43258,29 +48499,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44789] = 3, + [48671] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(978), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1388), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(980), 25, + ACTIONS(1390), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43298,29 +48544,34 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44832] = 3, + [48719] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1204), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1392), 11, + ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1202), 25, + ACTIONS(1394), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43338,34 +48589,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_export, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44875] = 3, + [48767] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1208), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(961), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1206), 25, + ACTIONS(963), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -43378,29 +48634,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44918] = 3, + [48814] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1210), 10, + ACTIONS(1278), 11, ts_builtin_sym_end, + anon_sym_DOT, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1212), 25, + ACTIONS(1280), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43418,29 +48678,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [44961] = 3, + [48861] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1184), 10, + ACTIONS(1400), 1, + anon_sym_DASH_GT, + ACTIONS(1396), 9, ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, - anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1182), 25, + ACTIONS(1398), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43451,6 +48715,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -43458,29 +48723,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45004] = 3, + [48910] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1214), 10, - ts_builtin_sym_end, + ACTIONS(1406), 1, + anon_sym_DASH_GT, + ACTIONS(1404), 9, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, - anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1216), 25, + ACTIONS(1402), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43491,6 +48760,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -43498,34 +48768,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45047] = 3, + [48959] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1015), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(991), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1017), 25, + ACTIONS(993), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -43538,29 +48812,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45090] = 3, + [49006] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1025), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1412), 1, + anon_sym_DASH_GT, + ACTIONS(1410), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, - anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1027), 25, + ACTIONS(1408), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43571,6 +48849,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -43578,29 +48857,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45133] = 3, + [49055] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1037), 10, + ACTIONS(1414), 1, + anon_sym_DASH_GT, + ACTIONS(1404), 9, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, - anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1039), 25, + ACTIONS(1402), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43611,6 +48894,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -43618,34 +48902,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45176] = 3, + [49104] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1204), 10, - ts_builtin_sym_end, + ACTIONS(1030), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1202), 25, + ACTIONS(1032), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -43658,34 +48946,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45219] = 3, + [49151] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1158), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(982), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1160), 25, + ACTIONS(984), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -43698,29 +48990,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45262] = 3, + [49198] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1055), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1278), 11, + anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1057), 25, + ACTIONS(1280), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43738,34 +49034,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45305] = 3, + [49245] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1218), 10, - ts_builtin_sym_end, + ACTIONS(1018), 1, + anon_sym_LBRACE, + ACTIONS(955), 9, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1220), 25, + ACTIONS(957), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -43778,34 +49079,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45348] = 3, + [49294] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1214), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1099), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1216), 25, + ACTIONS(1101), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -43818,34 +49123,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45391] = 3, + [49341] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1061), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(978), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1063), 25, + ACTIONS(980), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -43858,29 +49167,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45434] = 3, + [49388] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1218), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1416), 1, + anon_sym_DASH_GT, + ACTIONS(1396), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, - anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1220), 25, + ACTIONS(1398), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43891,6 +49204,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -43898,29 +49212,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45477] = 3, + [49437] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1222), 10, + ACTIONS(1418), 1, + anon_sym_DASH_GT, + ACTIONS(1410), 9, ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, - anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1224), 25, + ACTIONS(1408), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -43931,6 +49249,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -43938,34 +49257,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45520] = 3, + [49486] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1077), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(974), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1079), 25, + ACTIONS(976), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -43978,29 +49301,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45563] = 3, + [49533] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1228), 10, + ACTIONS(1424), 1, + anon_sym_DASH_GT, + ACTIONS(1420), 9, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, - anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1226), 25, + ACTIONS(1422), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44011,6 +49338,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -44018,34 +49346,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45606] = 3, + [49582] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1232), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1079), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1230), 25, + ACTIONS(1081), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -44058,29 +49390,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45649] = 3, + [49629] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1081), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1426), 1, + anon_sym_DASH_GT, + ACTIONS(1420), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, - anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1083), 25, + ACTIONS(1422), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44091,6 +49427,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_if, anon_sym_handle, anon_sym_select, + anon_sym_DASH, anon_sym_await, anon_sym_spawn, anon_sym_yield, @@ -44098,34 +49435,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45692] = 3, + [49678] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1085), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1083), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1087), 25, + ACTIONS(1085), 29, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, anon_sym_extern, anon_sym_type, + anon_sym_where, anon_sym_effect, anon_sym_match, anon_sym_if, @@ -44138,29 +49479,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45735] = 3, + [49725] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1089), 10, + ACTIONS(1428), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1091), 25, + ACTIONS(1430), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44178,29 +49522,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45778] = 3, + [49771] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1093), 10, + ACTIONS(1432), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1095), 25, + ACTIONS(1434), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44218,29 +49565,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45821] = 3, + [49817] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1097), 10, + ACTIONS(1436), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1099), 25, + ACTIONS(1438), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44258,29 +49608,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45864] = 3, + [49863] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1101), 10, + ACTIONS(1440), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1103), 25, + ACTIONS(1442), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44298,29 +49651,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45907] = 3, + [49909] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1236), 10, + ACTIONS(1444), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1234), 25, + ACTIONS(1446), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44338,29 +49694,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45950] = 3, + [49955] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1105), 10, + ACTIONS(1448), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1450), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [50001] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1432), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1107), 25, + ACTIONS(1434), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44378,29 +49780,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [45993] = 3, + [50047] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1240), 10, + ACTIONS(1448), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1450), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [50093] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1454), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1238), 25, + ACTIONS(1452), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44418,29 +49866,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46036] = 3, + [50139] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1109), 10, + ACTIONS(1428), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1430), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [50185] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1458), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1111), 25, + ACTIONS(1456), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44458,29 +49952,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46079] = 3, + [50231] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1232), 10, + ACTIONS(1460), 10, ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1230), 25, + ACTIONS(1462), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44498,29 +49995,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46122] = 3, + [50277] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1118), 10, + ACTIONS(1464), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1120), 25, + ACTIONS(1466), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44538,29 +50038,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46165] = 3, + [50323] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1126), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1436), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1128), 25, + ACTIONS(1438), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44578,29 +50081,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46208] = 3, + [50369] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1140), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1440), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1142), 25, + ACTIONS(1442), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44618,29 +50124,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46251] = 3, + [50415] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1146), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1444), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1148), 25, + ACTIONS(1446), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44658,29 +50167,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46294] = 3, + [50461] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1150), 10, + ACTIONS(1468), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1470), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [50507] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1111), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1152), 25, + ACTIONS(1113), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44698,29 +50253,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46337] = 3, + [50553] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1154), 10, + ACTIONS(1472), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1156), 25, + ACTIONS(1474), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44738,29 +50296,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46380] = 3, + [50599] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1065), 10, + ACTIONS(1274), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1276), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [50645] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1212), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1067), 25, + ACTIONS(1214), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44778,29 +50382,75 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46423] = 3, + [50691] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(966), 10, + ACTIONS(1460), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1462), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [50737] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1464), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(968), 25, + ACTIONS(1466), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44818,29 +50468,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46466] = 3, + [50783] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1208), 10, - ts_builtin_sym_end, + ACTIONS(1468), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1206), 25, + ACTIONS(1470), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44858,69 +50511,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46509] = 3, + [50829] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(974), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1472), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_PLUS, - anon_sym_DASH, - sym_float, - sym__doc_comment_line, - ACTIONS(976), 25, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_effect, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [46552] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(982), 10, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(984), 25, + ACTIONS(1474), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44938,29 +50554,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46595] = 3, + [50875] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(986), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1344), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(988), 25, + ACTIONS(1346), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -44978,69 +50597,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46638] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(468), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - ACTIONS(466), 23, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_EQ_GT, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [46681] = 3, + [50921] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1236), 10, + ACTIONS(1454), 10, ts_builtin_sym_end, + anon_sym_LBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1234), 25, + ACTIONS(1452), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45058,69 +50640,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46724] = 3, + [50967] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(994), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1131), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_PLUS, - anon_sym_DASH, - sym_float, - sym__doc_comment_line, - ACTIONS(996), 25, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_effect, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [46767] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1240), 10, - ts_builtin_sym_end, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1238), 25, + ACTIONS(1133), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45138,72 +50683,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46810] = 6, - ACTIONS(366), 1, + [51013] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(447), 1, - anon_sym_LT, - ACTIONS(1242), 1, + ACTIONS(1065), 10, anon_sym_LBRACE, - STATE(1374), 1, - sym_type_arguments, - ACTIONS(438), 11, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - ACTIONS(440), 21, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [46859] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1245), 10, - ts_builtin_sym_end, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1247), 25, + ACTIONS(1067), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45221,69 +50726,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46902] = 3, + [51059] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1245), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1392), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_BANG, - anon_sym_LBRACK, - anon_sym_PLUS, - anon_sym_DASH, - sym_float, - sym__doc_comment_line, - ACTIONS(1247), 25, - anon_sym_import, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_effect, - anon_sym_match, - anon_sym_if, - anon_sym_handle, - anon_sym_select, - anon_sym_await, - anon_sym_spawn, - anon_sym_yield, - anon_sym_send, - anon_sym_recv, - anon_sym_perform, - anon_sym_resume, - anon_sym_module, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_string, - sym_interpolated_string, - sym_identifier, - [46945] = 3, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1249), 10, - ts_builtin_sym_end, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1251), 25, + ACTIONS(1394), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45301,29 +50769,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [46988] = 3, + [51105] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1186), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1300), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1188), 25, + ACTIONS(1302), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45341,29 +50812,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47031] = 3, + [51151] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1190), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1348), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1192), 25, + ACTIONS(1350), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45381,29 +50855,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47074] = 3, + [51197] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1194), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1360), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1196), 25, + ACTIONS(1362), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45421,29 +50898,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47117] = 3, + [51243] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1210), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1073), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1212), 25, + ACTIONS(1075), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45461,29 +50941,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47160] = 3, + [51289] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1222), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1177), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1224), 25, + ACTIONS(1179), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45501,29 +50984,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47203] = 3, + [51335] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(506), 10, - ts_builtin_sym_end, + ACTIONS(1232), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(504), 25, + ACTIONS(1234), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45541,29 +51027,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47246] = 3, + [51381] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1180), 10, - ts_builtin_sym_end, + ACTIONS(1478), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1178), 25, + ACTIONS(1476), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45581,29 +51070,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47289] = 3, + [51427] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(576), 10, - ts_builtin_sym_end, + ACTIONS(1216), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(574), 25, + ACTIONS(1218), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45621,29 +51113,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47332] = 3, + [51473] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(506), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1181), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(504), 25, + ACTIONS(1183), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45661,29 +51156,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47375] = 3, + [51519] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(576), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1220), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(574), 25, + ACTIONS(1222), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45701,29 +51199,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47418] = 3, + [51565] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1172), 10, - ts_builtin_sym_end, + ACTIONS(1262), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1170), 25, + ACTIONS(1264), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45741,29 +51242,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47461] = 3, + [51611] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1249), 10, - anon_sym_LPAREN, - anon_sym_PIPE, + ACTIONS(1380), 10, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1251), 25, + ACTIONS(1382), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45781,29 +51285,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47504] = 3, + [51657] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1168), 10, - ts_builtin_sym_end, + ACTIONS(1388), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1166), 25, + ACTIONS(1390), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45821,29 +51328,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47547] = 3, + [51703] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1200), 10, - ts_builtin_sym_end, + ACTIONS(1127), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1198), 25, + ACTIONS(1129), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45861,29 +51371,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47590] = 3, + [51749] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1176), 10, - ts_builtin_sym_end, + ACTIONS(1139), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1174), 25, + ACTIONS(1141), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45901,29 +51414,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47633] = 3, + [51795] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1228), 10, - ts_builtin_sym_end, + ACTIONS(1143), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, anon_sym_PIPE, - anon_sym_LBRACE, anon_sym_BANG, anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1226), 25, + ACTIONS(1145), 28, anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, @@ -45941,2233 +51457,2368 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_recv, anon_sym_perform, anon_sym_resume, + anon_sym_state, anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47676] = 3, - ACTIONS(366), 1, + [51841] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(578), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1119), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1121), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(580), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [51887] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1149), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [47718] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(496), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1151), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(498), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [51933] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1153), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [47760] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(669), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1155), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(667), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [51979] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1157), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [47802] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(472), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1159), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(470), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52025] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1161), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [47844] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(649), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(647), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1163), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [47912] = 7, - ACTIONS(366), 1, + [52071] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(1169), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(524), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1171), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(528), 18, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, + [52117] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1185), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - sym_float, - [47962] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(661), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(659), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1187), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [48030] = 6, - ACTIONS(366), 1, + [52163] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(1189), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(556), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1191), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(558), 19, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, + [52209] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1107), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, sym_float, - [48078] = 7, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(679), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1109), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(681), 18, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, + [52255] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1250), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, sym_float, - [48128] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(504), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1252), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(506), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52301] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(616), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [48170] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(677), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(675), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(618), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [48238] = 3, - ACTIONS(366), 1, + [52347] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(520), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1304), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1306), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(522), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52393] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1332), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [48280] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(683), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1334), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(685), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52439] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1336), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [48322] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(665), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1338), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(663), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52485] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1340), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [48364] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(438), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1342), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(440), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52531] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1352), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [48406] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(562), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(560), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1354), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [48474] = 10, - ACTIONS(366), 1, + [52577] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(1364), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(524), 11, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym_float, + sym__doc_comment_line, + ACTIONS(1366), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(528), 14, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, + [52623] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1372), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - sym_float, - [48530] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(508), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1374), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(510), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52669] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1376), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [48572] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(490), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1378), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(488), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52715] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1384), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [48614] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(570), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1386), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(572), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52761] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1115), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [48656] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(574), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1117), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(576), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52807] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1266), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [48698] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(689), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(687), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1268), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [48766] = 3, - ACTIONS(366), 1, + [52853] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(542), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1254), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1256), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(544), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52899] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1240), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [48808] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(630), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(628), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1242), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [48876] = 3, - ACTIONS(366), 1, + [52945] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(637), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1087), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1089), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(635), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [52991] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1324), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [48918] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(486), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1326), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(484), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53037] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1312), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [48960] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(653), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1314), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(651), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53083] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1356), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [49002] = 13, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(524), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym_float, + sym__doc_comment_line, + ACTIONS(1358), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(528), 9, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, + [53129] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1197), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - sym_float, - [49064] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(624), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1199), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(626), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53175] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1246), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49106] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(582), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1248), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(584), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53221] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1285), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49148] = 16, - ACTIONS(366), 1, + sym__doc_comment_line, + ACTIONS(1287), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [53267] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(1316), 10, anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(693), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(691), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1318), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [49216] = 3, - ACTIONS(366), 1, + [53313] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(512), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1458), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1456), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(514), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53359] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1368), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49258] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(476), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1370), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(474), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53405] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1135), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49300] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(502), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1137), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(500), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53451] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1051), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49342] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(481), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1053), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(478), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53497] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1193), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49384] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(548), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1195), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(546), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53543] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1228), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49426] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(639), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1230), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(641), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53589] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1308), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49468] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(494), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1310), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(492), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53635] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1328), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, sym_float, - [49510] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(462), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, - anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1330), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(464), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53681] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1165), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [49552] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(645), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(643), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1167), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [49620] = 3, - ACTIONS(366), 1, + [53727] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(516), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1201), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1203), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(518), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53773] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1208), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [49662] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(673), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(671), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1210), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [49730] = 3, - ACTIONS(366), 1, + [53819] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(589), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1224), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1226), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(586), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53865] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1236), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [49772] = 12, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(524), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym_float, + sym__doc_comment_line, + ACTIONS(1238), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(528), 10, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - sym_float, - [49832] = 3, - ACTIONS(366), 1, + [53911] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(607), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1478), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1476), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(609), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [53957] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1258), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [49874] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(613), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(611), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1260), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [49942] = 3, - ACTIONS(366), 1, + [54003] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(604), 12, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + ACTIONS(1123), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym_SLASH, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1125), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(601), 22, - anon_sym_DOT, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + [54049] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1270), 10, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - sym_float, - [49984] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(657), 6, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - anon_sym_RBRACK, sym_float, - ACTIONS(655), 9, - anon_sym_in, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(1272), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [50052] = 9, - ACTIONS(366), 1, + [54095] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(1320), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(524), 11, - anon_sym_LT, - anon_sym_GT, - anon_sym_in, + anon_sym_PIPE, + anon_sym_BANG, anon_sym_LBRACK, - anon_sym__, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + sym__doc_comment_line, + ACTIONS(1322), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - ACTIONS(528), 16, - anon_sym_COLON, - anon_sym_RPAREN, - anon_sym_COMMA, + [54141] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(549), 10, + ts_builtin_sym_end, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_RBRACK, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, sym_float, - [50106] = 16, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + sym__doc_comment_line, + ACTIONS(551), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [54187] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(616), 10, + ts_builtin_sym_end, + anon_sym_LBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1281), 2, - anon_sym_RBRACE, sym_float, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(1279), 8, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(618), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [50169] = 16, - ACTIONS(366), 1, + [54233] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(549), 10, anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + anon_sym_RBRACE, + anon_sym_LPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1285), 2, - anon_sym_RBRACE, sym_float, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(1283), 8, - anon_sym_LBRACK, - anon_sym__, + sym__doc_comment_line, + ACTIONS(551), 28, + anon_sym_import, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, anon_sym_true, anon_sym_false, sym_integer, sym_string, sym_interpolated_string, sym_identifier, - [50232] = 10, + [54279] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1293), 10, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(524), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1287), 2, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(528), 14, + sym_float, + sym__doc_comment_line, + ACTIONS(1295), 28, + anon_sym_import, + anon_sym_namespace, anon_sym_let, anon_sym_mut, anon_sym_fn, + anon_sym_extern, anon_sym_type, + anon_sym_effect, + anon_sym_match, + anon_sym_if, + anon_sym_handle, + anon_sym_select, + anon_sym_await, + anon_sym_spawn, + anon_sym_yield, + anon_sym_send, + anon_sym_recv, + anon_sym_perform, + anon_sym_resume, + anon_sym_state, + anon_sym_module, + anon_sym_signature, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [54325] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + STATE(717), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(434), 14, + anon_sym_COLON, + anon_sym_EQ, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(432), 21, + anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, @@ -48175,152 +53826,171 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - sym__doc_comment_line, - [50279] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [54374] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1482), 1, + anon_sym_COLON_COLON, + STATE(717), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(471), 14, + anon_sym_COLON, + anon_sym_EQ, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(469), 21, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(853), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [50336] = 12, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1303), 1, - anon_sym_AMP_AMP, - ACTIONS(1287), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [54423] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(462), 1, anon_sym_LT, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(1485), 1, + anon_sym_LBRACE, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1736), 1, + sym_type_arguments, + ACTIONS(448), 12, + anon_sym_COLON, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(450), 20, + anon_sym_DOT, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(528), 9, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - sym__doc_comment_line, - [50387] = 11, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1287), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [54478] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(471), 14, + anon_sym_COLON, + anon_sym_EQ, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(528), 10, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(469), 22, + anon_sym_DOT, + anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, - sym__doc_comment_line, - [50436] = 9, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, anon_sym_PIPE_GT, - ACTIONS(524), 2, + anon_sym_LBRACK2, + sym_float, + [54522] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(515), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(528), 16, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(513), 23, + anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, @@ -48330,29 +54000,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - sym__doc_comment_line, - [50481] = 7, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1293), 1, + anon_sym_PERCENT, anon_sym_PIPE_GT, - ACTIONS(524), 3, + anon_sym_LBRACK2, + sym_float, + [54565] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(462), 1, anon_sym_LT, + ACTIONS(1488), 1, + anon_sym_LBRACE, + STATE(1736), 1, + sym_type_arguments, + ACTIONS(448), 11, anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(528), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_LBRACE, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(450), 21, + anon_sym_DOT, anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, @@ -48362,409 +54043,463 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, anon_sym_PERCENT, - sym__doc_comment_line, - [50522] = 15, - ACTIONS(3), 1, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [54614] = 10, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, - anon_sym_LBRACE, - ACTIONS(1299), 1, - anon_sym_QMARK, - ACTIONS(1301), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, - anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(711), 11, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(713), 14, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(562), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [50579] = 15, - ACTIONS(3), 1, + sym_float, + [54670] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(624), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(622), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(613), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [50636] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [54712] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(566), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(564), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [54754] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(448), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(630), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [50693] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(450), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(645), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [50750] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [54796] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(697), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(699), 18, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(649), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [50807] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + sym_float, + [54846] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(586), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(584), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(657), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [50864] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [54888] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(661), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(703), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [50921] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(701), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [54956] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(673), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(707), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [50978] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(705), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [55024] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(551), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(549), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [55066] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(555), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(553), 22, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(677), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51035] = 7, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1293), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, anon_sym_PIPE_GT, - ACTIONS(679), 3, + anon_sym_LBRACK2, + sym_float, + [55108] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(562), 12, anon_sym_LT, anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(681), 18, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(560), 22, + anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, @@ -48774,11464 +54509,18762 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, anon_sym_PERCENT, - sym__doc_comment_line, - [51076] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [55150] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(570), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(568), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [55192] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(574), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(572), 22, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(689), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51133] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [55234] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(580), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(578), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [55276] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(596), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(594), 22, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(693), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51190] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [55318] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(711), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(713), 18, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + sym_float, + [55368] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(600), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(598), 22, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(863), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51247] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [55410] = 13, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, - anon_sym_LBRACE, - ACTIONS(1299), 1, - anon_sym_QMARK, - ACTIONS(1301), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(867), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(711), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(713), 9, + anon_sym_LBRACE, anon_sym_RBRACE, - sym__doc_comment_line, - [51304] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + sym_float, + [55472] = 12, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, - anon_sym_LBRACE, - ACTIONS(1299), 1, - anon_sym_QMARK, - ACTIONS(1301), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, - anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(701), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(711), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(713), 10, + anon_sym_LBRACE, anon_sym_RBRACE, - sym__doc_comment_line, - [51361] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + sym_float, + [55532] = 9, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, - anon_sym_LBRACE, - ACTIONS(1299), 1, - anon_sym_QMARK, - ACTIONS(1301), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, - anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(711), 11, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(713), 16, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(719), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51418] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + sym_float, + [55586] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(1503), 1, anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(604), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(602), 19, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(726), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51475] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + sym_float, + [55634] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(614), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(612), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(730), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51532] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [55676] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(618), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(616), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(734), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51589] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [55718] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(738), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(717), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [51646] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(715), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [55786] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(628), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(626), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(742), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51703] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [55828] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(634), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(632), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(746), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51760] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [55870] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(640), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(638), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(754), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51817] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [55912] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(645), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(642), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(758), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51874] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [55954] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(650), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(648), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(762), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51931] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [55996] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(656), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(654), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56038] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(498), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(766), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [51988] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(495), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(770), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52045] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [56080] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(503), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(501), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(774), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52102] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56122] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(778), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(721), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [52159] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(719), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [56190] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(507), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(505), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(782), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52216] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, anon_sym_LBRACK2, - ACTIONS(1291), 1, + sym_float, + [56232] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(511), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(509), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(786), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52273] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56274] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(790), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(725), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [52330] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(723), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [56342] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(493), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(491), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(794), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52387] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56384] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(798), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(729), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [52444] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(727), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [56452] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(527), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(525), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1295), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1305), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(802), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52501] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56494] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(806), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(733), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [52558] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(731), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [56562] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(810), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(737), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [52615] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(735), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [56630] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(531), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(529), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56672] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(535), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(533), 22, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(814), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52672] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56714] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(821), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(741), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [52729] = 15, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, - anon_sym_LBRACE, - ACTIONS(1299), 1, - anon_sym_QMARK, - ACTIONS(1301), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(739), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [56782] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(539), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(537), 22, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56824] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(543), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(541), 22, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(825), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52786] = 15, - ACTIONS(3), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [56866] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(829), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(745), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [52843] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(743), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [56934] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1293), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(833), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, + ACTIONS(749), 6, anon_sym_RBRACE, - sym__doc_comment_line, - [52900] = 15, - ACTIONS(3), 1, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + sym_float, + ACTIONS(747), 9, + anon_sym_in, + anon_sym_LBRACK, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + [57002] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(615), 1, - anon_sym_DOT, - ACTIONS(617), 1, - anon_sym_LPAREN, - ACTIONS(619), 1, - anon_sym_LBRACK2, - ACTIONS(1291), 1, + ACTIONS(547), 12, + anon_sym_LT, + anon_sym_GT, + anon_sym_in, + anon_sym_LBRACK, anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(545), 22, + anon_sym_DOT, anon_sym_LBRACE, - ACTIONS(1299), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, anon_sym_QMARK, - ACTIONS(1301), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1289), 2, - anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [57044] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(522), 12, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + anon_sym_in, + anon_sym_LBRACK, + anon_sym_SLASH, + anon_sym__, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_string, + sym_interpolated_string, + sym_identifier, + ACTIONS(519), 22, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(837), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [52957] = 15, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + sym_float, + [57086] = 15, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1533), 1, + anon_sym_SLASH, + ACTIONS(1535), 1, + anon_sym_PIPE_GT, + ACTIONS(1519), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1531), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(841), 6, + ACTIONS(874), 12, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, + anon_sym_extern, anon_sym_type, - anon_sym_RBRACE, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, sym__doc_comment_line, - [53014] = 15, + [57149] = 15, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1533), 1, + anon_sym_SLASH, + ACTIONS(1535), 1, + anon_sym_PIPE_GT, + ACTIONS(1519), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1531), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(845), 6, + ACTIONS(703), 12, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, + anon_sym_extern, anon_sym_type, - anon_sym_RBRACE, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, sym__doc_comment_line, - [53071] = 15, + [57212] = 15, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1533), 1, + anon_sym_SLASH, + ACTIONS(1535), 1, + anon_sym_PIPE_GT, + ACTIONS(1519), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1531), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(849), 6, + ACTIONS(937), 12, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, + anon_sym_extern, anon_sym_type, - anon_sym_RBRACE, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, sym__doc_comment_line, - [53128] = 15, + [57275] = 15, ACTIONS(3), 1, sym_line_comment, - ACTIONS(615), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(617), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(619), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1291), 1, - anon_sym_SLASH, - ACTIONS(1293), 1, - anon_sym_PIPE_GT, - ACTIONS(1297), 1, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1299), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1301), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1303), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1287), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1289), 2, + ACTIONS(1533), 1, + anon_sym_SLASH, + ACTIONS(1535), 1, + anon_sym_PIPE_GT, + ACTIONS(1519), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1295), 2, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1305), 4, + ACTIONS(1531), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(750), 6, + ACTIONS(795), 12, + anon_sym_RBRACE, anon_sym_let, anon_sym_mut, anon_sym_fn, + anon_sym_extern, anon_sym_type, - anon_sym_RBRACE, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, sym__doc_comment_line, - [53185] = 7, - ACTIONS(366), 1, + [57338] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(447), 1, - anon_sym_LT, - ACTIONS(1242), 1, - anon_sym_LBRACE, - ACTIONS(1307), 1, - anon_sym_COLON, - STATE(1374), 1, - sym_type_arguments, - ACTIONS(438), 2, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(440), 17, + ACTIONS(606), 1, anon_sym_DOT, + ACTIONS(608), 1, anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COMMA, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, + anon_sym_LBRACE, + ACTIONS(1523), 1, anon_sym_QMARK, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(1533), 1, + anon_sym_SLASH, + ACTIONS(1535), 1, + anon_sym_PIPE_GT, + ACTIONS(1519), 2, anon_sym_STAR, anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [53224] = 9, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(447), 1, + ACTIONS(1521), 2, anon_sym_LT, - ACTIONS(1242), 1, - anon_sym_LBRACE, - ACTIONS(1309), 1, - anon_sym_COMMA, - ACTIONS(1311), 1, - anon_sym_RBRACE, - STATE(1102), 1, - aux_sym_field_pattern_repeat1, - STATE(1374), 1, - sym_type_arguments, - ACTIONS(438), 2, anon_sym_GT, - anon_sym_SLASH, - ACTIONS(440), 15, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + ACTIONS(1531), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [53267] = 17, - ACTIONS(366), 1, + ACTIONS(823), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57401] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1314), 1, - anon_sym_COMMA, - ACTIONS(1316), 1, - anon_sym_RBRACK, - STATE(1143), 1, - aux_sym_argument_list_repeat1, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53325] = 17, - ACTIONS(366), 1, + ACTIONS(827), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57464] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1314), 1, - anon_sym_COMMA, - ACTIONS(1318), 1, - anon_sym_RPAREN, - STATE(1084), 1, - aux_sym_argument_list_repeat1, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53383] = 17, - ACTIONS(366), 1, + ACTIONS(707), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57527] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1314), 1, - anon_sym_COMMA, - ACTIONS(1320), 1, - anon_sym_RBRACK, - STATE(1092), 1, - aux_sym_argument_list_repeat1, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53441] = 15, - ACTIONS(366), 1, + ACTIONS(835), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57590] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1322), 3, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACK, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53495] = 17, - ACTIONS(366), 1, + ACTIONS(839), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57653] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1314), 1, - anon_sym_COMMA, - ACTIONS(1324), 1, - anon_sym_RBRACK, - STATE(1079), 1, - aux_sym_argument_list_repeat1, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53553] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1326), 2, - anon_sym_COMMA, + ACTIONS(785), 12, anon_sym_RBRACE, - ACTIONS(669), 3, - anon_sym_LT, - anon_sym_GT, - anon_sym_SLASH, - ACTIONS(667), 16, - anon_sym_DOT, - anon_sym_LPAREN, - anon_sym_LBRACE, - anon_sym_QMARK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_PERCENT, - anon_sym_PIPE_GT, - anon_sym_LBRACK2, - [53584] = 15, - ACTIONS(366), 1, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57716] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1328), 2, - anon_sym_COMMA, - anon_sym_RBRACE, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53637] = 15, - ACTIONS(366), 1, + ACTIONS(801), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57779] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1330), 2, - anon_sym_in, - sym_identifier, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53690] = 15, - ACTIONS(366), 1, + ACTIONS(847), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57842] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1332), 2, - anon_sym_in, - sym_identifier, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53743] = 15, - ACTIONS(366), 1, + ACTIONS(797), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57905] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1334), 2, - anon_sym_COMMA, - anon_sym_RBRACE, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53796] = 15, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(805), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [57968] = 15, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(606), 1, + anon_sym_DOT, + ACTIONS(608), 1, + anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1336), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53849] = 15, - ACTIONS(366), 1, + ACTIONS(809), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58031] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1338), 1, - anon_sym_RBRACK, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53901] = 15, - ACTIONS(366), 1, + ACTIONS(791), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58094] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1340), 1, - anon_sym_COLON, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [53953] = 15, - ACTIONS(366), 1, + ACTIONS(829), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58157] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1342), 1, - anon_sym_RBRACK, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54005] = 15, - ACTIONS(366), 1, + ACTIONS(841), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58220] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1344), 1, - anon_sym_RBRACK, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54057] = 15, - ACTIONS(366), 1, + ACTIONS(849), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58283] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1346), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54109] = 15, - ACTIONS(366), 1, + ACTIONS(853), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58346] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1348), 1, - anon_sym_COLON, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54161] = 15, - ACTIONS(366), 1, + ACTIONS(857), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58409] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1350), 1, - anon_sym_RBRACE, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54213] = 15, - ACTIONS(366), 1, + ACTIONS(861), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58472] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1352), 1, - anon_sym_RBRACE, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54265] = 15, - ACTIONS(366), 1, + ACTIONS(870), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58535] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1354), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54317] = 15, - ACTIONS(366), 1, + ACTIONS(815), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58598] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(594), 1, - anon_sym_COLON, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54369] = 15, - ACTIONS(366), 1, + ACTIONS(819), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58661] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1356), 1, - anon_sym_COLON, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54421] = 15, - ACTIONS(366), 1, + ACTIONS(882), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58724] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1358), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54473] = 15, - ACTIONS(366), 1, + ACTIONS(886), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58787] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1360), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54525] = 15, - ACTIONS(366), 1, + ACTIONS(761), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58850] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1362), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54577] = 15, - ACTIONS(366), 1, + ACTIONS(890), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58913] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1364), 1, - anon_sym_COLON, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54629] = 15, - ACTIONS(366), 1, + ACTIONS(894), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [58976] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1366), 1, - anon_sym_COMMA, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54681] = 15, - ACTIONS(366), 1, + ACTIONS(898), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59039] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1368), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54733] = 15, - ACTIONS(366), 1, + ACTIONS(902), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59102] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1370), 1, - anon_sym_RBRACE, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54785] = 15, - ACTIONS(366), 1, + ACTIONS(906), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59165] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1372), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54837] = 15, - ACTIONS(366), 1, + ACTIONS(910), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59228] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1374), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54889] = 15, - ACTIONS(366), 1, + ACTIONS(914), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59291] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1376), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54941] = 15, - ACTIONS(366), 1, + ACTIONS(918), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59354] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1378), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [54993] = 15, - ACTIONS(366), 1, + ACTIONS(924), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59417] = 7, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1535), 1, + anon_sym_PIPE_GT, + ACTIONS(711), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(713), 24, anon_sym_LBRACE, - ACTIONS(1261), 1, + anon_sym_RBRACE, + anon_sym_STAR, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, anon_sym_QMARK, - ACTIONS(1263), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59464] = 10, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(606), 1, + anon_sym_DOT, + ACTIONS(608), 1, + anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1380), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(711), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, + ACTIONS(1519), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1531), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(713), 20, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55045] = 15, - ACTIONS(366), 1, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59517] = 12, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1382), 1, - anon_sym_COLON, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55097] = 15, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(713), 15, anon_sym_LBRACE, - ACTIONS(1261), 1, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, anon_sym_QMARK, - ACTIONS(1263), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59574] = 11, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(606), 1, + anon_sym_DOT, + ACTIONS(608), 1, + anon_sym_LPAREN, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1384), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55149] = 15, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(713), 16, anon_sym_LBRACE, - ACTIONS(1261), 1, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, anon_sym_QMARK, - ACTIONS(1263), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1386), 1, - anon_sym_COLON, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [55201] = 15, - ACTIONS(366), 1, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59629] = 9, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, - anon_sym_LBRACE, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1388), 1, - anon_sym_RBRACE, - ACTIONS(1255), 2, + ACTIONS(711), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, + ACTIONS(1519), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [55253] = 15, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(713), 22, anon_sym_LBRACE, - ACTIONS(1261), 1, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, anon_sym_QMARK, - ACTIONS(1263), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1390), 1, - anon_sym_COLON, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55305] = 15, - ACTIONS(366), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59680] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1392), 1, - anon_sym_COLON, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55357] = 15, - ACTIONS(366), 1, + ACTIONS(717), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59743] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1394), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55409] = 15, - ACTIONS(366), 1, + ACTIONS(721), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59806] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1396), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55461] = 15, - ACTIONS(366), 1, + ACTIONS(725), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59869] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1398), 1, - anon_sym_COMMA, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55513] = 15, - ACTIONS(366), 1, + ACTIONS(729), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59932] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1400), 1, - anon_sym_RBRACE, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55565] = 15, - ACTIONS(366), 1, + ACTIONS(733), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [59995] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1402), 1, - anon_sym_COMMA, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55617] = 15, - ACTIONS(366), 1, + ACTIONS(737), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [60058] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1404), 1, - anon_sym_RBRACE, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55669] = 15, - ACTIONS(366), 1, + ACTIONS(741), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [60121] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1406), 1, - anon_sym_RPAREN, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55721] = 14, - ACTIONS(366), 1, + ACTIONS(745), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [60184] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1259), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, anon_sym_LBRACE, - ACTIONS(1261), 1, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55770] = 14, - ACTIONS(366), 1, + ACTIONS(749), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [60247] = 7, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, + ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1408), 1, - anon_sym_LBRACE, - ACTIONS(1255), 2, + ACTIONS(1535), 1, + anon_sym_PIPE_GT, + ACTIONS(697), 3, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, + anon_sym_SLASH, + ACTIONS(699), 24, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55819] = 14, - ACTIONS(366), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [60294] = 15, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(606), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(608), 1, anon_sym_LPAREN, - ACTIONS(1261), 1, + ACTIONS(610), 1, + anon_sym_LBRACK2, + ACTIONS(1517), 1, + anon_sym_LBRACE, + ACTIONS(1523), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1525), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1527), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1533), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1535), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1410), 1, - anon_sym_LBRACE, - ACTIONS(1255), 2, + ACTIONS(1519), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1521), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1531), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1529), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [55868] = 13, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1412), 1, - sym_identifier, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1416), 1, - anon_sym_RBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - STATE(1212), 1, - sym_pattern, - STATE(1414), 1, - sym_field_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(788), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [55915] = 13, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1412), 1, - sym_identifier, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1426), 1, + ACTIONS(878), 12, anon_sym_RBRACE, - STATE(1212), 1, - sym_pattern, - STATE(1414), 1, - sym_field_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(786), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [55962] = 14, - ACTIONS(366), 1, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [60357] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, + ACTIONS(1503), 1, anon_sym_LBRACK2, - ACTIONS(1428), 1, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1539), 2, + anon_sym_RBRACE, + sym_float, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [56011] = 13, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1412), 1, - sym_identifier, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, + ACTIONS(1537), 8, anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1430), 1, - anon_sym_RBRACE, - STATE(1212), 1, - sym_pattern, - STATE(1414), 1, - sym_field_pattern, - ACTIONS(360), 2, + anon_sym__, anon_sym_true, anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(787), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, sym_integer, sym_string, sym_interpolated_string, - [56058] = 14, - ACTIONS(366), 1, + sym_identifier, + [60420] = 16, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1253), 1, + ACTIONS(1491), 1, anon_sym_DOT, - ACTIONS(1257), 1, + ACTIONS(1495), 1, anon_sym_LPAREN, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, + ACTIONS(1499), 1, anon_sym_SLASH, - ACTIONS(1275), 1, + ACTIONS(1501), 1, anon_sym_PIPE_GT, - ACTIONS(1277), 1, + ACTIONS(1503), 1, anon_sym_LBRACK2, - ACTIONS(1432), 1, + ACTIONS(1505), 1, anon_sym_LBRACE, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [56107] = 14, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1261), 1, + ACTIONS(1509), 1, anon_sym_QMARK, - ACTIONS(1263), 1, + ACTIONS(1511), 1, anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, + ACTIONS(1513), 1, anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1434), 1, - anon_sym_LBRACE, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1271), 2, + ACTIONS(1493), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1267), 4, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [56156] = 14, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1253), 1, - anon_sym_DOT, - ACTIONS(1257), 1, - anon_sym_LPAREN, - ACTIONS(1261), 1, - anon_sym_QMARK, - ACTIONS(1263), 1, - anon_sym_PIPE_PIPE, - ACTIONS(1265), 1, - anon_sym_AMP_AMP, - ACTIONS(1273), 1, - anon_sym_SLASH, - ACTIONS(1275), 1, - anon_sym_PIPE_GT, - ACTIONS(1277), 1, - anon_sym_LBRACK2, - ACTIONS(1436), 1, - anon_sym_LBRACE, - ACTIONS(1255), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(1269), 2, + ACTIONS(1497), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1271), 2, - anon_sym_STAR, - anon_sym_PERCENT, - ACTIONS(1267), 4, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1543), 2, + anon_sym_RBRACE, + sym_float, + ACTIONS(1515), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [56205] = 12, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, + ACTIONS(1541), 8, anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - ACTIONS(1440), 1, - anon_sym_RBRACE, - STATE(1281), 1, - sym_pattern, - ACTIONS(360), 2, + anon_sym__, anon_sym_true, anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(790), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, sym_integer, sym_string, sym_interpolated_string, - [56249] = 12, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, sym_identifier, - ACTIONS(1442), 1, + [60483] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1545), 1, anon_sym_RBRACE, - STATE(1281), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(790), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56293] = 12, - ACTIONS(366), 1, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [60542] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1444), 1, - sym_identifier, - ACTIONS(1447), 1, - anon_sym_LBRACE, - ACTIONS(1450), 1, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1565), 1, anon_sym_RBRACE, - ACTIONS(1452), 1, - anon_sym_LBRACK, - ACTIONS(1464), 1, - sym_float, - STATE(1212), 1, - sym_pattern, - ACTIONS(1455), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1461), 2, - anon_sym_true, - anon_sym_false, - STATE(785), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1458), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56337] = 12, - ACTIONS(366), 1, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(833), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [60601] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - ACTIONS(1467), 1, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1567), 1, anon_sym_RBRACE, - STATE(1212), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(785), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56381] = 12, - ACTIONS(366), 1, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(830), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [60660] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - ACTIONS(1469), 1, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1569), 1, anon_sym_RBRACE, - STATE(1212), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(785), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56425] = 12, - ACTIONS(366), 1, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [60719] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - ACTIONS(1471), 1, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1571), 1, anon_sym_RBRACE, - STATE(1212), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(785), 2, - sym_match_arm, - aux_sym_match_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56469] = 12, - ACTIONS(366), 1, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(838), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [60778] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - ACTIONS(1473), 1, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1573), 1, anon_sym_RBRACE, - STATE(1281), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(790), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56513] = 12, - ACTIONS(366), 1, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(843), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [60837] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1475), 1, - sym_identifier, - ACTIONS(1478), 1, - anon_sym_LBRACE, - ACTIONS(1481), 1, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1575), 1, anon_sym_RBRACE, - ACTIONS(1483), 1, - anon_sym_LBRACK, - ACTIONS(1495), 1, - sym_float, - STATE(1281), 1, - sym_pattern, - ACTIONS(1486), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1492), 2, - anon_sym_true, - anon_sym_false, - STATE(790), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1489), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56557] = 11, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - STATE(1281), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(789), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56598] = 11, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - STATE(1281), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(784), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56639] = 11, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - STATE(1281), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(783), 2, - sym_select_arm, - aux_sym_select_expression_repeat1, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56680] = 11, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - ACTIONS(1498), 1, - anon_sym_RBRACK, - STATE(1130), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56720] = 11, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - ACTIONS(1500), 1, - anon_sym_DOT_DOT_DOT, - STATE(1172), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56760] = 11, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - ACTIONS(1502), 1, - anon_sym_DOT_DOT_DOT, - STATE(1172), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56800] = 10, - ACTIONS(366), 1, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [60896] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - STATE(1197), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56837] = 10, - ACTIONS(366), 1, + ACTIONS(1577), 1, + anon_sym_RBRACE, + ACTIONS(1582), 1, + anon_sym_fn, + ACTIONS(1585), 1, + anon_sym_extern, + ACTIONS(1588), 1, + anon_sym_type, + ACTIONS(1591), 1, + anon_sym_effect, + ACTIONS(1594), 1, + anon_sym_state, + ACTIONS(1597), 1, + anon_sym_module, + ACTIONS(1600), 1, + anon_sym_export, + ACTIONS(1603), 1, + anon_sym_signature, + ACTIONS(1606), 1, + sym__doc_comment_line, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1579), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [60955] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1414), 1, - anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - STATE(1052), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56874] = 10, - ACTIONS(366), 1, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1609), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61014] = 11, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1414), 1, + ACTIONS(462), 1, + anon_sym_LT, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(1485), 1, anon_sym_LBRACE, - ACTIONS(1418), 1, - anon_sym_LBRACK, - ACTIONS(1424), 1, - sym_float, - ACTIONS(1438), 1, - sym_identifier, - STATE(1172), 1, - sym_pattern, - ACTIONS(360), 2, - anon_sym_true, - anon_sym_false, - ACTIONS(1420), 2, + ACTIONS(1611), 1, + anon_sym_RBRACE, + ACTIONS(1614), 1, + anon_sym_COMMA, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1355), 1, + aux_sym_field_pattern_repeat1, + STATE(1736), 1, + sym_type_arguments, + ACTIONS(448), 2, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(450), 15, + anon_sym_DOT, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, anon_sym_PLUS, anon_sym_DASH, - STATE(972), 2, - sym_list_pattern, - sym_boolean, - ACTIONS(1422), 4, - anon_sym__, - sym_integer, - sym_string, - sym_interpolated_string, - [56911] = 5, - ACTIONS(366), 1, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [61063] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1504), 1, - anon_sym_LT, - ACTIONS(1506), 1, - anon_sym_LBRACK, - ACTIONS(1000), 3, - anon_sym_EQ, - anon_sym_where, - sym_identifier, - ACTIONS(998), 9, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_PIPE, - anon_sym_LBRACE, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1616), 1, anon_sym_RBRACE, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [56937] = 10, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(839), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61122] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(61), 1, + ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1510), 1, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1512), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1514), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1618), 1, anon_sym_RBRACE, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1508), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(804), 2, - sym_module_statement, + STATE(834), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [56972] = 10, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61181] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(61), 1, + ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1510), 1, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1512), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1516), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1620), 1, anon_sym_RBRACE, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1508), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(809), 2, - sym_module_statement, + STATE(834), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [57007] = 10, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61240] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(61), 1, + ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1510), 1, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1512), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1518), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1622), 1, anon_sym_RBRACE, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1508), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(805), 2, - sym_module_statement, + STATE(841), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [57042] = 10, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61299] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1523), 1, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1526), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1529), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1624), 1, anon_sym_RBRACE, - ACTIONS(1531), 1, - sym__doc_comment_line, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1520), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(804), 2, - sym_module_statement, + STATE(834), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [57077] = 10, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61358] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(61), 1, + ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1510), 1, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1512), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1534), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1626), 1, anon_sym_RBRACE, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1508), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(804), 2, - sym_module_statement, + STATE(834), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [57112] = 10, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61417] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(61), 1, + ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1510), 1, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1512), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1536), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1628), 1, anon_sym_RBRACE, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1508), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(804), 2, - sym_module_statement, + STATE(834), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [57147] = 10, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61476] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(61), 1, + ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1510), 1, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1512), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1538), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1630), 1, anon_sym_RBRACE, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1508), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(801), 2, - sym_module_statement, + STATE(847), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [57182] = 10, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61535] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(61), 1, + ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1510), 1, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1512), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1540), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1632), 1, anon_sym_RBRACE, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1508), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(806), 2, - sym_module_statement, + STATE(835), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [57217] = 10, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61594] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(61), 1, + ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1510), 1, + ACTIONS(1549), 1, anon_sym_fn, - ACTIONS(1512), 1, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, anon_sym_type, - ACTIONS(1542), 1, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1634), 1, anon_sym_RBRACE, - STATE(824), 1, + STATE(968), 1, aux_sym_doc_comment_repeat1, - STATE(973), 1, + STATE(1005), 1, sym_doc_comment, - ACTIONS(1508), 2, + ACTIONS(1547), 2, anon_sym_let, anon_sym_mut, - STATE(804), 2, - sym_module_statement, + STATE(850), 2, + sym_module_item, aux_sym_module_declaration_repeat1, - STATE(911), 3, + STATE(984), 9, sym_let_declaration, sym_function_declaration, + sym_extern_declaration, sym_type_declaration, - [57252] = 3, - ACTIONS(366), 1, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61653] = 16, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1188), 3, - anon_sym_EQ, - anon_sym_where, - sym_identifier, - ACTIONS(1186), 9, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_PIPE, - anon_sym_LBRACE, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1636), 1, anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61712] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1638), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(852), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61771] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1640), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(854), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61830] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1642), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61889] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1644), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(856), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [61948] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1646), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62007] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1648), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(827), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62066] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1650), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62125] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1652), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(859), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62184] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1654), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62243] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(462), 1, + anon_sym_LT, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(1485), 1, + anon_sym_LBRACE, + ACTIONS(1656), 1, + anon_sym_COLON, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1736), 1, + sym_type_arguments, + ACTIONS(448), 2, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(450), 17, + anon_sym_DOT, + anon_sym_STAR, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [62288] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1658), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(860), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62347] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1660), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62406] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1662), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(834), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62465] = 16, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1561), 1, + anon_sym_export, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1664), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1005), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(842), 2, + sym_module_item, + aux_sym_module_declaration_repeat1, + STATE(984), 9, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym_export_declaration, + sym__module_declaration, + sym_signature_declaration, + [62524] = 17, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1666), 1, + anon_sym_COMMA, + ACTIONS(1668), 1, + anon_sym_RBRACK, + STATE(1319), 1, + aux_sym_argument_list_repeat1, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [62582] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1670), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [62636] = 17, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1666), 1, + anon_sym_COMMA, + ACTIONS(1672), 1, + anon_sym_RBRACK, + STATE(1296), 1, + aux_sym_argument_list_repeat1, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [62694] = 17, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1666), 1, + anon_sym_COMMA, + ACTIONS(1674), 1, + anon_sym_RBRACK, + STATE(1380), 1, + aux_sym_argument_list_repeat1, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [62752] = 17, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1666), 1, + anon_sym_COMMA, + ACTIONS(1676), 1, + anon_sym_RPAREN, + STATE(1332), 1, + aux_sym_argument_list_repeat1, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [62810] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1678), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + ACTIONS(566), 3, + anon_sym_LT, + anon_sym_GT, + anon_sym_SLASH, + ACTIONS(564), 16, + anon_sym_DOT, + anon_sym_LBRACE, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_QMARK, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_PIPE_GT, + anon_sym_LBRACK2, + [62841] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1680), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [62894] = 14, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1682), 1, + anon_sym_opaque, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1042), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(982), 8, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym__module_declaration, + sym_signature_declaration, + [62945] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1684), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [62998] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1686), 2, + anon_sym_in, + sym_identifier, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63051] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1688), 2, + anon_sym_in, + sym_identifier, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63104] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1690), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63157] = 14, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1549), 1, + anon_sym_fn, + ACTIONS(1551), 1, + anon_sym_extern, + ACTIONS(1553), 1, + anon_sym_type, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1557), 1, + anon_sym_state, + ACTIONS(1559), 1, + anon_sym_module, + ACTIONS(1563), 1, + anon_sym_signature, + ACTIONS(1692), 1, + anon_sym_opaque, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1042), 1, + sym_doc_comment, + ACTIONS(1547), 2, + anon_sym_let, + anon_sym_mut, + STATE(975), 8, + sym_let_declaration, + sym_function_declaration, + sym_extern_declaration, + sym_type_declaration, + sym_effect_declaration, + sym_module_declaration, + sym__module_declaration, + sym_signature_declaration, + [63208] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1694), 1, + anon_sym_COLON, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63260] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1696), 1, + sym_identifier, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1700), 1, + anon_sym_RBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + STATE(1474), 1, + sym_qualified_path, + STATE(1628), 1, + sym_pattern, + STATE(1771), 1, + sym_field_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(915), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [63310] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(673), 1, + anon_sym_COLON, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63362] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1710), 1, + anon_sym_RBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63414] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1712), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63466] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1714), 1, + anon_sym_COMMA, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63518] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1716), 1, + anon_sym_RBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63570] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1718), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63622] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1720), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63674] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1722), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63726] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1696), 1, + sym_identifier, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1724), 1, + anon_sym_RBRACE, + STATE(1474), 1, + sym_qualified_path, + STATE(1628), 1, + sym_pattern, + STATE(1771), 1, + sym_field_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(928), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [63776] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1726), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63828] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1728), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63880] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1730), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63932] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1732), 1, + anon_sym_COLON, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [63984] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1734), 1, + anon_sym_RBRACK, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64036] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1736), 1, + anon_sym_RBRACK, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64088] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1738), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64140] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1740), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64192] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1742), 1, + anon_sym_COLON, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64244] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1744), 1, + anon_sym_COLON, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64296] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1746), 1, + anon_sym_RBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64348] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1748), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64400] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1696), 1, + sym_identifier, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1750), 1, + anon_sym_RBRACE, + STATE(1474), 1, + sym_qualified_path, + STATE(1628), 1, + sym_pattern, + STATE(1771), 1, + sym_field_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(919), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [64450] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1752), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64502] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1754), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64554] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1756), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64606] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1758), 1, + anon_sym_COLON, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64658] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1760), 1, + anon_sym_RBRACK, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64710] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1762), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64762] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1764), 1, + anon_sym_COLON, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64814] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1766), 1, + anon_sym_RBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64866] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1768), 1, + anon_sym_COLON, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64918] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1770), 1, + anon_sym_COLON, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [64970] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1772), 1, + anon_sym_COMMA, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65022] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1774), 1, + anon_sym_RBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65074] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1776), 1, + anon_sym_COMMA, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65126] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1778), 1, + anon_sym_RBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65178] = 15, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1780), 1, + anon_sym_RPAREN, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65230] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1782), 1, + anon_sym_LBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65279] = 13, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1786), 1, + anon_sym_RBRACE, + STATE(1474), 1, + sym_qualified_path, + STATE(1628), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(918), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [65326] = 13, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1788), 1, + anon_sym_RBRACE, + STATE(1474), 1, + sym_qualified_path, + STATE(1639), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(927), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [65373] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1790), 1, + anon_sym_LBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65422] = 13, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1792), 1, + sym_identifier, + ACTIONS(1795), 1, + anon_sym_LBRACE, + ACTIONS(1798), 1, + anon_sym_RBRACE, + ACTIONS(1800), 1, + anon_sym_LBRACK, + ACTIONS(1812), 1, + sym_float, + STATE(1474), 1, + sym_qualified_path, + STATE(1628), 1, + sym_pattern, + ACTIONS(1803), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1809), 2, + anon_sym_true, + anon_sym_false, + STATE(918), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1806), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [65469] = 13, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1815), 1, + anon_sym_RBRACE, + STATE(1474), 1, + sym_qualified_path, + STATE(1628), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(918), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [65516] = 13, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1817), 1, + anon_sym_RBRACE, + STATE(1474), 1, + sym_qualified_path, + STATE(1639), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(927), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [65563] = 7, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(953), 1, + anon_sym_COLON_COLON, + ACTIONS(959), 1, + anon_sym_LBRACE, + ACTIONS(969), 1, + anon_sym_LT, + ACTIONS(1819), 1, + anon_sym_LBRACK, + STATE(469), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(955), 14, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_where, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [65598] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1821), 1, + anon_sym_LBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65647] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1505), 1, + anon_sym_LBRACE, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65696] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1823), 1, + anon_sym_LBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65745] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(953), 1, + anon_sym_COLON_COLON, + ACTIONS(969), 1, + anon_sym_LT, + ACTIONS(1819), 1, + anon_sym_LBRACK, + STATE(469), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(965), 15, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + anon_sym_effect, + anon_sym_BANG, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym__doc_comment_line, + [65778] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1825), 1, + anon_sym_LBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [65827] = 13, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1827), 1, + sym_identifier, + ACTIONS(1830), 1, + anon_sym_LBRACE, + ACTIONS(1833), 1, + anon_sym_RBRACE, + ACTIONS(1835), 1, + anon_sym_LBRACK, + ACTIONS(1847), 1, + sym_float, + STATE(1474), 1, + sym_qualified_path, + STATE(1639), 1, + sym_pattern, + ACTIONS(1838), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1844), 2, + anon_sym_true, + anon_sym_false, + STATE(927), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1841), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [65874] = 13, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1850), 1, + anon_sym_RBRACE, + STATE(1474), 1, + sym_qualified_path, + STATE(1628), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(918), 2, + sym_match_arm, + aux_sym_match_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [65921] = 13, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1852), 1, + anon_sym_RBRACE, + STATE(1474), 1, + sym_qualified_path, + STATE(1639), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(927), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [65968] = 14, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1491), 1, + anon_sym_DOT, + ACTIONS(1495), 1, + anon_sym_LPAREN, + ACTIONS(1499), 1, + anon_sym_SLASH, + ACTIONS(1501), 1, + anon_sym_PIPE_GT, + ACTIONS(1503), 1, + anon_sym_LBRACK2, + ACTIONS(1509), 1, + anon_sym_QMARK, + ACTIONS(1511), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1513), 1, + anon_sym_AMP_AMP, + ACTIONS(1854), 1, + anon_sym_LBRACE, + ACTIONS(1493), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(1497), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1507), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(1515), 4, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [66017] = 12, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + STATE(1474), 1, + sym_qualified_path, + STATE(1639), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(920), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66061] = 12, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + STATE(1474), 1, + sym_qualified_path, + STATE(1639), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(916), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66105] = 12, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + STATE(1474), 1, + sym_qualified_path, + STATE(1639), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(929), 2, + sym_select_arm, + aux_sym_select_expression_repeat1, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66149] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1856), 1, + anon_sym_RBRACE, + ACTIONS(1858), 1, + anon_sym_let, + ACTIONS(1860), 1, + anon_sym_fn, + ACTIONS(1862), 1, + anon_sym_type, + ACTIONS(1864), 1, + anon_sym_module, + ACTIONS(1866), 1, + anon_sym_opaque, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(945), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66194] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1858), 1, + anon_sym_let, + ACTIONS(1860), 1, + anon_sym_fn, + ACTIONS(1862), 1, + anon_sym_type, + ACTIONS(1864), 1, + anon_sym_module, + ACTIONS(1866), 1, + anon_sym_opaque, + ACTIONS(1868), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(936), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66239] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1858), 1, + anon_sym_let, + ACTIONS(1860), 1, + anon_sym_fn, + ACTIONS(1862), 1, + anon_sym_type, + ACTIONS(1864), 1, + anon_sym_module, + ACTIONS(1866), 1, + anon_sym_opaque, + ACTIONS(1870), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(945), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66284] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1858), 1, + anon_sym_let, + ACTIONS(1860), 1, + anon_sym_fn, + ACTIONS(1862), 1, + anon_sym_type, + ACTIONS(1864), 1, + anon_sym_module, + ACTIONS(1866), 1, + anon_sym_opaque, + ACTIONS(1872), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(940), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66329] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1858), 1, + anon_sym_let, + ACTIONS(1860), 1, + anon_sym_fn, + ACTIONS(1862), 1, + anon_sym_type, + ACTIONS(1864), 1, + anon_sym_module, + ACTIONS(1866), 1, + anon_sym_opaque, + ACTIONS(1874), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(945), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66374] = 12, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1876), 1, + anon_sym_RBRACK, + STATE(1412), 1, + sym_pattern, + STATE(1474), 1, + sym_qualified_path, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66417] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1858), 1, + anon_sym_let, + ACTIONS(1860), 1, + anon_sym_fn, + ACTIONS(1862), 1, + anon_sym_type, + ACTIONS(1864), 1, + anon_sym_module, + ACTIONS(1866), 1, + anon_sym_opaque, + ACTIONS(1878), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(945), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66462] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1858), 1, + anon_sym_let, + ACTIONS(1860), 1, + anon_sym_fn, + ACTIONS(1862), 1, + anon_sym_type, + ACTIONS(1864), 1, + anon_sym_module, + ACTIONS(1866), 1, + anon_sym_opaque, + ACTIONS(1880), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(934), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66507] = 12, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1882), 1, + anon_sym_DOT_DOT_DOT, + STATE(1474), 1, + sym_qualified_path, + STATE(1481), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66550] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1555), 1, + anon_sym_effect, + ACTIONS(1858), 1, + anon_sym_let, + ACTIONS(1860), 1, + anon_sym_fn, + ACTIONS(1862), 1, + anon_sym_type, + ACTIONS(1864), 1, + anon_sym_module, + ACTIONS(1866), 1, + anon_sym_opaque, + ACTIONS(1884), 1, + anon_sym_RBRACE, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(938), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66595] = 12, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + ACTIONS(1886), 1, + anon_sym_DOT_DOT_DOT, + STATE(1474), 1, + sym_qualified_path, + STATE(1481), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66638] = 13, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1888), 1, + anon_sym_RBRACE, + ACTIONS(1890), 1, + anon_sym_let, + ACTIONS(1893), 1, + anon_sym_fn, + ACTIONS(1896), 1, + anon_sym_type, + ACTIONS(1899), 1, + anon_sym_effect, + ACTIONS(1902), 1, + anon_sym_module, + ACTIONS(1905), 1, + anon_sym_opaque, + ACTIONS(1908), 1, + sym__doc_comment_line, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(1649), 1, + sym_doc_comment, + STATE(945), 2, + sym_signature_item, + aux_sym_signature_declaration_repeat1, + STATE(1118), 5, + sym_effect_declaration, + sym_signature_value, + sym_signature_function, + sym_signature_type, + sym_signature_module, + [66683] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(969), 1, + anon_sym_LT, + ACTIONS(1819), 1, + anon_sym_LBRACK, + ACTIONS(965), 15, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_where, + anon_sym_effect, + anon_sym_BANG, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_opaque, + anon_sym_signature, + sym__doc_comment_line, + [66710] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(959), 1, + anon_sym_LBRACE, + ACTIONS(969), 1, + anon_sym_LT, + ACTIONS(1819), 1, + anon_sym_LBRACK, + ACTIONS(955), 14, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_PIPE, + anon_sym_where, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [66739] = 11, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + STATE(1462), 1, + sym_pattern, + STATE(1474), 1, + sym_qualified_path, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66779] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1911), 1, + anon_sym_COLON_COLON, + STATE(949), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(471), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(469), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [66807] = 11, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + STATE(1336), 1, + sym_pattern, + STATE(1474), 1, + sym_qualified_path, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66847] = 11, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1698), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + anon_sym_LBRACK, + ACTIONS(1708), 1, + sym_float, + ACTIONS(1784), 1, + sym_identifier, + STATE(1474), 1, + sym_qualified_path, + STATE(1481), 1, + sym_pattern, + ACTIONS(424), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(1704), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(1209), 2, + sym_list_pattern, + sym_boolean, + ACTIONS(1706), 4, + anon_sym__, + sym_integer, + sym_string, + sym_interpolated_string, + [66887] = 7, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1914), 1, + anon_sym_COLON_COLON, + ACTIONS(1916), 1, + anon_sym_LT, + ACTIONS(1918), 1, + anon_sym_LBRACK, + STATE(953), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(967), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(965), 9, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [66919] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1914), 1, + anon_sym_COLON_COLON, + STATE(949), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(434), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(432), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [66947] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(471), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(469), 12, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LT, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [66970] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1920), 1, + sym_identifier, + ACTIONS(1922), 1, + anon_sym_LBRACE, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_variant, + STATE(947), 1, + sym_qualified_path, + STATE(491), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(503), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67004] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1928), 1, + sym_identifier, + ACTIONS(1930), 1, + anon_sym_LBRACE, + ACTIONS(1932), 1, + anon_sym_fn, + ACTIONS(1934), 1, + anon_sym_LPAREN, + STATE(578), 1, + sym_variant, + STATE(579), 1, + sym_qualified_path, + STATE(531), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(613), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67038] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1922), 1, + anon_sym_LBRACE, + ACTIONS(1936), 1, + sym_identifier, + ACTIONS(1938), 1, + anon_sym_fn, + ACTIONS(1940), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_variant, + STATE(576), 1, + sym_qualified_path, + STATE(487), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(503), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67072] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1920), 1, + sym_identifier, + ACTIONS(1922), 1, + anon_sym_LBRACE, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_variant, + STATE(947), 1, + sym_qualified_path, + STATE(487), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(503), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67106] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1920), 1, + sym_identifier, + ACTIONS(1922), 1, + anon_sym_LBRACE, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_variant, + STATE(947), 1, + sym_qualified_path, + STATE(484), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(503), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67140] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1922), 1, + anon_sym_LBRACE, + ACTIONS(1936), 1, + sym_identifier, + ACTIONS(1938), 1, + anon_sym_fn, + ACTIONS(1940), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_variant, + STATE(576), 1, + sym_qualified_path, + STATE(484), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(503), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67174] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1928), 1, + sym_identifier, + ACTIONS(1930), 1, + anon_sym_LBRACE, + ACTIONS(1932), 1, + anon_sym_fn, + ACTIONS(1934), 1, + anon_sym_LPAREN, + STATE(578), 1, + sym_variant, + STATE(579), 1, + sym_qualified_path, + STATE(521), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(613), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67208] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1922), 1, + anon_sym_LBRACE, + ACTIONS(1936), 1, + sym_identifier, + ACTIONS(1938), 1, + anon_sym_fn, + ACTIONS(1940), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_variant, + STATE(576), 1, + sym_qualified_path, + STATE(491), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(503), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67242] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1928), 1, + sym_identifier, + ACTIONS(1930), 1, + anon_sym_LBRACE, + ACTIONS(1932), 1, + anon_sym_fn, + ACTIONS(1934), 1, + anon_sym_LPAREN, + STATE(578), 1, + sym_variant, + STATE(579), 1, + sym_qualified_path, + STATE(577), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(613), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67276] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1922), 1, + anon_sym_LBRACE, + ACTIONS(1936), 1, + sym_identifier, + ACTIONS(1938), 1, + anon_sym_fn, + ACTIONS(1940), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_variant, + STATE(576), 1, + sym_qualified_path, + STATE(490), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(503), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67310] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1928), 1, + sym_identifier, + ACTIONS(1930), 1, + anon_sym_LBRACE, + ACTIONS(1932), 1, + anon_sym_fn, + ACTIONS(1934), 1, + anon_sym_LPAREN, + STATE(578), 1, + sym_variant, + STATE(579), 1, + sym_qualified_path, + STATE(570), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(613), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67344] = 9, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1920), 1, + sym_identifier, + ACTIONS(1922), 1, + anon_sym_LBRACE, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_variant, + STATE(947), 1, + sym_qualified_path, + STATE(490), 3, + sym_union_type, + sym_type_alias, + sym_record_type, + STATE(503), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67378] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1916), 1, + anon_sym_LT, + ACTIONS(1918), 1, + anon_sym_LBRACK, + ACTIONS(967), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(965), 9, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [67404] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1944), 1, + sym__doc_comment_line, + STATE(973), 1, + aux_sym_doc_comment_repeat1, + ACTIONS(1942), 11, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + [67427] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1946), 1, + anon_sym_DASH_GT, + ACTIONS(1420), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67448] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1948), 1, + anon_sym_DASH_GT, + ACTIONS(1410), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67469] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1950), 1, + anon_sym_DASH_GT, + ACTIONS(1396), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67490] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1952), 1, + anon_sym_DASH_GT, + ACTIONS(1404), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67511] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1956), 1, + sym__doc_comment_line, + STATE(973), 1, + aux_sym_doc_comment_repeat1, + ACTIONS(1954), 11, + anon_sym_namespace, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + [67534] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1959), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67552] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1961), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67570] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(436), 1, + anon_sym_COLON_COLON, + ACTIONS(1965), 1, + anon_sym_LT, + STATE(24), 1, + aux_sym_qualified_path_repeat1, + STATE(1102), 1, + sym_type_arguments, + ACTIONS(1963), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [67596] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(976), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(974), 9, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [57272] = 3, - ACTIONS(366), 1, + [67616] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1224), 3, + ACTIONS(963), 3, anon_sym_EQ, anon_sym_where, sym_identifier, - ACTIONS(1222), 9, + ACTIONS(961), 9, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, anon_sym_GT, anon_sym_RPAREN, - anon_sym_COMMA, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [67636] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1967), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67654] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1032), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(1030), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [57292] = 3, - ACTIONS(366), 1, + [67674] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1196), 3, + ACTIONS(980), 3, anon_sym_EQ, anon_sym_where, sym_identifier, - ACTIONS(1194), 9, + ACTIONS(978), 9, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, anon_sym_GT, anon_sym_RPAREN, - anon_sym_COMMA, anon_sym_PIPE, + anon_sym_BANG, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [67694] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1969), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67712] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(984), 3, + anon_sym_EQ, + anon_sym_where, + sym_identifier, + ACTIONS(982), 9, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + anon_sym_PIPE, anon_sym_BANG, anon_sym_RBRACK, anon_sym_EQ_GT, - [57312] = 3, - ACTIONS(366), 1, + [67732] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1971), 12, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_mut, + anon_sym_fn, + anon_sym_extern, + anon_sym_type, + anon_sym_effect, + anon_sym_state, + anon_sym_module, + anon_sym_export, + anon_sym_signature, + sym__doc_comment_line, + [67750] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(1979), 1, + anon_sym_RPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1744), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67779] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1983), 1, + anon_sym_DASH_GT, + ACTIONS(1985), 1, + anon_sym_BANG, + STATE(1117), 1, + sym_effect_set, + ACTIONS(1981), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [67802] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(1987), 1, + anon_sym_RPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1591), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67831] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(1989), 1, + anon_sym_RPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1605), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67860] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(1991), 1, + anon_sym_RPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1645), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67889] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(436), 1, + anon_sym_COLON_COLON, + STATE(994), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1993), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_PLUS, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [67910] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(1995), 1, + anon_sym_RPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1656), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67939] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1985), 1, + anon_sym_BANG, + ACTIONS(1999), 1, + anon_sym_DASH_GT, + STATE(1119), 1, + sym_effect_set, + ACTIONS(1997), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [67962] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(2001), 1, + anon_sym_RPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1691), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [67991] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(436), 1, + anon_sym_COLON_COLON, + STATE(30), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(2003), 9, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_PLUS, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68012] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1985), 1, + anon_sym_BANG, + ACTIONS(2007), 1, + anon_sym_DASH_GT, + STATE(1115), 1, + sym_effect_set, + ACTIONS(2005), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68035] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(2009), 1, + anon_sym_RPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1689), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [68064] = 8, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(2011), 1, + anon_sym_RPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1664), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [68093] = 5, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1985), 1, + anon_sym_BANG, + ACTIONS(2015), 1, + anon_sym_DASH_GT, + STATE(1108), 1, + sym_effect_set, + ACTIONS(2013), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68116] = 11, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(1614), 1, + anon_sym_COMMA, + ACTIONS(2017), 1, + sym_identifier, + ACTIONS(2019), 1, + anon_sym_LBRACE, + ACTIONS(2021), 1, + anon_sym_RBRACE, + ACTIONS(2023), 1, + anon_sym_COLON, + ACTIONS(2025), 1, + anon_sym_LPAREN, + ACTIONS(2027), 1, + anon_sym_EQ_GT, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1355), 1, + aux_sym_field_pattern_repeat1, + [68150] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1985), 1, + anon_sym_BANG, + STATE(1111), 1, + sym_effect_set, + ACTIONS(2029), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68170] = 7, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + ACTIONS(2031), 1, + anon_sym_LBRACE, + STATE(967), 1, + sym_qualified_path, + STATE(1200), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [68196] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1985), 1, + anon_sym_BANG, + STATE(1116), 1, + sym_effect_set, + ACTIONS(2033), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68216] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1965), 1, + anon_sym_LT, + STATE(1102), 1, + sym_type_arguments, + ACTIONS(1963), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68236] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1985), 1, + anon_sym_BANG, + STATE(1104), 1, + sym_effect_set, + ACTIONS(2035), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68256] = 10, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2039), 1, + anon_sym_fn, + ACTIONS(2041), 1, + anon_sym_extern, + ACTIONS(2043), 1, + anon_sym_type, + ACTIONS(2045), 1, + anon_sym_effect, + ACTIONS(2047), 1, + anon_sym_state, + ACTIONS(2049), 1, + anon_sym_module, + ACTIONS(2051), 1, + anon_sym_export, + ACTIONS(2053), 1, + anon_sym_signature, + ACTIONS(2037), 2, + anon_sym_let, + anon_sym_mut, + [68288] = 7, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1662), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [68314] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(1985), 1, + anon_sym_BANG, + STATE(1112), 1, + sym_effect_set, + ACTIONS(2055), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68334] = 7, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1606), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [68360] = 7, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1515), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [68386] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2059), 1, + anon_sym_EQ, + ACTIONS(2061), 1, + anon_sym_LT, + ACTIONS(2057), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68406] = 7, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1973), 1, + sym_identifier, + ACTIONS(1975), 1, + anon_sym_fn, + ACTIONS(1977), 1, + anon_sym_LPAREN, + STATE(967), 1, + sym_qualified_path, + STATE(1624), 1, + sym_type_list, + STATE(1249), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [68432] = 4, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2065), 1, + anon_sym_EQ, + ACTIONS(2067), 1, + anon_sym_LT, + ACTIONS(2063), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [68452] = 10, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2045), 1, + anon_sym_effect, + ACTIONS(2047), 1, + anon_sym_state, + ACTIONS(2049), 1, + anon_sym_module, + ACTIONS(2053), 1, + anon_sym_signature, + ACTIONS(2069), 1, + anon_sym_namespace, + ACTIONS(2073), 1, + anon_sym_fn, + ACTIONS(2075), 1, + anon_sym_extern, + ACTIONS(2077), 1, + anon_sym_type, + ACTIONS(2071), 2, + anon_sym_let, + anon_sym_mut, + [68484] = 8, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1192), 3, - anon_sym_EQ, - anon_sym_where, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2017), 1, sym_identifier, - ACTIONS(1190), 9, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_PIPE, + ACTIONS(2019), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_BANG, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [57332] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1212), 3, - anon_sym_EQ, - anon_sym_where, - sym_identifier, - ACTIONS(1210), 9, - anon_sym_GT, - anon_sym_RPAREN, + ACTIONS(2023), 1, + anon_sym_COLON, + ACTIONS(2025), 1, + anon_sym_LPAREN, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(2027), 4, anon_sym_COMMA, - anon_sym_PIPE, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_BANG, + anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [57352] = 7, - ACTIONS(366), 1, + [68512] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - ACTIONS(1550), 1, - anon_sym_RPAREN, - STATE(1290), 1, + STATE(967), 1, + sym_qualified_path, + STATE(1686), 1, sym_type_list, - STATE(974), 5, + STATE(1249), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57378] = 7, - ACTIONS(366), 1, + [68538] = 10, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(2079), 1, + anon_sym_namespace, + ACTIONS(2083), 1, anon_sym_fn, - ACTIONS(1548), 1, - anon_sym_LPAREN, - ACTIONS(1552), 1, - anon_sym_RPAREN, - STATE(1279), 1, - sym_type_list, - STATE(974), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [57404] = 7, - ACTIONS(366), 1, + ACTIONS(2085), 1, + anon_sym_extern, + ACTIONS(2087), 1, + anon_sym_type, + ACTIONS(2089), 1, + anon_sym_effect, + ACTIONS(2091), 1, + anon_sym_state, + ACTIONS(2093), 1, + anon_sym_module, + ACTIONS(2095), 1, + anon_sym_signature, + ACTIONS(2081), 2, + anon_sym_let, + anon_sym_mut, + [68570] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - ACTIONS(1554), 1, - anon_sym_RPAREN, - STATE(1331), 1, - sym_type_list, - STATE(974), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1174), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57430] = 7, - ACTIONS(366), 1, + [68593] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - ACTIONS(1556), 1, - anon_sym_RPAREN, - STATE(1258), 1, - sym_type_list, - STATE(974), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1477), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57456] = 7, - ACTIONS(366), 1, + [68616] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - ACTIONS(1558), 1, - anon_sym_RPAREN, - STATE(1339), 1, - sym_type_list, - STATE(974), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(488), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57482] = 7, - ACTIONS(366), 1, + [68639] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - ACTIONS(1560), 1, - anon_sym_RPAREN, - STATE(1276), 1, - sym_type_list, - STATE(974), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(1007), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57508] = 6, - ACTIONS(366), 1, + [68662] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - STATE(1299), 1, - sym_type_list, - STATE(974), 5, + ACTIONS(2099), 1, + sym_identifier, + STATE(536), 1, + sym_qualified_path, + STATE(604), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57531] = 6, - ACTIONS(366), 1, + [68685] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - ACTIONS(1562), 1, - anon_sym_LBRACE, - STATE(996), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(476), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57554] = 6, - ACTIONS(366), 1, + [68708] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - STATE(1236), 1, - sym_type_list, - STATE(974), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(1120), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57577] = 4, + [68731] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1566), 1, - sym__doc_comment_line, - STATE(825), 1, - aux_sym_doc_comment_repeat1, - ACTIONS(1564), 7, + ACTIONS(2103), 1, + anon_sym_EQ, + ACTIONS(2101), 8, + anon_sym_RBRACE, anon_sym_let, - anon_sym_mut, anon_sym_fn, - anon_sym_extern, anon_sym_type, anon_sym_effect, anon_sym_module, - [57596] = 4, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1570), 1, + anon_sym_opaque, sym__doc_comment_line, - STATE(825), 1, - aux_sym_doc_comment_repeat1, - ACTIONS(1568), 7, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_extern, - anon_sym_type, - anon_sym_effect, - anon_sym_module, - [57615] = 6, - ACTIONS(366), 1, + [68748] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1244), 1, - sym_type_list, - STATE(974), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1147), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57638] = 6, - ACTIONS(366), 1, + [68771] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - STATE(1318), 1, - sym_type_list, - STATE(974), 5, + ACTIONS(2099), 1, + sym_identifier, + STATE(536), 1, + sym_qualified_path, + STATE(608), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57661] = 5, - ACTIONS(366), 1, + [68794] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1938), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1940), 1, anon_sym_LPAREN, - STATE(937), 5, + ACTIONS(2105), 1, + sym_identifier, + STATE(541), 1, + sym_qualified_path, + STATE(476), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57681] = 5, - ACTIONS(366), 1, + [68817] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1938), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1940), 1, anon_sym_LPAREN, - STATE(1325), 5, + ACTIONS(2105), 1, + sym_identifier, + STATE(541), 1, + sym_qualified_path, + STATE(488), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57701] = 5, - ACTIONS(366), 1, + [68840] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1093), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1711), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57721] = 5, - ACTIONS(366), 1, + [68863] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1573), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1575), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1577), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(554), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1348), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57741] = 5, - ACTIONS(366), 1, + [68886] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1573), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1575), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1577), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(607), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1542), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57761] = 5, - ACTIONS(366), 1, + [68909] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1573), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1575), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1577), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(566), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1722), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57781] = 5, - ACTIONS(366), 1, + [68932] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1573), 1, + ACTIONS(1932), 1, + anon_sym_fn, + ACTIONS(1934), 1, + anon_sym_LPAREN, + ACTIONS(2099), 1, sym_identifier, - ACTIONS(1575), 1, + STATE(536), 1, + sym_qualified_path, + STATE(669), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [68955] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1577), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - STATE(571), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(1114), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57801] = 5, - ACTIONS(366), 1, + [68978] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1579), 1, + ACTIONS(1932), 1, + anon_sym_fn, + ACTIONS(1934), 1, + anon_sym_LPAREN, + ACTIONS(2099), 1, sym_identifier, - ACTIONS(1581), 1, + STATE(536), 1, + sym_qualified_path, + STATE(680), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [69001] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1583), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - STATE(556), 5, + ACTIONS(2099), 1, + sym_identifier, + STATE(536), 1, + sym_qualified_path, + STATE(685), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57821] = 5, - ACTIONS(366), 1, + [69024] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1579), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1581), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1583), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(558), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1316), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57841] = 5, - ACTIONS(366), 1, + [69047] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1573), 1, - sym_identifier, - ACTIONS(1575), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1577), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - STATE(579), 5, + ACTIONS(2099), 1, + sym_identifier, + STATE(536), 1, + sym_qualified_path, + STATE(695), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57861] = 5, - ACTIONS(366), 1, + [69070] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1579), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1581), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1583), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(569), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1186), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57881] = 5, - ACTIONS(366), 1, + [69093] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1938), 1, + anon_sym_fn, + ACTIONS(1940), 1, + anon_sym_LPAREN, + ACTIONS(2105), 1, sym_identifier, - ACTIONS(1546), 1, + STATE(541), 1, + sym_qualified_path, + STATE(591), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [69116] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1938), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1940), 1, anon_sym_LPAREN, - STATE(811), 5, + ACTIONS(2105), 1, + sym_identifier, + STATE(541), 1, + sym_qualified_path, + STATE(475), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57901] = 9, - ACTIONS(366), 1, + [69139] = 9, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1309), 1, - anon_sym_COMMA, - ACTIONS(1585), 1, + ACTIONS(2039), 1, + anon_sym_fn, + ACTIONS(2041), 1, + anon_sym_extern, + ACTIONS(2043), 1, + anon_sym_type, + ACTIONS(2045), 1, + anon_sym_effect, + ACTIONS(2047), 1, + anon_sym_state, + ACTIONS(2049), 1, + anon_sym_module, + ACTIONS(2053), 1, + anon_sym_signature, + ACTIONS(2037), 2, + anon_sym_let, + anon_sym_mut, + [69168] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, + anon_sym_LPAREN, + ACTIONS(2097), 1, sym_identifier, - ACTIONS(1587), 1, - anon_sym_COLON, - ACTIONS(1589), 1, + STATE(946), 1, + sym_qualified_path, + STATE(1107), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [69191] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, anon_sym_LPAREN, - ACTIONS(1591), 1, - anon_sym_LBRACE, - ACTIONS(1593), 1, - anon_sym_RBRACE, - ACTIONS(1595), 1, - anon_sym_EQ_GT, - STATE(1102), 1, - aux_sym_field_pattern_repeat1, - [57929] = 5, - ACTIONS(366), 1, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(475), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [69214] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1579), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1581), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1583), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(545), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1157), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57949] = 5, - ACTIONS(366), 1, + [69237] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1169), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1173), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57969] = 5, - ACTIONS(366), 1, + [69260] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - STATE(814), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(1000), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [57989] = 5, - ACTIONS(366), 1, + [69283] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, + anon_sym_LPAREN, + ACTIONS(2097), 1, sym_identifier, - ACTIONS(1546), 1, + STATE(946), 1, + sym_qualified_path, + STATE(533), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [69306] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - STATE(940), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(591), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58009] = 5, - ACTIONS(366), 1, + [69329] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, + anon_sym_LPAREN, + ACTIONS(2097), 1, sym_identifier, - ACTIONS(1546), 1, + STATE(946), 1, + sym_qualified_path, + STATE(550), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [69352] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1938), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1940), 1, anon_sym_LPAREN, - STATE(1308), 5, + ACTIONS(2105), 1, + sym_identifier, + STATE(541), 1, + sym_qualified_path, + STATE(589), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58029] = 5, - ACTIONS(366), 1, + [69375] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1924), 1, + anon_sym_fn, + ACTIONS(1926), 1, + anon_sym_LPAREN, + ACTIONS(2097), 1, sym_identifier, - ACTIONS(1546), 1, + STATE(946), 1, + sym_qualified_path, + STATE(589), 5, + sym__type, + sym_function_type, + sym_generic_type, + sym_array_type, + sym_type_identifier, + [69398] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - STATE(1098), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(1109), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58049] = 5, - ACTIONS(366), 1, + [69421] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(956), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1680), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58069] = 5, - ACTIONS(366), 1, + [69444] = 3, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(2109), 1, + anon_sym_PLUS, + ACTIONS(2107), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [69461] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1938), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1940), 1, anon_sym_LPAREN, - STATE(1211), 5, + ACTIONS(2105), 1, + sym_identifier, + STATE(541), 1, + sym_qualified_path, + STATE(533), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58089] = 5, - ACTIONS(366), 1, + [69484] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1573), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1575), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1577), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(608), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1295), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58109] = 5, - ACTIONS(366), 1, + [69507] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(948), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1547), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58129] = 5, - ACTIONS(366), 1, + [69530] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1579), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1581), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1583), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(597), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1579), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58149] = 5, - ACTIONS(366), 1, + [69553] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1579), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1581), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1583), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(562), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1506), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58169] = 5, - ACTIONS(366), 1, + [69576] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1434), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1725), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58189] = 5, - ACTIONS(366), 1, + [69599] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1418), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1648), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58209] = 5, - ACTIONS(366), 1, + [69622] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1220), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1165), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58229] = 5, - ACTIONS(366), 1, + [69645] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1579), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1581), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1583), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(619), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1159), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58249] = 5, - ACTIONS(366), 1, + [69668] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(949), 5, + STATE(967), 1, + sym_qualified_path, + STATE(983), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58269] = 5, - ACTIONS(366), 1, + [69691] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1237), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1162), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58289] = 5, - ACTIONS(366), 1, + [69714] = 3, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2113), 1, + anon_sym_EQ, + ACTIONS(2111), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [69731] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1238), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1198), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58309] = 5, - ACTIONS(366), 1, + [69754] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1247), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1175), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58329] = 5, - ACTIONS(366), 1, + [69777] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(960), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1179), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58349] = 5, - ACTIONS(366), 1, + [69800] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(810), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1181), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58369] = 5, - ACTIONS(366), 1, + [69823] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(922), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1185), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58389] = 5, - ACTIONS(366), 1, + [69846] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(923), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1160), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58409] = 5, - ACTIONS(366), 1, + [69869] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(924), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1427), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58429] = 5, - ACTIONS(366), 1, + [69892] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(925), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1597), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58449] = 5, - ACTIONS(366), 1, + [69915] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - STATE(927), 5, + ACTIONS(2099), 1, + sym_identifier, + STATE(536), 1, + sym_qualified_path, + STATE(603), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58469] = 5, - ACTIONS(366), 1, + [69938] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(928), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1636), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58489] = 5, - ACTIONS(366), 1, + [69961] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1938), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1940), 1, anon_sym_LPAREN, - STATE(929), 5, + ACTIONS(2105), 1, + sym_identifier, + STATE(541), 1, + sym_qualified_path, + STATE(550), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58509] = 5, - ACTIONS(366), 1, + [69984] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(931), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1688), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58529] = 5, - ACTIONS(366), 1, + [70007] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(947), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1693), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58549] = 5, - ACTIONS(366), 1, + [70030] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1253), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1700), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58569] = 5, - ACTIONS(366), 1, + [70053] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1280), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1172), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58589] = 5, - ACTIONS(366), 1, + [70076] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1314), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1180), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58609] = 5, - ACTIONS(366), 1, + [70099] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(954), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1183), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58629] = 5, - ACTIONS(366), 1, + [70122] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - STATE(936), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(1105), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58649] = 5, - ACTIONS(366), 1, + [70145] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1321), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1194), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58669] = 5, - ACTIONS(366), 1, + [70168] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1323), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1148), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58689] = 5, - ACTIONS(366), 1, + [70191] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1332), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1151), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58709] = 5, - ACTIONS(366), 1, + [70214] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(938), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1152), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58729] = 5, - ACTIONS(366), 1, + [70237] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(939), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1153), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58749] = 5, - ACTIONS(366), 1, + [70260] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - STATE(966), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(1004), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58769] = 5, - ACTIONS(366), 1, + [70283] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(942), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1538), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58789] = 5, - ACTIONS(366), 1, + [70306] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(943), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1540), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58809] = 5, - ACTIONS(366), 1, + [70329] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(944), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1197), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58829] = 5, - ACTIONS(366), 1, + [70352] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(945), 5, + STATE(967), 1, + sym_qualified_path, + STATE(980), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58849] = 5, - ACTIONS(366), 1, + [70375] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1240), 5, + STATE(967), 1, + sym_qualified_path, + STATE(981), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58869] = 5, - ACTIONS(366), 1, + [70398] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(1241), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1166), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58889] = 5, - ACTIONS(366), 1, + [70421] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(1924), 1, anon_sym_fn, - ACTIONS(1548), 1, + ACTIONS(1926), 1, anon_sym_LPAREN, - STATE(1115), 5, + ACTIONS(2097), 1, + sym_identifier, + STATE(946), 1, + sym_qualified_path, + STATE(1002), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58909] = 5, - ACTIONS(366), 1, + [70444] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1573), 1, + ACTIONS(1973), 1, sym_identifier, - ACTIONS(1575), 1, + ACTIONS(1975), 1, anon_sym_fn, - ACTIONS(1577), 1, + ACTIONS(1977), 1, anon_sym_LPAREN, - STATE(604), 5, + STATE(967), 1, + sym_qualified_path, + STATE(1629), 5, sym__type, sym_function_type, sym_generic_type, sym_array_type, sym_type_identifier, - [58929] = 6, - ACTIONS(366), 1, + [70467] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2115), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70481] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2117), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70495] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2119), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70509] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2121), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70523] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2123), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70537] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2125), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70551] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2127), 1, + anon_sym_LT, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1226), 1, + sym_type_arguments, + ACTIONS(1963), 4, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_RBRACK, + [70573] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2129), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70587] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2131), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70601] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2133), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70615] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2135), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70629] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2137), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70643] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2139), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70657] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2141), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70671] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2143), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70685] = 2, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1585), 1, - sym_identifier, - ACTIONS(1587), 1, - anon_sym_COLON, - ACTIONS(1589), 1, - anon_sym_LPAREN, - ACTIONS(1591), 1, - anon_sym_LBRACE, - ACTIONS(1595), 4, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [58951] = 5, - ACTIONS(366), 1, + ACTIONS(2145), 8, + anon_sym_RBRACE, + anon_sym_let, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70699] = 2, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1544), 1, - sym_identifier, - ACTIONS(1546), 1, + ACTIONS(2147), 8, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1548), 1, - anon_sym_LPAREN, - STATE(1153), 5, - sym__type, - sym_function_type, - sym_generic_type, - sym_array_type, - sym_type_identifier, - [58971] = 7, - ACTIONS(366), 1, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70713] = 2, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1599), 1, + ACTIONS(2149), 8, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1601), 1, - anon_sym_extern, - ACTIONS(1603), 1, anon_sym_type, - ACTIONS(1605), 1, anon_sym_effect, - ACTIONS(1607), 1, anon_sym_module, - ACTIONS(1597), 2, + anon_sym_opaque, + sym__doc_comment_line, + [70727] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2151), 8, + anon_sym_RBRACE, anon_sym_let, - anon_sym_mut, - [58994] = 7, - ACTIONS(366), 1, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70741] = 2, + ACTIONS(3), 1, sym_line_comment, - ACTIONS(1611), 1, + ACTIONS(2153), 8, + anon_sym_RBRACE, + anon_sym_let, anon_sym_fn, - ACTIONS(1613), 1, - anon_sym_extern, - ACTIONS(1615), 1, anon_sym_type, - ACTIONS(1617), 1, anon_sym_effect, - ACTIONS(1619), 1, anon_sym_module, - ACTIONS(1609), 2, + anon_sym_opaque, + sym__doc_comment_line, + [70755] = 2, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(2155), 8, + anon_sym_RBRACE, anon_sym_let, - anon_sym_mut, - [59017] = 7, - ACTIONS(366), 1, + anon_sym_fn, + anon_sym_type, + anon_sym_effect, + anon_sym_module, + anon_sym_opaque, + sym__doc_comment_line, + [70769] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1621), 1, + ACTIONS(2157), 1, + anon_sym_LBRACE, + ACTIONS(2159), 1, anon_sym_EQ, - ACTIONS(1623), 1, + ACTIONS(2161), 1, anon_sym_DASH_GT, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - STATE(543), 1, + STATE(583), 1, sym_block, - STATE(1140), 1, + STATE(1320), 1, sym_effect_set, - [59039] = 7, - ACTIONS(366), 1, + [70791] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1629), 1, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2167), 1, anon_sym_EQ, - ACTIONS(1631), 1, + ACTIONS(2169), 1, anon_sym_DASH_GT, - ACTIONS(1633), 1, - anon_sym_LBRACE, - STATE(485), 1, + STATE(586), 1, sym_block, - STATE(1056), 1, + STATE(1321), 1, sym_effect_set, - [59061] = 7, - ACTIONS(366), 1, + [70813] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1635), 1, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2171), 1, anon_sym_EQ, - ACTIONS(1637), 1, + ACTIONS(2173), 1, anon_sym_DASH_GT, - ACTIONS(1639), 1, - anon_sym_LBRACE, - STATE(493), 1, + STATE(519), 1, sym_block, - STATE(1132), 1, + STATE(1308), 1, sym_effect_set, - [59083] = 7, - ACTIONS(366), 1, + [70835] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1641), 1, + ACTIONS(2175), 1, anon_sym_EQ, - ACTIONS(1643), 1, + ACTIONS(2177), 1, anon_sym_DASH_GT, - STATE(498), 1, + STATE(552), 1, sym_block, - STATE(1133), 1, + STATE(1322), 1, sym_effect_set, - [59105] = 7, - ACTIONS(366), 1, + [70857] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1645), 1, + ACTIONS(2181), 1, anon_sym_EQ, - ACTIONS(1647), 1, + ACTIONS(2183), 1, anon_sym_DASH_GT, - STATE(511), 1, + STATE(677), 1, sym_block, - STATE(1039), 1, + STATE(1409), 1, sym_effect_set, - [59127] = 7, - ACTIONS(366), 1, + [70879] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1649), 1, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2185), 1, anon_sym_EQ, - ACTIONS(1651), 1, + ACTIONS(2187), 1, anon_sym_DASH_GT, - STATE(574), 1, + STATE(575), 1, sym_block, - STATE(1094), 1, + STATE(1326), 1, sym_effect_set, - [59149] = 7, - ACTIONS(366), 1, + [70901] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1653), 1, + ACTIONS(2189), 1, anon_sym_EQ, - ACTIONS(1655), 1, + ACTIONS(2191), 1, anon_sym_DASH_GT, - STATE(513), 1, + STATE(641), 1, sym_block, - STATE(1040), 1, + STATE(1357), 1, sym_effect_set, - [59171] = 7, - ACTIONS(366), 1, + [70923] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1657), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2193), 1, anon_sym_EQ, - ACTIONS(1659), 1, + ACTIONS(2195), 1, anon_sym_DASH_GT, - STATE(526), 1, + STATE(552), 1, sym_block, - STATE(1046), 1, + STATE(1331), 1, sym_effect_set, - [59193] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1663), 1, - anon_sym_LT, - STATE(1004), 1, - sym_type_arguments, - ACTIONS(1661), 4, - anon_sym_EQ, - anon_sym_COMMA, - anon_sym_LBRACE, - anon_sym_RBRACK, - [59209] = 7, - ACTIONS(366), 1, + [70945] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1665), 1, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2197), 1, anon_sym_EQ, - ACTIONS(1667), 1, + ACTIONS(2199), 1, anon_sym_DASH_GT, - STATE(560), 1, + STATE(660), 1, sym_block, - STATE(1088), 1, + STATE(1390), 1, sym_effect_set, - [59231] = 7, - ACTIONS(366), 1, + [70967] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2127), 1, + anon_sym_LT, + STATE(1226), 1, + sym_type_arguments, + ACTIONS(1963), 4, anon_sym_LBRACE, - ACTIONS(1627), 1, + anon_sym_COMMA, + anon_sym_EQ, + anon_sym_RBRACK, + [70983] = 7, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1669), 1, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2201), 1, anon_sym_EQ, - ACTIONS(1671), 1, + ACTIONS(2203), 1, anon_sym_DASH_GT, - STATE(576), 1, + STATE(689), 1, sym_block, - STATE(1044), 1, + STATE(1280), 1, sym_effect_set, - [59253] = 7, - ACTIONS(366), 1, + [71005] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1673), 1, + ACTIONS(2205), 1, anon_sym_EQ, - ACTIONS(1675), 1, + ACTIONS(2207), 1, anon_sym_DASH_GT, - STATE(561), 1, + STATE(586), 1, sym_block, - STATE(1139), 1, + STATE(1377), 1, sym_effect_set, - [59275] = 7, - ACTIONS(366), 1, + [71027] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1677), 1, + ACTIONS(2209), 1, anon_sym_EQ, - ACTIONS(1679), 1, + ACTIONS(2211), 1, anon_sym_DASH_GT, - STATE(586), 1, + STATE(585), 1, sym_block, - STATE(1076), 1, + STATE(1307), 1, sym_effect_set, - [59297] = 7, - ACTIONS(366), 1, + [71049] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1681), 1, + ACTIONS(2213), 1, anon_sym_EQ, - ACTIONS(1683), 1, + ACTIONS(2215), 1, anon_sym_DASH_GT, - STATE(523), 1, + STATE(691), 1, sym_block, - STATE(1111), 1, + STATE(1281), 1, sym_effect_set, - [59319] = 7, - ACTIONS(366), 1, + [71071] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1685), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2217), 1, anon_sym_EQ, - ACTIONS(1687), 1, + ACTIONS(2219), 1, anon_sym_DASH_GT, - STATE(523), 1, + STATE(575), 1, sym_block, - STATE(1105), 1, + STATE(1312), 1, sym_effect_set, - [59341] = 7, - ACTIONS(366), 1, + [71093] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1689), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2221), 1, anon_sym_EQ, - ACTIONS(1691), 1, + ACTIONS(2223), 1, anon_sym_DASH_GT, - STATE(485), 1, + STATE(519), 1, sym_block, - STATE(1118), 1, + STATE(1340), 1, sym_effect_set, - [59363] = 2, - ACTIONS(3), 1, - sym_line_comment, - ACTIONS(1693), 6, - anon_sym_let, - anon_sym_mut, - anon_sym_fn, - anon_sym_type, - anon_sym_RBRACE, - sym__doc_comment_line, - [59375] = 7, - ACTIONS(366), 1, + [71115] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1695), 1, + ACTIONS(2225), 1, anon_sym_EQ, - ACTIONS(1697), 1, + ACTIONS(2227), 1, anon_sym_DASH_GT, - STATE(526), 1, + STATE(568), 1, sym_block, - STATE(1113), 1, + STATE(1313), 1, sym_effect_set, - [59397] = 7, - ACTIONS(366), 1, + [71137] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1699), 1, + ACTIONS(2229), 1, anon_sym_EQ, - ACTIONS(1701), 1, + ACTIONS(2231), 1, anon_sym_DASH_GT, - STATE(513), 1, + STATE(585), 1, sym_block, - STATE(1131), 1, + STATE(1314), 1, sym_effect_set, - [59419] = 7, - ACTIONS(366), 1, + [71159] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1703), 1, + ACTIONS(2233), 1, anon_sym_EQ, - ACTIONS(1705), 1, + ACTIONS(2235), 1, anon_sym_DASH_GT, - STATE(498), 1, + STATE(701), 1, sym_block, - STATE(1066), 1, + STATE(1285), 1, sym_effect_set, - [59441] = 7, - ACTIONS(366), 1, + [71181] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1707), 1, + ACTIONS(2237), 1, anon_sym_EQ, - ACTIONS(1709), 1, + ACTIONS(2239), 1, anon_sym_DASH_GT, - STATE(535), 1, + STATE(545), 1, sym_block, - STATE(1121), 1, + STATE(1300), 1, sym_effect_set, - [59463] = 7, - ACTIONS(366), 1, + [71203] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1711), 1, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2241), 1, anon_sym_EQ, - ACTIONS(1713), 1, + ACTIONS(2243), 1, anon_sym_DASH_GT, - STATE(548), 1, + STATE(673), 1, sym_block, - STATE(1055), 1, + STATE(1401), 1, sym_effect_set, - [59485] = 7, - ACTIONS(366), 1, + [71225] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1715), 1, + ACTIONS(2245), 1, anon_sym_EQ, - ACTIONS(1717), 1, + ACTIONS(2247), 1, anon_sym_DASH_GT, - STATE(493), 1, + STATE(545), 1, sym_block, - STATE(1083), 1, + STATE(1305), 1, sym_effect_set, - [59507] = 7, - ACTIONS(366), 1, + [71247] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1719), 1, + ACTIONS(2249), 1, anon_sym_EQ, - ACTIONS(1721), 1, + ACTIONS(2251), 1, anon_sym_DASH_GT, - STATE(521), 1, + STATE(583), 1, sym_block, - STATE(1122), 1, + STATE(1301), 1, sym_effect_set, - [59529] = 7, - ACTIONS(366), 1, + [71269] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1723), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2253), 1, anon_sym_EQ, - ACTIONS(1725), 1, + ACTIONS(2255), 1, anon_sym_DASH_GT, - STATE(511), 1, + STATE(568), 1, sym_block, - STATE(1085), 1, + STATE(1359), 1, sym_effect_set, - [59551] = 7, - ACTIONS(366), 1, + [71291] = 7, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1727), 1, + ACTIONS(2257), 1, anon_sym_EQ, - ACTIONS(1729), 1, + ACTIONS(2259), 1, anon_sym_DASH_GT, - STATE(521), 1, + STATE(655), 1, sym_block, - STATE(1062), 1, + STATE(1382), 1, sym_effect_set, - [59573] = 5, - ACTIONS(366), 1, + [71313] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1439), 1, + STATE(1586), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [59590] = 6, - ACTIONS(366), 1, + [71330] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1735), 1, + ACTIONS(2265), 1, anon_sym_EQ, - STATE(564), 1, + STATE(546), 1, sym_block, - STATE(1061), 1, + STATE(1366), 1, sym_effect_set, - [59609] = 6, - ACTIONS(366), 1, + [71349] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1737), 1, - anon_sym_EQ, - STATE(532), 1, - sym_block, - STATE(1114), 1, - sym_effect_set, - [59628] = 6, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1739), 1, + ACTIONS(2267), 1, anon_sym_EQ, - STATE(578), 1, + STATE(534), 1, sym_block, - STATE(1049), 1, + STATE(1325), 1, sym_effect_set, - [59647] = 6, - ACTIONS(366), 1, + [71368] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1741), 1, - anon_sym_EQ, - STATE(582), 1, - sym_block, - STATE(1053), 1, - sym_effect_set, - [59666] = 5, - ACTIONS(366), 1, + ACTIONS(2261), 1, + sym_identifier, + STATE(1370), 1, + sym_type_parameter, + STATE(1520), 1, + sym_type_parameter_list, + ACTIONS(2263), 2, + anon_sym_in, + anon_sym_out, + [71385] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1743), 1, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2269), 1, sym_identifier, - ACTIONS(1745), 1, - anon_sym_LBRACE, - STATE(457), 1, - sym_variant, - STATE(456), 2, - sym_union_type, - sym_record_type, - [59683] = 6, - ACTIONS(366), 1, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1236), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [71402] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1747), 1, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2271), 1, anon_sym_EQ, - STATE(589), 1, + STATE(542), 1, sym_block, - STATE(1078), 1, + STATE(1327), 1, sym_effect_set, - [59702] = 6, - ACTIONS(366), 1, + [71421] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1749), 1, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2273), 1, anon_sym_EQ, - STATE(590), 1, + STATE(546), 1, sym_block, - STATE(1081), 1, + STATE(1328), 1, sym_effect_set, - [59721] = 6, - ACTIONS(366), 1, + [71440] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1751), 1, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2275), 1, anon_sym_EQ, - STATE(595), 1, + STATE(559), 1, sym_block, - STATE(1090), 1, + STATE(1330), 1, sym_effect_set, - [59740] = 5, - ACTIONS(366), 1, + [71459] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1553), 1, + anon_sym_type, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(974), 1, + sym_type_declaration, + STATE(1650), 1, + sym_doc_comment, + [71478] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1337), 1, + STATE(1665), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [59757] = 6, - ACTIONS(366), 1, + [71495] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2277), 1, + anon_sym_COLON, + STATE(717), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(2003), 2, + anon_sym_LBRACE, + anon_sym_PLUS, + [71512] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1753), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2279), 1, anon_sym_EQ, - STATE(530), 1, + STATE(559), 1, sym_block, - STATE(1054), 1, + STATE(1413), 1, sym_effect_set, - [59776] = 5, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1755), 1, - sym_identifier, - ACTIONS(1757), 1, - anon_sym_LBRACE, - STATE(472), 1, - sym_variant, - STATE(467), 2, - sym_union_type, - sym_record_type, - [59793] = 5, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1743), 1, - sym_identifier, - ACTIONS(1745), 1, - anon_sym_LBRACE, - STATE(457), 1, - sym_variant, - STATE(460), 2, - sym_union_type, - sym_record_type, - [59810] = 5, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1731), 1, - sym_identifier, - STATE(1101), 1, - sym_type_parameter, - STATE(1353), 1, - sym_type_parameter_list, - ACTIONS(1733), 2, - anon_sym_in, - anon_sym_out, - [59827] = 5, - ACTIONS(366), 1, + [71531] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1355), 1, + STATE(1561), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [59844] = 6, - ACTIONS(366), 1, + [71548] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1759), 1, + ACTIONS(2281), 1, anon_sym_EQ, - STATE(506), 1, + STATE(679), 1, sym_block, - STATE(1059), 1, + STATE(1410), 1, sym_effect_set, - [59863] = 6, - ACTIONS(366), 1, + [71567] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1761), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2283), 1, anon_sym_EQ, - STATE(502), 1, + STATE(527), 1, sym_block, - STATE(1127), 1, + STATE(1297), 1, sym_effect_set, - [59882] = 6, - ACTIONS(366), 1, + [71586] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2269), 1, + sym_identifier, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1215), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [71603] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1763), 1, + ACTIONS(2285), 1, anon_sym_EQ, - STATE(503), 1, + STATE(683), 1, sym_block, - STATE(1137), 1, + STATE(1415), 1, sym_effect_set, - [59901] = 6, - ACTIONS(366), 1, + [71622] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2287), 1, + anon_sym_COLON, + STATE(1156), 1, + aux_sym_qualified_path_repeat1, + ACTIONS(1993), 2, + anon_sym_LBRACE, + anon_sym_PLUS, + [71639] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2261), 1, + sym_identifier, + STATE(1370), 1, + sym_type_parameter, + STATE(1638), 1, + sym_type_parameter_list, + ACTIONS(2263), 2, + anon_sym_in, + anon_sym_out, + [71656] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1765), 1, + ACTIONS(2289), 1, anon_sym_EQ, - STATE(508), 1, + STATE(667), 1, sym_block, - STATE(1144), 1, + STATE(1395), 1, sym_effect_set, - [59920] = 6, - ACTIONS(366), 1, + [71675] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1767), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2291), 1, anon_sym_EQ, - STATE(516), 1, + STATE(542), 1, sym_block, - STATE(1146), 1, + STATE(1338), 1, sym_effect_set, - [59939] = 5, - ACTIONS(366), 1, + [71694] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2261), 1, + sym_identifier, + STATE(1370), 1, + sym_type_parameter, + STATE(1507), 1, + sym_type_parameter_list, + ACTIONS(2263), 2, + anon_sym_in, + anon_sym_out, + [71711] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1424), 1, + STATE(1531), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [59956] = 6, - ACTIONS(366), 1, + [71728] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2269), 1, + sym_identifier, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1276), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [71745] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2293), 1, + sym_identifier, + ACTIONS(2295), 1, + sym_string, + STATE(508), 1, + sym_import_target, + STATE(509), 1, + sym_namespace_name, + STATE(623), 1, + sym_legacy_import_path, + [71764] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2269), 1, + sym_identifier, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + STATE(1241), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [71781] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1769), 1, + ACTIONS(2297), 1, anon_sym_EQ, - STATE(518), 1, + STATE(527), 1, sym_block, - STATE(1043), 1, + STATE(1310), 1, sym_effect_set, - [59975] = 6, - ACTIONS(366), 1, + [71800] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1771), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2299), 1, anon_sym_EQ, - STATE(530), 1, + STATE(572), 1, sym_block, - STATE(1047), 1, + STATE(1376), 1, sym_effect_set, - [59994] = 6, - ACTIONS(366), 1, + [71819] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1773), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2301), 1, anon_sym_EQ, - STATE(506), 1, + STATE(534), 1, sym_block, - STATE(1048), 1, + STATE(1363), 1, sym_effect_set, - [60013] = 6, - ACTIONS(366), 1, + [71838] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1775), 1, + ACTIONS(2303), 1, anon_sym_EQ, - STATE(484), 1, + STATE(698), 1, sym_block, - STATE(1050), 1, + STATE(1283), 1, sym_effect_set, - [60032] = 5, - ACTIONS(366), 1, + [71857] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1743), 1, + ACTIONS(2261), 1, sym_identifier, - ACTIONS(1745), 1, - anon_sym_LBRACE, - STATE(457), 1, - sym_variant, - STATE(454), 2, - sym_union_type, - sym_record_type, - [60049] = 6, - ACTIONS(366), 1, + STATE(1370), 1, + sym_type_parameter, + STATE(1731), 1, + sym_type_parameter_list, + ACTIONS(2263), 2, + anon_sym_in, + anon_sym_out, + [71874] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2261), 1, + sym_identifier, + STATE(1370), 1, + sym_type_parameter, + STATE(1782), 1, + sym_type_parameter_list, + ACTIONS(2263), 2, + anon_sym_in, + anon_sym_out, + [71891] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2305), 1, + sym_identifier, + ACTIONS(2307), 1, + sym_string, + STATE(492), 1, + sym_namespace_name, + STATE(506), 1, + sym_import_target, + STATE(621), 1, + sym_legacy_import_path, + [71910] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1777), 1, + ACTIONS(2309), 1, anon_sym_EQ, - STATE(508), 1, + STATE(704), 1, sym_block, - STATE(1120), 1, + STATE(1286), 1, sym_effect_set, - [60068] = 6, - ACTIONS(366), 1, + [71929] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1779), 1, + ACTIONS(2311), 1, anon_sym_EQ, - STATE(484), 1, + STATE(590), 1, sym_block, - STATE(1107), 1, + STATE(1315), 1, sym_effect_set, - [60087] = 6, - ACTIONS(366), 1, + [71948] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1781), 1, + ACTIONS(2313), 1, anon_sym_EQ, - STATE(518), 1, + STATE(705), 1, sym_block, - STATE(1087), 1, + STATE(1287), 1, sym_effect_set, - [60106] = 5, - ACTIONS(366), 1, + [71967] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1354), 1, + STATE(1608), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60123] = 5, - ACTIONS(366), 1, + [71984] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2315), 1, + anon_sym_EQ, + STATE(558), 1, + sym_block, + STATE(1318), 1, + sym_effect_set, + [72003] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1428), 1, + STATE(1652), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60140] = 5, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1755), 1, - sym_identifier, - ACTIONS(1757), 1, - anon_sym_LBRACE, - STATE(472), 1, - sym_variant, - STATE(471), 2, - sym_union_type, - sym_record_type, - [60157] = 5, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1755), 1, - sym_identifier, - ACTIONS(1757), 1, - anon_sym_LBRACE, - STATE(472), 1, - sym_variant, - STATE(473), 2, - sym_union_type, - sym_record_type, - [60174] = 6, - ACTIONS(366), 1, + [72020] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1783), 1, + ACTIONS(2317), 1, anon_sym_EQ, - STATE(502), 1, + STATE(710), 1, sym_block, - STATE(1057), 1, + STATE(1289), 1, sym_effect_set, - [60193] = 5, - ACTIONS(366), 1, + [72039] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1755), 1, - sym_identifier, - ACTIONS(1757), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - STATE(472), 1, - sym_variant, - STATE(464), 2, - sym_union_type, - sym_record_type, - [60210] = 6, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1627), 1, + ACTIONS(2163), 1, anon_sym_BANG, - ACTIONS(1633), 1, - anon_sym_LBRACE, - ACTIONS(1785), 1, + ACTIONS(2319), 1, anon_sym_EQ, - STATE(503), 1, + STATE(590), 1, sym_block, - STATE(1145), 1, + STATE(1311), 1, sym_effect_set, - [60229] = 5, - ACTIONS(366), 1, + [72058] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1743), 1, + ACTIONS(2261), 1, sym_identifier, - ACTIONS(1745), 1, - anon_sym_LBRACE, - STATE(457), 1, - sym_variant, - STATE(459), 2, - sym_union_type, - sym_record_type, - [60246] = 5, - ACTIONS(366), 1, + STATE(1370), 1, + sym_type_parameter, + STATE(1667), 1, + sym_type_parameter_list, + ACTIONS(2263), 2, + anon_sym_in, + anon_sym_out, + [72075] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1275), 1, + STATE(1612), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60263] = 5, - ACTIONS(366), 1, + [72092] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1293), 1, + STATE(1719), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60280] = 6, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1787), 1, - anon_sym_EQ, - STATE(552), 1, - sym_block, - STATE(1129), 1, - sym_effect_set, - [60299] = 5, - ACTIONS(366), 1, + [72109] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1383), 1, + STATE(1726), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60316] = 5, - ACTIONS(366), 1, + [72126] = 6, + ACTIONS(3), 1, + sym_line_comment, + ACTIONS(67), 1, + sym__doc_comment_line, + ACTIONS(1553), 1, + anon_sym_type, + STATE(968), 1, + aux_sym_doc_comment_repeat1, + STATE(979), 1, + sym_type_declaration, + STATE(1650), 1, + sym_doc_comment, + [72145] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1388), 1, + STATE(1762), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60333] = 5, - ACTIONS(366), 1, + [72162] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1415), 1, + STATE(1765), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60350] = 5, - ACTIONS(366), 1, + [72179] = 6, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2321), 1, + anon_sym_EQ, + STATE(572), 1, + sym_block, + STATE(1324), 1, + sym_effect_set, + [72198] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1417), 1, + STATE(1772), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60367] = 5, - ACTIONS(366), 1, + [72215] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2261), 1, sym_identifier, - STATE(1101), 1, + STATE(1370), 1, sym_type_parameter, - STATE(1423), 1, + STATE(1773), 1, sym_type_parameter_list, - ACTIONS(1733), 2, + ACTIONS(2263), 2, anon_sym_in, anon_sym_out, - [60384] = 6, - ACTIONS(366), 1, + [72232] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1627), 1, - anon_sym_BANG, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1789), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2323), 1, anon_sym_EQ, - STATE(516), 1, + STATE(558), 1, sym_block, - STATE(1042), 1, + STATE(1400), 1, sym_effect_set, - [60403] = 5, - ACTIONS(366), 1, + [72251] = 6, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, - sym_identifier, - ACTIONS(1793), 1, - anon_sym_RPAREN, - STATE(968), 1, - sym_parameter, - STATE(1350), 1, - sym_parameter_list, - [60419] = 4, - ACTIONS(366), 1, + ACTIONS(2163), 1, + anon_sym_BANG, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2325), 1, + anon_sym_EQ, + STATE(693), 1, + sym_block, + STATE(1282), 1, + sym_effect_set, + [72270] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1797), 1, + ACTIONS(2327), 1, anon_sym_COMMA, - STATE(1033), 1, + STATE(1199), 1, aux_sym_parameter_list_repeat1, - ACTIONS(1795), 2, + ACTIONS(2330), 2, anon_sym_RPAREN, anon_sym_PIPE, - [60433] = 5, - ACTIONS(366), 1, + [72284] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, - sym_identifier, - ACTIONS(1799), 1, + ACTIONS(2332), 4, + anon_sym_COMMA, anon_sym_RPAREN, - STATE(968), 1, - sym_parameter, - STATE(1347), 1, - sym_parameter_list, - [60449] = 5, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1801), 1, - sym_identifier, - ACTIONS(1803), 1, + anon_sym_RBRACK, anon_sym_EQ_GT, - STATE(1117), 1, - aux_sym_handler_params_repeat1, - STATE(1295), 1, - sym_handler_params, - [60465] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1805), 1, - sym_identifier, - ACTIONS(1807), 1, - anon_sym_in, - STATE(1024), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [60479] = 2, - ACTIONS(366), 1, + [72294] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1809), 4, - anon_sym_RPAREN, + ACTIONS(2334), 4, anon_sym_COMMA, + anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [60489] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1615), 1, - anon_sym_type, - ACTIONS(1813), 1, - anon_sym_fn, - ACTIONS(1811), 2, - anon_sym_let, - anon_sym_mut, - [60503] = 4, - ACTIONS(366), 1, + [72304] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1817), 1, + ACTIONS(2336), 4, anon_sym_COMMA, - STATE(977), 1, - aux_sym_type_list_repeat1, - ACTIONS(1815), 2, - anon_sym_GT, - anon_sym_RPAREN, - [60517] = 5, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1791), 1, - sym_identifier, - ACTIONS(1819), 1, anon_sym_RPAREN, - STATE(968), 1, - sym_parameter, - STATE(1416), 1, - sym_parameter_list, - [60533] = 5, - ACTIONS(366), 1, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [72314] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1821), 1, - anon_sym_RPAREN, - STATE(968), 1, + ACTIONS(2340), 1, + anon_sym_PIPE, + STATE(1211), 1, sym_parameter, - STATE(1255), 1, + STATE(1657), 1, sym_parameter_list, - [60549] = 4, - ACTIONS(366), 1, + [72330] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1817), 1, + ACTIONS(2342), 4, anon_sym_COMMA, - STATE(1012), 1, - aux_sym_type_list_repeat1, - ACTIONS(1823), 2, - anon_sym_GT, anon_sym_RPAREN, - [60563] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1825), 4, - anon_sym_EQ, - anon_sym_COMMA, - anon_sym_LBRACE, anon_sym_RBRACK, - [60573] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1827), 1, - sym_identifier, - ACTIONS(1829), 1, - anon_sym_RBRACE, - STATE(993), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - [60587] = 4, - ACTIONS(366), 1, + anon_sym_EQ_GT, + [72340] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2344), 1, sym_identifier, - ACTIONS(1831), 1, - anon_sym_RBRACE, - STATE(1027), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - [60601] = 5, - ACTIONS(366), 1, + ACTIONS(2346), 1, + anon_sym_RPAREN, + STATE(1333), 1, + sym_extern_parameter, + STATE(1523), 1, + sym_extern_parameter_list, + [72356] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1833), 1, + ACTIONS(2344), 1, sym_identifier, - ACTIONS(1835), 1, + ACTIONS(2348), 1, anon_sym_RPAREN, - STATE(1063), 1, + STATE(1333), 1, sym_extern_parameter, - STATE(1317), 1, + STATE(1641), 1, sym_extern_parameter_list, - [60617] = 5, - ACTIONS(366), 1, + [72372] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2350), 1, + sym_identifier, + ACTIONS(2352), 1, + anon_sym_RBRACE, + STATE(1247), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + [72386] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1837), 1, + ACTIONS(2354), 1, anon_sym_RPAREN, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1301), 1, + STATE(1574), 1, sym_parameter_list, - [60633] = 2, - ACTIONS(366), 1, + [72402] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1839), 4, - anon_sym_RPAREN, + ACTIONS(2356), 4, anon_sym_COMMA, + anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [60643] = 2, - ACTIONS(366), 1, + [72412] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1841), 4, + ACTIONS(2358), 1, + anon_sym_COMMA, + STATE(1210), 1, + aux_sym_type_list_repeat1, + ACTIONS(2361), 2, + anon_sym_GT, + anon_sym_RPAREN, + [72426] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2363), 1, + anon_sym_COMMA, + STATE(1237), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2365), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [72440] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2367), 1, + anon_sym_COMMA, + STATE(1210), 1, + aux_sym_type_list_repeat1, + ACTIONS(2369), 2, + anon_sym_GT, anon_sym_RPAREN, + [72454] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2135), 4, + anon_sym_LBRACE, anon_sym_COMMA, + anon_sym_EQ, anon_sym_RBRACK, - anon_sym_EQ_GT, - [60653] = 4, - ACTIONS(366), 1, + [72464] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1843), 1, + ACTIONS(2371), 1, anon_sym_RBRACE, - STATE(1035), 2, + STATE(1219), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [60667] = 4, - ACTIONS(366), 1, + [72478] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1805), 1, + ACTIONS(2373), 1, sym_identifier, - ACTIONS(1845), 1, + ACTIONS(2375), 1, anon_sym_in, - STATE(1024), 2, + STATE(1266), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [60681] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1847), 4, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [60691] = 4, - ACTIONS(366), 1, + [72492] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1731), 1, + ACTIONS(2344), 1, sym_identifier, - STATE(1149), 1, - sym_type_parameter, - ACTIONS(1733), 2, - anon_sym_in, - anon_sym_out, - [60705] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1849), 4, + ACTIONS(2377), 1, anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [60715] = 2, - ACTIONS(366), 1, + STATE(1333), 1, + sym_extern_parameter, + STATE(1668), 1, + sym_extern_parameter_list, + [72508] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1851), 4, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [60725] = 2, - ACTIONS(366), 1, + ACTIONS(2379), 1, + sym_identifier, + ACTIONS(2381), 1, + anon_sym_RBRACE, + STATE(1291), 1, + sym_import_member, + STATE(1576), 1, + sym_import_member_list, + [72524] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1853), 4, + ACTIONS(2344), 1, + sym_identifier, + ACTIONS(2383), 1, anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [60735] = 2, - ACTIONS(366), 1, + STATE(1333), 1, + sym_extern_parameter, + STATE(1593), 1, + sym_extern_parameter_list, + [72540] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1855), 4, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_EQ_GT, - [60745] = 4, - ACTIONS(366), 1, + ACTIONS(2350), 1, + sym_identifier, + ACTIONS(2385), 1, + anon_sym_RBRACE, + STATE(1259), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + [72554] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1857), 1, + ACTIONS(2387), 1, anon_sym_RBRACE, - STATE(1027), 2, + STATE(1259), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [60759] = 4, - ACTIONS(366), 1, + [72568] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1859), 1, + ACTIONS(2389), 1, anon_sym_RBRACE, - STATE(1027), 2, + STATE(1224), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [60773] = 4, - ACTIONS(366), 1, + [72582] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1861), 1, - anon_sym_COMMA, - STATE(995), 1, - aux_sym_argument_list_repeat1, - ACTIONS(1322), 2, + ACTIONS(2391), 1, + sym_identifier, + ACTIONS(2393), 1, + anon_sym_LBRACK, + STATE(1003), 1, + sym_qualified_path, + STATE(1100), 1, + sym_effect_ref, + [72598] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2344), 1, + sym_identifier, + ACTIONS(2395), 1, anon_sym_RPAREN, - anon_sym_RBRACK, - [60787] = 2, - ACTIONS(366), 1, + STATE(1333), 1, + sym_extern_parameter, + STATE(1681), 1, + sym_extern_parameter_list, + [72614] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2350), 1, + sym_identifier, + ACTIONS(2397), 1, + anon_sym_RBRACE, + STATE(1259), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + [72628] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1864), 4, + ACTIONS(2338), 1, + sym_identifier, + ACTIONS(2399), 1, anon_sym_RPAREN, + STATE(1211), 1, + sym_parameter, + STATE(1510), 1, + sym_parameter_list, + [72644] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2119), 4, + anon_sym_LBRACE, anon_sym_COMMA, + anon_sym_EQ, anon_sym_RBRACK, - anon_sym_EQ_GT, - [60797] = 5, - ACTIONS(366), 1, + [72654] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1866), 1, + ACTIONS(2401), 1, anon_sym_RPAREN, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1429), 1, + STATE(1690), 1, sym_parameter_list, - [60813] = 5, - ACTIONS(366), 1, + [72670] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1868), 1, - anon_sym_PIPE, - STATE(968), 1, - sym_parameter, - STATE(1252), 1, - sym_parameter_list, - [60829] = 5, - ACTIONS(366), 1, + ACTIONS(2403), 1, + anon_sym_RBRACE, + STATE(1230), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + [72684] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1870), 1, + ACTIONS(2405), 1, anon_sym_RPAREN, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1265), 1, + STATE(1653), 1, sym_parameter_list, - [60845] = 4, - ACTIONS(366), 1, + [72700] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1872), 1, + ACTIONS(2407), 1, anon_sym_RBRACE, - STATE(1027), 2, + STATE(1259), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [60859] = 4, - ACTIONS(366), 1, + [72714] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2344), 1, sym_identifier, - ACTIONS(1874), 1, + ACTIONS(2409), 1, + anon_sym_RPAREN, + STATE(1333), 1, + sym_extern_parameter, + STATE(1535), 1, + sym_extern_parameter_list, + [72730] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2350), 1, + sym_identifier, + ACTIONS(2411), 1, anon_sym_RBRACE, - STATE(1027), 2, + STATE(1234), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [60873] = 5, - ACTIONS(366), 1, + [72744] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1876), 1, - anon_sym_RPAREN, - STATE(968), 1, - sym_parameter, - STATE(1273), 1, - sym_parameter_list, - [60889] = 5, - ACTIONS(366), 1, + ACTIONS(2413), 1, + anon_sym_RBRACE, + STATE(1220), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + [72758] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1878), 1, - anon_sym_RPAREN, - STATE(968), 1, - sym_parameter, - STATE(1292), 1, - sym_parameter_list, - [60905] = 2, - ACTIONS(366), 1, + ACTIONS(2415), 1, + anon_sym_RBRACE, + STATE(1259), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + [72772] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1880), 4, - anon_sym_EQ, - anon_sym_COMMA, - anon_sym_LBRACE, - anon_sym_RBRACK, - [60915] = 5, - ACTIONS(366), 1, + ACTIONS(2417), 1, + sym_identifier, + STATE(1130), 1, + sym_qualified_path, + STATE(1362), 1, + sym_effect_ref, + STATE(1581), 1, + sym_effect_list, + [72788] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2373), 1, sym_identifier, - ACTIONS(1882), 1, + ACTIONS(2419), 1, + anon_sym_in, + STATE(1266), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [72802] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2363), 1, + anon_sym_COMMA, + STATE(1199), 1, + aux_sym_parameter_list_repeat1, + ACTIONS(2421), 2, anon_sym_RPAREN, - STATE(968), 1, - sym_parameter, - STATE(1298), 1, - sym_parameter_list, - [60931] = 4, - ACTIONS(366), 1, + anon_sym_PIPE, + [72816] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2417), 1, sym_identifier, - ACTIONS(1884), 1, + ACTIONS(2423), 1, + anon_sym_LBRACK, + STATE(1130), 1, + sym_qualified_path, + STATE(1433), 1, + sym_effect_ref, + [72832] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2350), 1, + sym_identifier, + ACTIONS(2425), 1, anon_sym_RBRACE, - STATE(994), 2, + STATE(1259), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [60945] = 5, - ACTIONS(366), 1, + [72846] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1886), 1, - anon_sym_RPAREN, - STATE(968), 1, - sym_parameter, - STATE(1303), 1, - sym_parameter_list, - [60961] = 4, - ACTIONS(366), 1, + ACTIONS(2427), 1, + anon_sym_RBRACE, + STATE(1259), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + [72860] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2373), 1, sym_identifier, - ACTIONS(1888), 1, + ACTIONS(2429), 1, + anon_sym_in, + STATE(1266), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [72874] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2350), 1, + sym_identifier, + ACTIONS(2431), 1, anon_sym_RBRACE, - STATE(1019), 2, + STATE(1239), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [60975] = 5, - ACTIONS(366), 1, + [72888] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1890), 1, + ACTIONS(2433), 1, anon_sym_PIPE, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1312), 1, + STATE(1555), 1, sym_parameter_list, - [60991] = 5, - ACTIONS(366), 1, + [72904] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1892), 1, + ACTIONS(2435), 1, anon_sym_RPAREN, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1322), 1, + STATE(1573), 1, sym_parameter_list, - [61007] = 4, - ACTIONS(366), 1, + [72920] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2437), 4, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [72930] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1805), 1, + ACTIONS(2379), 1, sym_identifier, - ACTIONS(1894), 1, - anon_sym_in, - STATE(1024), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [61021] = 4, - ACTIONS(366), 1, + ACTIONS(2439), 1, + anon_sym_RBRACE, + STATE(1291), 1, + sym_import_member, + STATE(1779), 1, + sym_import_member_list, + [72946] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2350), 1, + sym_identifier, + ACTIONS(2441), 1, + anon_sym_RBRACE, + STATE(1259), 2, + sym_operation_declaration, + aux_sym_effect_declaration_repeat1, + [72960] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2338), 1, + sym_identifier, + ACTIONS(2443), 1, + anon_sym_RPAREN, + STATE(1211), 1, + sym_parameter, + STATE(1584), 1, + sym_parameter_list, + [72976] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1898), 1, + ACTIONS(2367), 1, anon_sym_COMMA, - STATE(1012), 1, + STATE(1212), 1, aux_sym_type_list_repeat1, - ACTIONS(1896), 2, + ACTIONS(2445), 2, anon_sym_GT, anon_sym_RPAREN, - [61035] = 5, - ACTIONS(366), 1, + [72990] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1901), 1, + ACTIONS(2447), 1, anon_sym_RPAREN, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1327), 1, + STATE(1607), 1, sym_parameter_list, - [61051] = 3, - ACTIONS(366), 1, + [73006] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1903), 1, - anon_sym_COLON, - ACTIONS(1905), 3, + ACTIONS(2338), 1, + sym_identifier, + ACTIONS(2449), 1, anon_sym_RPAREN, + STATE(1211), 1, + sym_parameter, + STATE(1617), 1, + sym_parameter_list, + [73022] = 5, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2417), 1, + sym_identifier, + STATE(1130), 1, + sym_qualified_path, + STATE(1362), 1, + sym_effect_ref, + STATE(1712), 1, + sym_effect_list, + [73038] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2451), 1, anon_sym_COMMA, - anon_sym_PIPE, - [61063] = 5, - ACTIONS(366), 1, + STATE(1253), 1, + aux_sym_argument_list_repeat1, + ACTIONS(1670), 2, + anon_sym_RPAREN, + anon_sym_RBRACK, + [73052] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1833), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1907), 1, + ACTIONS(2454), 1, anon_sym_RPAREN, - STATE(1063), 1, - sym_extern_parameter, - STATE(1386), 1, - sym_extern_parameter_list, - [61079] = 5, - ACTIONS(366), 1, + STATE(1211), 1, + sym_parameter, + STATE(1623), 1, + sym_parameter_list, + [73068] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1909), 1, + ACTIONS(2456), 1, anon_sym_PIPE, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1440), 1, + STATE(1633), 1, sym_parameter_list, - [61095] = 5, - ACTIONS(366), 1, + [73084] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1911), 1, + ACTIONS(2458), 1, anon_sym_RPAREN, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1341), 1, + STATE(1646), 1, sym_parameter_list, - [61111] = 5, - ACTIONS(366), 1, + [73100] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1833), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1913), 1, + ACTIONS(2460), 1, anon_sym_RPAREN, - STATE(1063), 1, - sym_extern_parameter, - STATE(1224), 1, - sym_extern_parameter_list, - [61127] = 4, - ACTIONS(366), 1, + STATE(1211), 1, + sym_parameter, + STATE(1651), 1, + sym_parameter_list, + [73116] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2464), 1, + anon_sym_COLON, + ACTIONS(2462), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_PIPE, + [73128] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2466), 1, sym_identifier, - ACTIONS(1915), 1, + ACTIONS(2469), 1, anon_sym_RBRACE, - STATE(1027), 2, + STATE(1259), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [61141] = 5, - ACTIONS(366), 1, + [73142] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1917), 1, + ACTIONS(2471), 1, anon_sym_RPAREN, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1345), 1, + STATE(1794), 1, sym_parameter_list, - [61157] = 4, - ACTIONS(366), 1, + [73158] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2350), 1, sym_identifier, - ACTIONS(1919), 1, + ACTIONS(2473), 1, anon_sym_RBRACE, - STATE(1030), 2, + STATE(1240), 2, sym_operation_declaration, aux_sym_effect_declaration_repeat1, - [61171] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1923), 1, - anon_sym_COMMA, - STATE(1022), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(1921), 2, - anon_sym_RPAREN, - anon_sym_PIPE, - [61185] = 4, - ACTIONS(366), 1, + [73172] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1926), 1, - anon_sym_RBRACE, - STATE(980), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - [61199] = 4, - ACTIONS(366), 1, + ACTIONS(2475), 1, + anon_sym_RPAREN, + STATE(1211), 1, + sym_parameter, + STATE(1671), 1, + sym_parameter_list, + [73188] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1928), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1931), 1, - anon_sym_in, - STATE(1024), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [61213] = 5, - ACTIONS(366), 1, + ACTIONS(2477), 1, + anon_sym_RPAREN, + STATE(1211), 1, + sym_parameter, + STATE(1676), 1, + sym_parameter_list, + [73204] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1933), 1, + ACTIONS(2479), 1, anon_sym_PIPE, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1356), 1, + STATE(1682), 1, sym_parameter_list, - [61229] = 5, - ACTIONS(366), 1, + [73220] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1935), 1, + ACTIONS(2481), 1, anon_sym_RPAREN, - STATE(968), 1, + STATE(1211), 1, sym_parameter, - STATE(1358), 1, + STATE(1685), 1, sym_parameter_list, - [61245] = 4, - ACTIONS(366), 1, + [73236] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1937), 1, + ACTIONS(2483), 1, sym_identifier, - ACTIONS(1940), 1, - anon_sym_RBRACE, - STATE(1027), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - [61259] = 2, - ACTIONS(366), 1, + ACTIONS(2486), 1, + anon_sym_in, + STATE(1266), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [73250] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1942), 4, - anon_sym_RPAREN, + ACTIONS(2488), 4, anon_sym_COMMA, + anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [61269] = 5, - ACTIONS(366), 1, + [73260] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1833), 1, + ACTIONS(2344), 1, sym_identifier, - ACTIONS(1944), 1, + ACTIONS(2490), 1, anon_sym_RPAREN, - STATE(1063), 1, + STATE(1333), 1, sym_extern_parameter, - STATE(1274), 1, + STATE(1724), 1, sym_extern_parameter_list, - [61285] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1827), 1, - sym_identifier, - ACTIONS(1946), 1, - anon_sym_RBRACE, - STATE(1027), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - [61299] = 2, - ACTIONS(366), 1, + [73276] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1948), 4, - anon_sym_RPAREN, + ACTIONS(2492), 4, anon_sym_COMMA, + anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [61309] = 4, - ACTIONS(366), 1, + [73286] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2344), 1, sym_identifier, - ACTIONS(1950), 1, - anon_sym_RBRACE, - STATE(1001), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - [61323] = 4, - ACTIONS(366), 1, + ACTIONS(2494), 1, + anon_sym_RPAREN, + STATE(1333), 1, + sym_extern_parameter, + STATE(1728), 1, + sym_extern_parameter_list, + [73302] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1797), 1, + ACTIONS(2496), 4, anon_sym_COMMA, - STATE(1022), 1, - aux_sym_parameter_list_repeat1, - ACTIONS(1952), 2, anon_sym_RPAREN, - anon_sym_PIPE, - [61337] = 2, - ACTIONS(366), 1, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [73312] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1954), 4, + ACTIONS(2498), 4, + anon_sym_COMMA, anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [73322] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2500), 4, anon_sym_COMMA, + anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_EQ_GT, - [61347] = 4, - ACTIONS(366), 1, + [73332] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2502), 1, sym_identifier, - ACTIONS(1956), 1, - anon_sym_RBRACE, - STATE(1027), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - [61361] = 4, - ACTIONS(366), 1, + ACTIONS(2504), 1, + anon_sym_EQ_GT, + STATE(1388), 1, + aux_sym_handler_params_repeat1, + STATE(1675), 1, + sym_handler_params, + [73348] = 5, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(2338), 1, sym_identifier, - ACTIONS(1958), 1, - anon_sym_RBRACE, - STATE(1000), 2, - sym_operation_declaration, - aux_sym_effect_declaration_repeat1, - [61375] = 4, - ACTIONS(366), 1, + ACTIONS(2506), 1, + anon_sym_RPAREN, + STATE(1211), 1, + sym_parameter, + STATE(1780), 1, + sym_parameter_list, + [73364] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1805), 1, + ACTIONS(2373), 1, sym_identifier, - ACTIONS(1960), 1, + ACTIONS(2508), 1, anon_sym_in, - STATE(1024), 2, + STATE(1266), 2, sym_handler_arm, aux_sym_handler_expression_repeat1, - [61389] = 4, - ACTIONS(366), 1, + [73378] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1962), 1, + ACTIONS(2510), 4, + anon_sym_COMMA, anon_sym_RPAREN, - ACTIONS(1964), 1, + anon_sym_RBRACK, + anon_sym_EQ_GT, + [73388] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2261), 1, + sym_identifier, + STATE(1490), 1, + sym_type_parameter, + ACTIONS(2263), 2, + anon_sym_in, + anon_sym_out, + [73402] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2512), 1, + anon_sym_RBRACE, + ACTIONS(2514), 1, anon_sym_COMMA, - STATE(1128), 1, - aux_sym_named_argument_list_repeat1, - [61402] = 4, - ACTIONS(366), 1, + STATE(1368), 1, + aux_sym_field_declarations_repeat1, + [73415] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1966), 1, + ACTIONS(2516), 1, anon_sym_EQ, - STATE(520), 1, + STATE(699), 1, sym_block, - [61415] = 4, - ACTIONS(366), 1, + [73428] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1968), 1, + ACTIONS(2518), 1, anon_sym_EQ, - STATE(522), 1, + STATE(700), 1, sym_block, - [61428] = 4, - ACTIONS(366), 1, + [73441] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1970), 1, - sym_identifier, - STATE(1070), 1, - sym_field_assignment, - STATE(1285), 1, - sym_field_assignments, - [61441] = 4, - ACTIONS(366), 1, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2520), 1, + anon_sym_EQ, + STATE(702), 1, + sym_block, + [73454] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1972), 1, + ACTIONS(2522), 1, anon_sym_EQ, - STATE(528), 1, + STATE(703), 1, + sym_block, + [73467] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2524), 1, + anon_sym_RBRACE, + ACTIONS(2526), 1, + anon_sym_COMMA, + STATE(1303), 1, + aux_sym_map_literal_repeat1, + [73480] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2528), 1, + anon_sym_EQ, + STATE(706), 1, sym_block, - [61454] = 4, - ACTIONS(366), 1, + [73493] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1974), 1, + ACTIONS(2530), 1, anon_sym_EQ, - STATE(529), 1, + STATE(708), 1, sym_block, - [61467] = 4, - ACTIONS(366), 1, + [73506] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(1976), 1, + ACTIONS(2532), 1, anon_sym_EQ, - STATE(585), 1, + STATE(709), 1, sym_block, - [61480] = 4, - ACTIONS(366), 1, + [73519] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2534), 1, + anon_sym_as, + ACTIONS(2536), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [73530] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2538), 1, + anon_sym_EQ, + STATE(711), 1, + sym_block, + [73543] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2526), 1, + anon_sym_COMMA, + ACTIONS(2540), 1, + anon_sym_RBRACE, + STATE(1294), 1, + aux_sym_map_literal_repeat1, + [73556] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2542), 1, + anon_sym_RBRACE, + ACTIONS(2544), 1, + anon_sym_COMMA, + STATE(1381), 1, + aux_sym_import_member_list_repeat1, + [73569] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2546), 1, + anon_sym_COMMA, + ACTIONS(2548), 1, + anon_sym_RBRACK, + STATE(1393), 1, + aux_sym_effect_list_repeat1, + [73582] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2550), 1, + anon_sym_COMMA, + ACTIONS(2553), 1, + anon_sym_RPAREN, + STATE(1293), 1, + aux_sym_extern_parameter_list_repeat1, + [73595] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1978), 1, + ACTIONS(2526), 1, anon_sym_COMMA, - ACTIONS(1980), 1, + ACTIONS(2555), 1, anon_sym_RBRACE, - STATE(1069), 1, + STATE(1303), 1, aux_sym_map_literal_repeat1, - [61493] = 4, - ACTIONS(366), 1, + [73608] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2559), 1, + anon_sym_where, + ACTIONS(2557), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [73619] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1666), 1, + anon_sym_COMMA, + ACTIONS(2561), 1, + anon_sym_RBRACK, + STATE(1253), 1, + aux_sym_argument_list_repeat1, + [73632] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1982), 1, + ACTIONS(2563), 1, anon_sym_EQ, - STATE(479), 1, + STATE(588), 1, sym_block, - [61506] = 4, - ACTIONS(366), 1, + [73645] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2565), 1, + anon_sym_LBRACE, + ACTIONS(2567), 1, + anon_sym_COLON, + STATE(1793), 1, + sym_signature_ascription, + [73658] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2569), 1, + sym_identifier, + STATE(1375), 1, + sym_field_assignment, + STATE(1524), 1, + sym_field_assignments, + [73671] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1984), 1, + ACTIONS(2571), 1, anon_sym_EQ, - STATE(481), 1, + STATE(532), 1, sym_block, - [61519] = 4, - ACTIONS(366), 1, + [73684] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1986), 1, + ACTIONS(2573), 1, anon_sym_EQ, - STATE(483), 1, + STATE(530), 1, sym_block, - [61532] = 4, - ACTIONS(366), 1, + [73697] = 3, + ACTIONS(430), 1, + sym_line_comment, + STATE(1389), 1, + sym_namespace_name, + ACTIONS(2575), 2, + sym_string, + sym_identifier, + [73708] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2577), 1, + anon_sym_RBRACE, + ACTIONS(2579), 1, + anon_sym_COMMA, + STATE(1303), 1, + aux_sym_map_literal_repeat1, + [73721] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2582), 1, + anon_sym_RBRACE, + ACTIONS(2584), 1, + anon_sym_COMMA, + STATE(1304), 1, + aux_sym_field_declarations_repeat1, + [73734] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(1988), 1, + ACTIONS(2587), 1, anon_sym_EQ, - STATE(587), 1, + STATE(532), 1, sym_block, - [61545] = 4, - ACTIONS(366), 1, + [73747] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2589), 1, + anon_sym_LBRACE, + ACTIONS(2591), 1, + anon_sym_if, + STATE(766), 1, + sym_if_expression, + [73760] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(1990), 1, + ACTIONS(2593), 1, anon_sym_EQ, - STATE(486), 1, + STATE(571), 1, sym_block, - [61558] = 4, - ACTIONS(366), 1, + [73773] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1992), 1, - sym_identifier, - ACTIONS(1995), 1, - anon_sym_EQ_GT, - STATE(1051), 1, - aux_sym_handler_params_repeat1, - [61571] = 4, - ACTIONS(366), 1, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2595), 1, + anon_sym_EQ, + STATE(564), 1, + sym_block, + [73786] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1997), 1, - anon_sym_RPAREN, - ACTIONS(1999), 1, + ACTIONS(2597), 1, anon_sym_COMMA, - STATE(1065), 1, - aux_sym_pattern_repeat1, - [61584] = 4, - ACTIONS(366), 1, + ACTIONS(2599), 1, + anon_sym_GT, + STATE(1397), 1, + aux_sym_type_parameter_list_repeat1, + [73799] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2001), 1, + ACTIONS(2601), 1, anon_sym_EQ, STATE(588), 1, sym_block, - [61597] = 4, - ACTIONS(366), 1, + [73812] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2157), 1, + anon_sym_LBRACE, + ACTIONS(2603), 1, + anon_sym_EQ, + STATE(535), 1, + sym_block, + [73825] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2003), 1, + ACTIONS(2605), 1, anon_sym_EQ, - STATE(481), 1, + STATE(549), 1, sym_block, - [61610] = 4, - ACTIONS(366), 1, + [73838] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2005), 1, + ACTIONS(2607), 1, anon_sym_EQ, - STATE(559), 1, + STATE(554), 1, sym_block, - [61623] = 4, - ACTIONS(366), 1, + [73851] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2007), 1, + ACTIONS(2609), 1, anon_sym_EQ, - STATE(482), 1, + STATE(571), 1, sym_block, - [61636] = 4, - ACTIONS(366), 1, + [73864] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2009), 1, + ACTIONS(2611), 1, anon_sym_EQ, - STATE(531), 1, + STATE(535), 1, sym_block, - [61649] = 4, - ACTIONS(366), 1, + [73877] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1978), 1, + ACTIONS(2613), 3, anon_sym_COMMA, - ACTIONS(2011), 1, - anon_sym_RBRACE, - STATE(1138), 1, - aux_sym_map_literal_repeat1, - [61662] = 4, - ACTIONS(366), 1, + anon_sym_RPAREN, + anon_sym_PIPE, + [73886] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2330), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_PIPE, + [73895] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2013), 1, + ACTIONS(2615), 1, anon_sym_EQ, - STATE(483), 1, + STATE(562), 1, sym_block, - [61675] = 4, - ACTIONS(366), 1, + [73908] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2015), 1, + ACTIONS(1666), 1, + anon_sym_COMMA, + ACTIONS(2617), 1, + anon_sym_RBRACK, + STATE(1253), 1, + aux_sym_argument_list_repeat1, + [73921] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2017), 1, - anon_sym_if, - STATE(317), 1, - sym_if_expression, - [61688] = 4, - ACTIONS(366), 1, + ACTIONS(2619), 1, + anon_sym_EQ, + STATE(530), 1, + sym_block, + [73934] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2019), 1, + ACTIONS(2621), 1, anon_sym_EQ, - STATE(575), 1, + STATE(547), 1, sym_block, - [61701] = 4, - ACTIONS(366), 1, + [73947] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, + ACTIONS(2623), 1, + anon_sym_EQ, + STATE(569), 1, + sym_block, + [73960] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1614), 1, + anon_sym_COMMA, ACTIONS(2021), 1, + anon_sym_RBRACE, + STATE(1355), 1, + aux_sym_field_pattern_repeat1, + [73973] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2625), 1, anon_sym_EQ, - STATE(491), 1, + STATE(526), 1, sym_block, - [61714] = 4, - ACTIONS(366), 1, + [73986] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2023), 1, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2627), 1, + anon_sym_EQ, + STATE(537), 1, + sym_block, + [73999] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2629), 1, + anon_sym_EQ, + STATE(549), 1, + sym_block, + [74012] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2631), 1, + anon_sym_EQ, + STATE(555), 1, + sym_block, + [74025] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2633), 1, + anon_sym_EQ, + STATE(515), 1, + sym_block, + [74038] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2526), 1, + anon_sym_COMMA, + ACTIONS(2635), 1, + anon_sym_RBRACE, + STATE(1303), 1, + aux_sym_map_literal_repeat1, + [74051] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2165), 1, + anon_sym_LBRACE, + ACTIONS(2637), 1, + anon_sym_EQ, + STATE(573), 1, + sym_block, + [74064] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2157), 1, + anon_sym_LBRACE, + ACTIONS(2639), 1, + anon_sym_EQ, + STATE(569), 1, + sym_block, + [74077] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1666), 1, + anon_sym_COMMA, + ACTIONS(2641), 1, anon_sym_RPAREN, - ACTIONS(2025), 1, + STATE(1253), 1, + aux_sym_argument_list_repeat1, + [74090] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2643), 1, anon_sym_COMMA, - STATE(1123), 1, + ACTIONS(2645), 1, + anon_sym_RPAREN, + STATE(1356), 1, aux_sym_extern_parameter_list_repeat1, - [61727] = 3, - ACTIONS(366), 1, + [74103] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2027), 1, + STATE(1391), 1, + sym_namespace_name, + ACTIONS(2575), 2, + sym_string, sym_identifier, - STATE(1011), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [61738] = 4, - ACTIONS(366), 1, + [74114] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1999), 1, + ACTIONS(2647), 1, + anon_sym_LBRACE, + ACTIONS(2649), 1, + anon_sym_SEMI, + STATE(638), 1, + sym_namespace_body, + [74127] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2651), 1, anon_sym_COMMA, - ACTIONS(2029), 1, + ACTIONS(2653), 1, anon_sym_RPAREN, - STATE(1108), 1, + STATE(1407), 1, aux_sym_pattern_repeat1, - [61751] = 4, - ACTIONS(366), 1, + [74140] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + STATE(1372), 1, + sym_namespace_name, + ACTIONS(2575), 2, + sym_string, + sym_identifier, + [74151] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2031), 1, + ACTIONS(2655), 1, anon_sym_EQ, - STATE(510), 1, + STATE(555), 1, + sym_block, + [74164] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2269), 1, + sym_identifier, + STATE(1215), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [74175] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2157), 1, + anon_sym_LBRACE, + ACTIONS(2657), 1, + anon_sym_EQ, + STATE(564), 1, sym_block, - [61764] = 4, - ACTIONS(366), 1, + [74188] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2567), 1, + anon_sym_COLON, + ACTIONS(2659), 1, + anon_sym_LBRACE, + STATE(1577), 1, + sym_signature_ascription, + [74201] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2569), 1, + sym_identifier, + STATE(1375), 1, + sym_field_assignment, + STATE(1514), 1, + sym_field_assignments, + [74214] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2417), 1, + sym_identifier, + STATE(1130), 1, + sym_qualified_path, + STATE(1480), 1, + sym_effect_ref, + [74227] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2661), 1, + anon_sym_COMMA, + ACTIONS(2664), 1, + anon_sym_RPAREN, + STATE(1344), 1, + aux_sym_pattern_repeat1, + [74240] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2569), 1, + sym_identifier, + STATE(1375), 1, + sym_field_assignment, + STATE(1521), 1, + sym_field_assignments, + [74253] = 3, + ACTIONS(430), 1, + sym_line_comment, + STATE(1335), 1, + sym_namespace_name, + ACTIONS(2575), 2, + sym_string, + sym_identifier, + [74264] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1964), 1, + ACTIONS(2666), 1, anon_sym_COMMA, - ACTIONS(2033), 1, + ACTIONS(2668), 1, anon_sym_RPAREN, - STATE(1038), 1, + STATE(1399), 1, aux_sym_named_argument_list_repeat1, - [61777] = 4, - ACTIONS(366), 1, + [74277] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1970), 1, + ACTIONS(2361), 3, + anon_sym_COMMA, + anon_sym_GT, + anon_sym_RPAREN, + [74286] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2567), 1, + anon_sym_COLON, + ACTIONS(2670), 1, + anon_sym_LBRACE, + STATE(1589), 1, + sym_signature_ascription, + [74299] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2569), 1, sym_identifier, - STATE(1070), 1, + STATE(1375), 1, sym_field_assignment, - STATE(1381), 1, + STATE(1568), 1, sym_field_assignments, - [61790] = 4, - ACTIONS(366), 1, + [74312] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1978), 1, - anon_sym_COMMA, - ACTIONS(2035), 1, + ACTIONS(2567), 1, + anon_sym_COLON, + ACTIONS(2672), 1, + anon_sym_LBRACE, + STATE(1598), 1, + sym_signature_ascription, + [74325] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2674), 1, + sym_identifier, + STATE(1279), 1, + sym_field_declaration, + STATE(1594), 1, + sym_field_declarations, + [74338] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2676), 1, anon_sym_RBRACE, - STATE(1138), 1, - aux_sym_map_literal_repeat1, - [61803] = 4, - ACTIONS(366), 1, + ACTIONS(2678), 1, + anon_sym_COMMA, + STATE(1394), 1, + aux_sym_field_assignments_repeat1, + [74351] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2567), 1, + anon_sym_COLON, + ACTIONS(2680), 1, + anon_sym_LBRACE, + STATE(1566), 1, + sym_signature_ascription, + [74364] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2037), 1, + ACTIONS(1614), 1, anon_sym_COMMA, - ACTIONS(2039), 1, + ACTIONS(2682), 1, anon_sym_RBRACE, - STATE(1135), 1, - aux_sym_field_assignments_repeat1, - [61816] = 4, - ACTIONS(366), 1, + STATE(1365), 1, + aux_sym_field_pattern_repeat1, + [74377] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2643), 1, + anon_sym_COMMA, + ACTIONS(2684), 1, + anon_sym_RPAREN, + STATE(1293), 1, + aux_sym_extern_parameter_list_repeat1, + [74390] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2686), 1, + anon_sym_EQ, + STATE(654), 1, + sym_block, + [74403] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2041), 1, - anon_sym_COMMA, - ACTIONS(2043), 1, - anon_sym_RBRACE, - STATE(1095), 1, - aux_sym_field_declarations_repeat1, - [61829] = 4, - ACTIONS(366), 1, + ACTIONS(2567), 1, + anon_sym_COLON, + ACTIONS(2688), 1, + anon_sym_LBRACE, + STATE(1609), 1, + sym_signature_ascription, + [74416] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1970), 1, - sym_identifier, - STATE(1070), 1, - sym_field_assignment, - STATE(1217), 1, - sym_field_assignments, - [61842] = 4, - ACTIONS(366), 1, + ACTIONS(2157), 1, + anon_sym_LBRACE, + ACTIONS(2690), 1, + anon_sym_EQ, + STATE(554), 1, + sym_block, + [74429] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2045), 1, + ACTIONS(2674), 1, sym_identifier, - STATE(1071), 1, + STATE(1279), 1, sym_field_declaration, - STATE(1287), 1, + STATE(1660), 1, sym_field_declarations, - [61855] = 4, - ACTIONS(366), 1, + [74442] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2045), 1, + ACTIONS(2692), 1, sym_identifier, - STATE(1071), 1, - sym_field_declaration, - STATE(1225), 1, - sym_field_declarations, - [61868] = 4, - ACTIONS(366), 1, + STATE(600), 1, + sym_variant, + STATE(606), 1, + sym_qualified_path, + [74455] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2047), 1, + ACTIONS(2546), 1, anon_sym_COMMA, - ACTIONS(2049), 1, + ACTIONS(2694), 1, anon_sym_RBRACK, - STATE(1141), 1, + STATE(1292), 1, aux_sym_effect_list_repeat1, - [61881] = 4, - ACTIONS(366), 1, + [74468] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2051), 1, + ACTIONS(2696), 1, anon_sym_EQ, - STATE(591), 1, + STATE(537), 1, sym_block, - [61894] = 4, - ACTIONS(366), 1, + [74481] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1978), 1, - anon_sym_COMMA, - ACTIONS(2053), 1, + ACTIONS(2698), 1, + sym_identifier, + STATE(501), 1, + sym_variant, + STATE(510), 1, + sym_qualified_path, + [74494] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2700), 1, anon_sym_RBRACE, - STATE(1089), 1, - aux_sym_map_literal_repeat1, - [61907] = 4, - ACTIONS(366), 1, + ACTIONS(2702), 1, + anon_sym_COMMA, + STATE(1365), 1, + aux_sym_field_pattern_repeat1, + [74507] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2055), 1, + ACTIONS(2705), 1, anon_sym_EQ, - STATE(593), 1, + STATE(515), 1, sym_block, - [61920] = 4, - ACTIONS(366), 1, + [74520] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1314), 1, - anon_sym_COMMA, - ACTIONS(2057), 1, - anon_sym_RBRACK, - STATE(995), 1, - aux_sym_argument_list_repeat1, - [61933] = 4, - ACTIONS(366), 1, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2707), 1, + anon_sym_DOT, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + [74533] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1978), 1, + ACTIONS(2514), 1, anon_sym_COMMA, - ACTIONS(2059), 1, + ACTIONS(2709), 1, anon_sym_RBRACE, - STATE(1058), 1, - aux_sym_map_literal_repeat1, - [61946] = 4, - ACTIONS(366), 1, + STATE(1304), 1, + aux_sym_field_declarations_repeat1, + [74546] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2567), 1, + anon_sym_COLON, + ACTIONS(2711), 1, anon_sym_LBRACE, - ACTIONS(2061), 1, - anon_sym_EQ, - STATE(594), 1, - sym_block, - [61959] = 4, - ACTIONS(366), 1, + STATE(1670), 1, + sym_signature_ascription, + [74559] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2045), 1, + ACTIONS(2597), 1, + anon_sym_COMMA, + ACTIONS(2713), 1, + anon_sym_GT, + STATE(1309), 1, + aux_sym_type_parameter_list_repeat1, + [74572] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2269), 1, sym_identifier, - STATE(1071), 1, - sym_field_declaration, - STATE(1257), 1, - sym_field_declarations, - [61972] = 4, - ACTIONS(366), 1, + STATE(1236), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [74583] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2715), 1, anon_sym_LBRACE, - ACTIONS(2063), 1, - anon_sym_EQ, - STATE(509), 1, - sym_block, - [61985] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1314), 1, - anon_sym_COMMA, - ACTIONS(2065), 1, - anon_sym_RPAREN, - STATE(995), 1, - aux_sym_argument_list_repeat1, - [61998] = 4, - ACTIONS(366), 1, + ACTIONS(2717), 1, + anon_sym_SEMI, + STATE(628), 1, + sym_namespace_body, + [74596] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, - anon_sym_LBRACE, - ACTIONS(2067), 1, - anon_sym_EQ, - STATE(520), 1, - sym_block, - [62011] = 4, - ACTIONS(366), 1, + ACTIONS(2569), 1, + sym_identifier, + STATE(1375), 1, + sym_field_assignment, + STATE(1558), 1, + sym_field_assignments, + [74609] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1970), 1, + ACTIONS(2569), 1, sym_identifier, - STATE(1070), 1, + STATE(1375), 1, sym_field_assignment, - STATE(1291), 1, + STATE(1580), 1, sym_field_assignments, - [62024] = 4, - ACTIONS(366), 1, + [74622] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, - anon_sym_LBRACE, - ACTIONS(2069), 1, - anon_sym_EQ, - STATE(529), 1, - sym_block, - [62037] = 4, - ACTIONS(366), 1, + ACTIONS(2678), 1, + anon_sym_COMMA, + ACTIONS(2719), 1, + anon_sym_RBRACE, + STATE(1353), 1, + aux_sym_field_assignments_repeat1, + [74635] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2071), 1, + ACTIONS(2721), 1, anon_sym_EQ, - STATE(570), 1, + STATE(526), 1, sym_block, - [62050] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1978), 1, - anon_sym_COMMA, - ACTIONS(2073), 1, - anon_sym_RBRACE, - STATE(1138), 1, - aux_sym_map_literal_repeat1, - [62063] = 4, - ACTIONS(366), 1, + [74648] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2075), 1, + ACTIONS(2723), 1, anon_sym_EQ, - STATE(598), 1, + STATE(547), 1, sym_block, - [62076] = 4, - ACTIONS(366), 1, + [74661] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2077), 1, - anon_sym_GT, - ACTIONS(2079), 1, + ACTIONS(2569), 1, + sym_identifier, + STATE(1375), 1, + sym_field_assignment, + STATE(1632), 1, + sym_field_assignments, + [74674] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2666), 1, anon_sym_COMMA, - STATE(1091), 1, - aux_sym_type_parameter_list_repeat1, - [62089] = 4, - ACTIONS(366), 1, + ACTIONS(2725), 1, + anon_sym_RPAREN, + STATE(1347), 1, + aux_sym_named_argument_list_repeat1, + [74687] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1314), 1, + ACTIONS(1666), 1, anon_sym_COMMA, - ACTIONS(2082), 1, + ACTIONS(2727), 1, anon_sym_RBRACK, - STATE(995), 1, + STATE(1253), 1, aux_sym_argument_list_repeat1, - [62102] = 3, - ACTIONS(366), 1, + [74700] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2086), 1, - anon_sym_where, - ACTIONS(2084), 2, + ACTIONS(2544), 1, anon_sym_COMMA, + ACTIONS(2729), 1, anon_sym_RBRACE, - [62113] = 4, - ACTIONS(366), 1, + STATE(1383), 1, + aux_sym_import_member_list_repeat1, + [74713] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(2088), 1, + ACTIONS(2731), 1, anon_sym_EQ, - STATE(584), 1, + STATE(668), 1, sym_block, - [62126] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2041), 1, - anon_sym_COMMA, - ACTIONS(2090), 1, - anon_sym_RBRACE, - STATE(1103), 1, - aux_sym_field_declarations_repeat1, - [62139] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2027), 1, - sym_identifier, - STATE(986), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [62150] = 4, - ACTIONS(366), 1, + [74726] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1309), 1, - anon_sym_COMMA, - ACTIONS(1593), 1, + ACTIONS(2733), 1, anon_sym_RBRACE, - STATE(1102), 1, - aux_sym_field_pattern_repeat1, - [62163] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1896), 3, - anon_sym_GT, - anon_sym_RPAREN, - anon_sym_COMMA, - [62172] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2092), 1, - sym_identifier, - ACTIONS(2094), 1, - anon_sym_LBRACK, - STATE(1158), 1, - sym_effect_ref, - [62185] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1970), 1, - sym_identifier, - STATE(1070), 1, - sym_field_assignment, - STATE(1239), 1, - sym_field_assignments, - [62198] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2096), 1, - anon_sym_GT, - ACTIONS(2098), 1, + ACTIONS(2735), 1, anon_sym_COMMA, - STATE(1148), 1, - aux_sym_type_parameter_list_repeat1, - [62211] = 4, - ACTIONS(366), 1, + STATE(1383), 1, + aux_sym_import_member_list_repeat1, + [74739] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1309), 1, + ACTIONS(2526), 1, anon_sym_COMMA, - ACTIONS(2100), 1, + ACTIONS(2738), 1, anon_sym_RBRACE, - STATE(1134), 1, - aux_sym_field_pattern_repeat1, - [62224] = 4, - ACTIONS(366), 1, + STATE(1284), 1, + aux_sym_map_literal_repeat1, + [74752] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2102), 1, + ACTIONS(2526), 1, anon_sym_COMMA, - ACTIONS(2105), 1, + ACTIONS(2740), 1, anon_sym_RBRACE, - STATE(1103), 1, - aux_sym_field_declarations_repeat1, - [62237] = 4, - ACTIONS(366), 1, + STATE(1329), 1, + aux_sym_map_literal_repeat1, + [74765] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1970), 1, - sym_identifier, - STATE(1070), 1, - sym_field_assignment, - STATE(1272), 1, - sym_field_assignments, - [62250] = 4, - ACTIONS(366), 1, + ACTIONS(2742), 1, + anon_sym_LBRACE, + ACTIONS(2744), 1, + anon_sym_if, + STATE(229), 1, + sym_if_expression, + [74778] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2746), 1, anon_sym_LBRACE, - ACTIONS(2107), 1, - anon_sym_EQ, - STATE(480), 1, - sym_block, - [62263] = 4, - ACTIONS(366), 1, + ACTIONS(2748), 1, + anon_sym_if, + STATE(52), 1, + sym_if_expression, + [74791] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2045), 1, + ACTIONS(2750), 1, sym_identifier, - STATE(1071), 1, - sym_field_declaration, - STATE(1436), 1, - sym_field_declarations, - [62276] = 4, - ACTIONS(366), 1, + ACTIONS(2752), 1, + anon_sym_EQ_GT, + STATE(1396), 1, + aux_sym_handler_params_repeat1, + [74804] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2715), 1, anon_sym_LBRACE, - ACTIONS(2109), 1, + ACTIONS(2754), 1, + anon_sym_SEMI, + STATE(694), 1, + sym_namespace_body, + [74817] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2179), 1, + anon_sym_LBRACE, + ACTIONS(2756), 1, anon_sym_EQ, - STATE(486), 1, + STATE(715), 1, sym_block, - [62289] = 4, - ACTIONS(366), 1, + [74830] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2111), 1, - anon_sym_RPAREN, - ACTIONS(2113), 1, - anon_sym_COMMA, - STATE(1108), 1, - aux_sym_pattern_repeat1, - [62302] = 4, - ACTIONS(366), 1, + ACTIONS(2647), 1, + anon_sym_LBRACE, + ACTIONS(2758), 1, + anon_sym_SEMI, + STATE(626), 1, + sym_namespace_body, + [74843] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2092), 1, + ACTIONS(2269), 1, sym_identifier, - STATE(1075), 1, - sym_effect_ref, - STATE(1268), 1, - sym_effect_list, - [62315] = 4, - ACTIONS(366), 1, + STATE(1241), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [74854] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2116), 1, + ACTIONS(2760), 1, anon_sym_COMMA, - ACTIONS(2119), 1, + ACTIONS(2763), 1, anon_sym_RBRACK, - STATE(1110), 1, + STATE(1393), 1, aux_sym_effect_list_repeat1, - [62328] = 4, - ACTIONS(366), 1, + [74867] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2765), 1, + anon_sym_RBRACE, + ACTIONS(2767), 1, + anon_sym_COMMA, + STATE(1394), 1, + aux_sym_field_assignments_repeat1, + [74880] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(2121), 1, + ACTIONS(2770), 1, anon_sym_EQ, - STATE(480), 1, + STATE(678), 1, sym_block, - [62341] = 4, - ACTIONS(366), 1, + [74893] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2772), 1, + sym_identifier, + ACTIONS(2775), 1, + anon_sym_EQ_GT, + STATE(1396), 1, + aux_sym_handler_params_repeat1, + [74906] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2777), 1, + anon_sym_COMMA, + ACTIONS(2780), 1, + anon_sym_GT, + STATE(1397), 1, + aux_sym_type_parameter_list_repeat1, + [74919] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2123), 1, + ACTIONS(2782), 1, anon_sym_COMMA, - ACTIONS(2125), 1, + ACTIONS(2785), 1, anon_sym_RBRACK, - STATE(1124), 1, + STATE(1398), 1, aux_sym_list_pattern_repeat1, - [62354] = 4, - ACTIONS(366), 1, + [74932] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2787), 1, + anon_sym_COMMA, + ACTIONS(2790), 1, + anon_sym_RPAREN, + STATE(1399), 1, + aux_sym_named_argument_list_repeat1, + [74945] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2127), 1, + ACTIONS(2792), 1, anon_sym_EQ, - STATE(479), 1, + STATE(562), 1, sym_block, - [62367] = 4, - ACTIONS(366), 1, + [74958] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(2129), 1, + ACTIONS(2794), 1, anon_sym_EQ, - STATE(577), 1, + STATE(684), 1, sym_block, - [62380] = 2, - ACTIONS(366), 1, + [74971] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2131), 3, - anon_sym_RPAREN, + ACTIONS(2569), 1, + sym_identifier, + STATE(1375), 1, + sym_field_assignment, + STATE(1637), 1, + sym_field_assignments, + [74984] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2269), 1, + sym_identifier, + STATE(1276), 2, + sym_handler_arm, + aux_sym_handler_expression_repeat1, + [74995] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2567), 1, + anon_sym_COLON, + ACTIONS(2796), 1, + anon_sym_LBRACE, + STATE(1766), 1, + sym_signature_ascription, + [75008] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2798), 1, anon_sym_COMMA, - anon_sym_PIPE, - [62389] = 2, - ACTIONS(366), 1, + ACTIONS(2800), 1, + anon_sym_RBRACK, + STATE(1398), 1, + aux_sym_list_pattern_repeat1, + [75021] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1921), 3, - anon_sym_RPAREN, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2802), 1, + anon_sym_DOT, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + [75034] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2651), 1, anon_sym_COMMA, - anon_sym_PIPE, - [62398] = 4, - ACTIONS(366), 1, + ACTIONS(2804), 1, + anon_sym_RPAREN, + STATE(1344), 1, + aux_sym_pattern_repeat1, + [75047] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2133), 1, + ACTIONS(2569), 1, sym_identifier, - ACTIONS(2135), 1, - anon_sym_EQ_GT, - STATE(1051), 1, - aux_sym_handler_params_repeat1, - [62411] = 4, - ACTIONS(366), 1, + STATE(1375), 1, + sym_field_assignment, + STATE(1536), 1, + sym_field_assignments, + [75060] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(2137), 1, + ACTIONS(2806), 1, anon_sym_EQ, - STATE(482), 1, + STATE(688), 1, sym_block, - [62424] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2139), 1, - anon_sym_LBRACE, - ACTIONS(2141), 1, - anon_sym_if, - STATE(335), 1, - sym_if_expression, - [62437] = 4, - ACTIONS(366), 1, + [75073] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(2143), 1, + ACTIONS(2808), 1, anon_sym_EQ, - STATE(515), 1, + STATE(690), 1, sym_block, - [62450] = 4, - ACTIONS(366), 1, + [75086] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1480), 1, + anon_sym_COLON_COLON, + ACTIONS(2810), 1, + anon_sym_DOT, + STATE(716), 1, + aux_sym_qualified_path_repeat1, + [75099] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2812), 1, + anon_sym_COMMA, + ACTIONS(2814), 1, + anon_sym_RBRACK, + STATE(1405), 1, + aux_sym_list_pattern_repeat1, + [75112] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(2157), 1, anon_sym_LBRACE, - ACTIONS(2145), 1, + ACTIONS(2816), 1, anon_sym_EQ, - STATE(542), 1, + STATE(573), 1, sym_block, - [62463] = 4, - ACTIONS(366), 1, + [75125] = 4, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2674), 1, + sym_identifier, + STATE(1279), 1, + sym_field_declaration, + STATE(1583), 1, + sym_field_declarations, + [75138] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2179), 1, anon_sym_LBRACE, - ACTIONS(2147), 1, + ACTIONS(2818), 1, anon_sym_EQ, - STATE(491), 1, + STATE(692), 1, sym_block, - [62476] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2025), 1, - anon_sym_COMMA, - ACTIONS(2149), 1, - anon_sym_RPAREN, - STATE(1136), 1, - aux_sym_extern_parameter_list_repeat1, - [62489] = 4, - ACTIONS(366), 1, + [75151] = 4, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2151), 1, - anon_sym_COMMA, - ACTIONS(2154), 1, - anon_sym_RBRACK, - STATE(1124), 1, - aux_sym_list_pattern_repeat1, - [62502] = 3, - ACTIONS(366), 1, + ACTIONS(2674), 1, + sym_identifier, + STATE(1279), 1, + sym_field_declaration, + STATE(1634), 1, + sym_field_declarations, + [75164] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2027), 1, + ACTIONS(2820), 1, sym_identifier, - STATE(1037), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [62513] = 4, - ACTIONS(366), 1, + STATE(1768), 1, + sym_qualified_path, + [75174] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2156), 1, + ACTIONS(2790), 2, anon_sym_COMMA, - ACTIONS(2159), 1, + anon_sym_RPAREN, + [75182] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2822), 2, anon_sym_RBRACE, - STATE(1126), 1, - aux_sym_field_assignments_repeat1, - [62526] = 4, - ACTIONS(366), 1, + anon_sym_COMMA, + [75190] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2824), 1, anon_sym_LBRACE, - ACTIONS(2161), 1, - anon_sym_EQ, - STATE(531), 1, - sym_block, - [62539] = 4, - ACTIONS(366), 1, + ACTIONS(2826), 1, + anon_sym_LT, + [75200] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, - anon_sym_RPAREN, - ACTIONS(2165), 1, + ACTIONS(2733), 2, + anon_sym_RBRACE, anon_sym_COMMA, - STATE(1128), 1, - aux_sym_named_argument_list_repeat1, - [62552] = 4, - ACTIONS(366), 1, + [75208] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, + ACTIONS(998), 2, anon_sym_LBRACE, - ACTIONS(2168), 1, - anon_sym_EQ, - STATE(563), 1, - sym_block, - [62565] = 4, - ACTIONS(366), 1, + anon_sym_SEMI, + [75216] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2170), 1, - anon_sym_COMMA, - ACTIONS(2172), 1, - anon_sym_RBRACK, - STATE(1112), 1, - aux_sym_list_pattern_repeat1, - [62578] = 4, - ACTIONS(366), 1, + ACTIONS(2828), 1, + anon_sym_DASH_GT, + ACTIONS(2830), 1, + anon_sym_EQ_GT, + [75226] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, - anon_sym_LBRACE, - ACTIONS(2174), 1, - anon_sym_EQ, - STATE(522), 1, - sym_block, - [62591] = 4, - ACTIONS(366), 1, + ACTIONS(2832), 1, + sym_identifier, + STATE(1445), 1, + sym_symbol_path, + [75236] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2832), 1, + sym_identifier, + STATE(1354), 1, + sym_symbol_path, + [75246] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2834), 1, anon_sym_LBRACE, - ACTIONS(2176), 1, + ACTIONS(2836), 1, + anon_sym_LT, + [75256] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2838), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [75264] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2840), 1, + anon_sym_COLON, + ACTIONS(2842), 1, anon_sym_EQ, - STATE(509), 1, - sym_block, - [62604] = 4, - ACTIONS(366), 1, + [75274] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, - anon_sym_LBRACE, - ACTIONS(2178), 1, + ACTIONS(2844), 1, + anon_sym_COLON, + ACTIONS(2846), 1, anon_sym_EQ, - STATE(510), 1, - sym_block, - [62617] = 4, - ACTIONS(366), 1, + [75284] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2180), 1, - anon_sym_COMMA, - ACTIONS(2183), 1, - anon_sym_RBRACE, - STATE(1134), 1, - aux_sym_field_pattern_repeat1, - [62630] = 4, - ACTIONS(366), 1, + ACTIONS(2848), 1, + sym_float, + ACTIONS(2850), 1, + sym_integer, + [75294] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2037), 1, + ACTIONS(2553), 2, anon_sym_COMMA, - ACTIONS(2185), 1, - anon_sym_RBRACE, - STATE(1126), 1, - aux_sym_field_assignments_repeat1, - [62643] = 4, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2187), 1, anon_sym_RPAREN, - ACTIONS(2189), 1, - anon_sym_COMMA, - STATE(1136), 1, - aux_sym_extern_parameter_list_repeat1, - [62656] = 4, - ACTIONS(366), 1, + [75302] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2852), 1, + anon_sym_DASH_GT, + ACTIONS(2854), 1, + anon_sym_EQ_GT, + [75312] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2115), 2, anon_sym_LBRACE, - ACTIONS(2192), 1, anon_sym_EQ, - STATE(512), 1, - sym_block, - [62669] = 4, - ACTIONS(366), 1, + [75320] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2194), 1, - anon_sym_COMMA, - ACTIONS(2197), 1, - anon_sym_RBRACE, - STATE(1138), 1, - aux_sym_map_literal_repeat1, - [62682] = 4, - ACTIONS(366), 1, + ACTIONS(2856), 1, + anon_sym_COLON, + ACTIONS(2858), 1, + anon_sym_EQ, + [75330] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(2199), 1, + ACTIONS(2338), 1, + sym_identifier, + STATE(1317), 1, + sym_parameter, + [75340] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2860), 1, + anon_sym_COLON, + ACTIONS(2862), 1, anon_sym_EQ, - STATE(573), 1, - sym_block, - [62695] = 4, - ACTIONS(366), 1, + [75350] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1625), 1, - anon_sym_LBRACE, - ACTIONS(2201), 1, + ACTIONS(2864), 1, anon_sym_EQ, - STATE(553), 1, - sym_block, - [62708] = 4, - ACTIONS(366), 1, + ACTIONS(2866), 1, + anon_sym_LT, + [75360] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2047), 1, - anon_sym_COMMA, - ACTIONS(2203), 1, - anon_sym_RBRACK, - STATE(1110), 1, - aux_sym_effect_list_repeat1, - [62721] = 3, - ACTIONS(366), 1, + ACTIONS(2868), 1, + anon_sym_DASH_GT, + ACTIONS(2870), 1, + anon_sym_EQ_GT, + [75370] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2027), 1, + ACTIONS(2872), 1, sym_identifier, - STATE(971), 2, - sym_handler_arm, - aux_sym_handler_expression_repeat1, - [62732] = 4, - ACTIONS(366), 1, + STATE(1403), 1, + sym_qualified_path, + [75380] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1314), 1, + ACTIONS(2582), 2, + anon_sym_RBRACE, anon_sym_COMMA, - ACTIONS(2205), 1, - anon_sym_RBRACK, - STATE(995), 1, - aux_sym_argument_list_repeat1, - [62745] = 4, - ACTIONS(366), 1, + [75388] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1639), 1, + ACTIONS(2874), 1, anon_sym_LBRACE, - ACTIONS(2207), 1, - anon_sym_EQ, - STATE(515), 1, - sym_block, - [62758] = 4, - ACTIONS(366), 1, + ACTIONS(2876), 1, + anon_sym_STAR, + [75398] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, - anon_sym_LBRACE, - ACTIONS(2209), 1, - anon_sym_EQ, - STATE(512), 1, - sym_block, - [62771] = 4, - ACTIONS(366), 1, + ACTIONS(2878), 2, + anon_sym_COMMA, + anon_sym_GT, + [75406] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2880), 1, + anon_sym_DASH_GT, + ACTIONS(2882), 1, + anon_sym_EQ_GT, + [75416] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1633), 1, + ACTIONS(2884), 1, anon_sym_LBRACE, - ACTIONS(2211), 1, - anon_sym_EQ, - STATE(528), 1, - sym_block, - [62784] = 4, - ACTIONS(366), 1, + ACTIONS(2886), 1, + anon_sym_STAR, + [75426] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2213), 1, + ACTIONS(2107), 1, anon_sym_LBRACE, - ACTIONS(2215), 1, - anon_sym_if, - STATE(644), 1, - sym_if_expression, - [62797] = 4, - ACTIONS(366), 1, + ACTIONS(2888), 1, + anon_sym_PLUS, + [75436] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2098), 1, - anon_sym_COMMA, - ACTIONS(2217), 1, - anon_sym_GT, - STATE(1091), 1, - aux_sym_type_parameter_list_repeat1, - [62810] = 2, - ACTIONS(366), 1, + ACTIONS(2890), 1, + sym_identifier, + STATE(1055), 1, + sym_symbol_path, + [75446] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2892), 1, + anon_sym_LT, + ACTIONS(2894), 1, + anon_sym_LPAREN, + [75456] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2077), 2, - anon_sym_GT, - anon_sym_COMMA, - [62818] = 3, - ACTIONS(366), 1, + ACTIONS(2896), 1, + sym_identifier, + STATE(1737), 1, + sym_field_pattern, + [75466] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2219), 1, + ACTIONS(2898), 1, anon_sym_COLON, - ACTIONS(2221), 1, + ACTIONS(2900), 1, anon_sym_EQ, - [62828] = 3, - ACTIONS(366), 1, + [75476] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1743), 1, - sym_identifier, - STATE(476), 1, - sym_variant, - [62838] = 3, - ACTIONS(366), 1, + ACTIONS(2902), 1, + anon_sym_EQ, + ACTIONS(2904), 1, + anon_sym_LT, + [75486] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2223), 1, + ACTIONS(2906), 1, anon_sym_DASH_GT, - ACTIONS(2225), 1, + ACTIONS(2908), 1, anon_sym_EQ_GT, - [62848] = 2, - ACTIONS(366), 1, + [75496] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2227), 2, - anon_sym_RBRACE, - sym_identifier, - [62856] = 3, - ACTIONS(366), 1, + ACTIONS(2910), 1, + anon_sym_DASH_GT, + ACTIONS(2912), 1, + anon_sym_EQ_GT, + [75506] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2229), 1, - anon_sym_COLON, - ACTIONS(2231), 1, - anon_sym_EQ, - [62866] = 3, - ACTIONS(366), 1, + ACTIONS(2914), 1, + sym_identifier, + STATE(1418), 1, + sym_named_argument, + [75516] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2233), 1, + ACTIONS(2916), 1, anon_sym_DASH_GT, - ACTIONS(2235), 1, + ACTIONS(2918), 1, anon_sym_EQ_GT, - [62876] = 3, - ACTIONS(366), 1, + [75526] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2237), 1, + ACTIONS(2920), 1, anon_sym_DASH_GT, - ACTIONS(2239), 1, + ACTIONS(2922), 1, anon_sym_EQ_GT, - [62886] = 3, - ACTIONS(366), 1, + [75536] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2241), 1, - anon_sym_COLON, - ACTIONS(2243), 1, + ACTIONS(2924), 1, anon_sym_EQ, - [62896] = 2, - ACTIONS(366), 1, + ACTIONS(2926), 1, + anon_sym_LT, + [75546] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2245), 2, - anon_sym_EQ, + ACTIONS(2928), 1, anon_sym_LBRACE, - [62904] = 3, - ACTIONS(366), 1, + ACTIONS(2930), 1, + anon_sym_LT, + [75556] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2247), 1, - anon_sym_DASH_GT, - ACTIONS(2249), 1, - anon_sym_EQ_GT, - [62914] = 3, - ACTIONS(366), 1, + ACTIONS(2832), 1, + sym_identifier, + STATE(1404), 1, + sym_symbol_path, + [75566] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2045), 1, + ACTIONS(2932), 1, sym_identifier, - STATE(1187), 1, - sym_field_declaration, - [62924] = 3, - ACTIONS(366), 1, + ACTIONS(2934), 1, + anon_sym_LPAREN, + [75576] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2251), 1, + ACTIONS(2936), 1, + anon_sym_COLON, + STATE(1113), 1, + sym_signature_ascription, + [75586] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2896), 1, sym_identifier, - STATE(1232), 1, + STATE(1784), 1, sym_field_pattern, - [62934] = 3, - ACTIONS(366), 1, + [75596] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2253), 1, - anon_sym_COLON, - ACTIONS(2255), 1, - anon_sym_EQ, - [62944] = 3, - ACTIONS(366), 1, + ACTIONS(2664), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [75604] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2257), 1, - anon_sym_EQ, - ACTIONS(2259), 1, + ACTIONS(2938), 1, + anon_sym_LBRACE, + ACTIONS(2940), 1, anon_sym_LT, - [62954] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2261), 1, - anon_sym_DASH_GT, - ACTIONS(2263), 1, - anon_sym_EQ_GT, - [62964] = 3, - ACTIONS(366), 1, + [75614] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1970), 1, + ACTIONS(2832), 1, sym_identifier, - STATE(1201), 1, - sym_field_assignment, - [62974] = 3, - ACTIONS(366), 1, + STATE(1460), 1, + sym_symbol_path, + [75624] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2265), 1, - anon_sym_COLON, - ACTIONS(2267), 1, - anon_sym_EQ, - [62984] = 3, - ACTIONS(366), 1, + ACTIONS(2896), 1, + sym_identifier, + STATE(1738), 1, + sym_field_pattern, + [75634] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2269), 1, + ACTIONS(2942), 1, anon_sym_LT, - ACTIONS(2271), 1, + ACTIONS(2944), 1, anon_sym_LPAREN, - [62994] = 3, - ACTIONS(366), 1, + [75644] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2251), 1, + ACTIONS(2832), 1, sym_identifier, - STATE(1316), 1, - sym_field_pattern, - [63004] = 2, - ACTIONS(366), 1, + STATE(1298), 1, + sym_symbol_path, + [75654] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2273), 2, - anon_sym_RPAREN, + ACTIONS(2946), 2, anon_sym_COMMA, - [63012] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2275), 1, - anon_sym_DASH_GT, - ACTIONS(2277), 1, - anon_sym_EQ_GT, - [63022] = 3, - ACTIONS(366), 1, + anon_sym_GT, + [75662] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2279), 1, - anon_sym_DASH_GT, - ACTIONS(2281), 1, - anon_sym_EQ_GT, - [63032] = 2, - ACTIONS(366), 1, + ACTIONS(2674), 1, + sym_identifier, + STATE(1440), 1, + sym_field_declaration, + [75672] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2283), 2, + ACTIONS(2577), 2, + anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_RBRACK, - [63040] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2285), 1, - anon_sym_EQ, - ACTIONS(2287), 1, - anon_sym_LT, - [63050] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2251), 1, - sym_identifier, - STATE(1441), 1, - sym_field_pattern, - [63060] = 3, - ACTIONS(366), 1, + [75680] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2289), 1, + ACTIONS(2948), 1, anon_sym_EQ, - ACTIONS(2291), 1, + ACTIONS(2950), 1, anon_sym_LT, - [63070] = 3, - ACTIONS(366), 1, + [75690] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2293), 1, - anon_sym_LT, - ACTIONS(2295), 1, + ACTIONS(2121), 2, anon_sym_LBRACE, - [63080] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2251), 1, - sym_identifier, - STATE(1425), 1, - sym_field_pattern, - [63090] = 3, - ACTIONS(366), 1, + anon_sym_EQ, + [75698] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1755), 1, + ACTIONS(2379), 1, sym_identifier, - STATE(497), 1, - sym_variant, - [63100] = 3, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2297), 1, - sym_float, - ACTIONS(2299), 1, - sym_integer, - [63110] = 3, - ACTIONS(366), 1, + STATE(1421), 1, + sym_import_member, + [75708] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2301), 1, - anon_sym_LT, - ACTIONS(2303), 1, + ACTIONS(2019), 1, anon_sym_LBRACE, - [63120] = 3, - ACTIONS(366), 1, + ACTIONS(2025), 1, + anon_sym_LPAREN, + [75718] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2305), 1, + ACTIONS(2952), 1, anon_sym_LT, - ACTIONS(2307), 1, + ACTIONS(2954), 1, anon_sym_LPAREN, - [63130] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2187), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - [63138] = 3, - ACTIONS(366), 1, + [75728] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2309), 1, + ACTIONS(2956), 1, + anon_sym_COLON, + ACTIONS(2958), 1, anon_sym_EQ, - ACTIONS(2311), 1, - anon_sym_LT, - [63148] = 3, - ACTIONS(366), 1, + [75738] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2313), 1, + ACTIONS(2960), 2, + anon_sym_RBRACE, sym_identifier, - ACTIONS(2315), 1, - anon_sym_LPAREN, - [63158] = 3, - ACTIONS(366), 1, + [75746] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2317), 1, + ACTIONS(2832), 1, sym_identifier, - STATE(1196), 1, - sym_named_argument, - [63168] = 3, - ACTIONS(366), 1, + STATE(1369), 1, + sym_symbol_path, + [75756] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2319), 1, - anon_sym_COLON, - ACTIONS(2321), 1, - anon_sym_EQ, - [63178] = 2, - ACTIONS(366), 1, + ACTIONS(2765), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [75764] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2105), 2, + ACTIONS(2763), 2, anon_sym_COMMA, - anon_sym_RBRACE, - [63186] = 2, - ACTIONS(366), 1, + anon_sym_RBRACK, + [75772] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2119), 2, + ACTIONS(2962), 2, anon_sym_COMMA, anon_sym_RBRACK, - [63194] = 2, - ACTIONS(366), 1, + [75780] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2323), 2, - anon_sym_EQ, - anon_sym_LBRACE, - [63202] = 3, - ACTIONS(366), 1, + ACTIONS(2964), 1, + sym_identifier, + ACTIONS(2966), 1, + anon_sym_LPAREN, + [75790] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2092), 1, + ACTIONS(2968), 1, sym_identifier, - STATE(1188), 1, - sym_effect_ref, - [63212] = 3, - ACTIONS(366), 1, + STATE(1339), 1, + sym_qualified_path, + [75800] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1833), 1, + ACTIONS(2832), 1, sym_identifier, - STATE(1182), 1, - sym_extern_parameter, - [63222] = 3, - ACTIONS(366), 1, + STATE(1341), 1, + sym_symbol_path, + [75810] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2325), 1, - anon_sym_DASH_GT, - ACTIONS(2327), 1, - anon_sym_EQ_GT, - [63232] = 2, - ACTIONS(366), 1, + ACTIONS(2970), 1, + anon_sym_LT, + ACTIONS(2972), 1, + anon_sym_LPAREN, + [75820] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2329), 2, - anon_sym_GT, - anon_sym_COMMA, - [63240] = 2, - ACTIONS(366), 1, + ACTIONS(2832), 1, + sym_identifier, + STATE(1349), 1, + sym_symbol_path, + [75830] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2331), 2, - anon_sym_GT, - anon_sym_COMMA, - [63248] = 3, - ACTIONS(366), 1, + ACTIONS(2832), 1, + sym_identifier, + STATE(1351), 1, + sym_symbol_path, + [75840] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2974), 1, + anon_sym_LT, + ACTIONS(2976), 1, + anon_sym_LPAREN, + [75850] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1791), 1, + ACTIONS(2832), 1, sym_identifier, - STATE(1116), 1, - sym_parameter, - [63258] = 2, - ACTIONS(366), 1, + STATE(1358), 1, + sym_symbol_path, + [75860] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 2, - anon_sym_RPAREN, + ACTIONS(2780), 2, anon_sym_COMMA, - [63266] = 2, - ACTIONS(366), 1, + anon_sym_GT, + [75868] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2111), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - [63274] = 3, - ACTIONS(366), 1, + ACTIONS(2569), 1, + sym_identifier, + STATE(1479), 1, + sym_field_assignment, + [75878] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2333), 1, + ACTIONS(2978), 1, sym_identifier, - ACTIONS(2335), 1, - anon_sym_LPAREN, - [63284] = 2, - ACTIONS(366), 1, + STATE(1626), 1, + sym_qualified_path, + [75888] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2183), 2, - anon_sym_COMMA, - anon_sym_RBRACE, - [63292] = 3, - ACTIONS(366), 1, + ACTIONS(2980), 1, + sym_identifier, + STATE(1371), 1, + sym_qualified_path, + [75898] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2337), 1, + ACTIONS(2982), 1, anon_sym_LT, - ACTIONS(2339), 1, + ACTIONS(2984), 1, anon_sym_LPAREN, - [63302] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2159), 2, - anon_sym_COMMA, - anon_sym_RBRACE, - [63310] = 3, - ACTIONS(366), 1, + [75908] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2341), 1, + ACTIONS(2986), 1, anon_sym_LT, - ACTIONS(2343), 1, + ACTIONS(2988), 1, anon_sym_LPAREN, - [63320] = 3, - ACTIONS(366), 1, + [75918] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2345), 1, - anon_sym_LT, - ACTIONS(2347), 1, - anon_sym_LPAREN, - [63330] = 2, - ACTIONS(366), 1, + ACTIONS(2990), 1, + sym_identifier, + STATE(1392), 1, + sym_qualified_path, + [75928] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2197), 2, - anon_sym_COMMA, + ACTIONS(2700), 2, anon_sym_RBRACE, - [63338] = 3, - ACTIONS(366), 1, + anon_sym_COMMA, + [75936] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2349), 1, + ACTIONS(2992), 1, + anon_sym_EQ, + ACTIONS(2994), 1, anon_sym_LT, - ACTIONS(2351), 1, - anon_sym_LPAREN, - [63348] = 3, - ACTIONS(366), 1, + [75946] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2996), 1, + sym_identifier, + STATE(1754), 1, + sym_qualified_path, + [75956] = 3, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2896), 1, + sym_identifier, + STATE(1761), 1, + sym_field_pattern, + [75966] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2353), 1, + ACTIONS(2998), 1, + anon_sym_EQ, + ACTIONS(3000), 1, anon_sym_LT, - ACTIONS(2355), 1, - anon_sym_LBRACE, - [63358] = 3, - ACTIONS(366), 1, + [75976] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2251), 1, + ACTIONS(2896), 1, sym_identifier, - STATE(1414), 1, + STATE(1771), 1, sym_field_pattern, - [63368] = 3, - ACTIONS(366), 1, + [75986] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2251), 1, + ACTIONS(2896), 1, sym_identifier, - STATE(1357), 1, + STATE(1778), 1, sym_field_pattern, - [63378] = 3, - ACTIONS(366), 1, + [75996] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2251), 1, + ACTIONS(2896), 1, sym_identifier, - STATE(1422), 1, + STATE(1774), 1, sym_field_pattern, - [63388] = 3, - ACTIONS(366), 1, + [76006] = 3, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2357), 1, - anon_sym_LT, - ACTIONS(2359), 1, - anon_sym_LBRACE, - [63398] = 2, - ACTIONS(366), 1, + ACTIONS(2344), 1, + sym_identifier, + STATE(1431), 1, + sym_extern_parameter, + [76016] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2361), 1, - anon_sym_EQ, - [63405] = 2, - ACTIONS(366), 1, + ACTIONS(3002), 1, + anon_sym_RBRACK, + [76023] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2363), 1, - anon_sym_EQ_GT, - [63412] = 2, - ACTIONS(366), 1, + ACTIONS(3004), 1, + anon_sym_GT, + [76030] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2365), 1, - anon_sym_fn, - [63419] = 2, - ACTIONS(366), 1, + ACTIONS(3006), 1, + anon_sym_QMARK, + [76037] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2367), 1, - anon_sym_LPAREN, - [63426] = 2, - ACTIONS(366), 1, + ACTIONS(3008), 1, + sym_identifier, + [76044] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3010), 1, + anon_sym_RPAREN, + [76051] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2369), 1, + ACTIONS(3012), 1, sym_identifier, - [63433] = 2, - ACTIONS(366), 1, + [76058] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2371), 1, - anon_sym_DASH_GT, - [63440] = 2, - ACTIONS(366), 1, + ACTIONS(1676), 1, + anon_sym_RPAREN, + [76065] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2373), 1, + ACTIONS(3014), 1, + anon_sym_LPAREN, + [76072] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3016), 1, anon_sym_RBRACE, - [63447] = 2, - ACTIONS(366), 1, + [76079] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2375), 1, - sym_identifier, - [63454] = 2, - ACTIONS(366), 1, + ACTIONS(3018), 1, + anon_sym_GT, + [76086] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2377), 1, + ACTIONS(3020), 1, + anon_sym_RPAREN, + [76093] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3022), 1, sym_identifier, - [63461] = 2, - ACTIONS(366), 1, + [76100] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2379), 1, - anon_sym_EQ_GT, - [63468] = 2, - ACTIONS(366), 1, + ACTIONS(3024), 1, + anon_sym_COLON, + [76107] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2381), 1, - anon_sym_LPAREN, - [63475] = 2, - ACTIONS(366), 1, + ACTIONS(3026), 1, + anon_sym_fn, + [76114] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2383), 1, - anon_sym_LPAREN, - [63482] = 2, - ACTIONS(366), 1, + ACTIONS(3028), 1, + anon_sym_GT, + [76121] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2385), 1, - sym_identifier, - [63489] = 2, - ACTIONS(366), 1, + ACTIONS(3030), 1, + anon_sym_RBRACE, + [76128] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2387), 1, + ACTIONS(3032), 1, + anon_sym_LPAREN, + [76135] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3034), 1, anon_sym_RPAREN, - [63496] = 2, - ACTIONS(366), 1, + [76142] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2389), 1, + ACTIONS(3036), 1, anon_sym_RBRACE, - [63503] = 2, - ACTIONS(366), 1, + [76149] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2391), 1, + ACTIONS(3038), 1, sym_identifier, - [63510] = 2, - ACTIONS(366), 1, + [76156] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2393), 1, - anon_sym_EQ, - [63517] = 2, - ACTIONS(366), 1, + ACTIONS(3040), 1, + anon_sym_LPAREN, + [76163] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2395), 1, - anon_sym_EQ, - [63524] = 2, - ACTIONS(366), 1, + ACTIONS(3042), 1, + anon_sym_RBRACE, + [76170] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2397), 1, + ACTIONS(3044), 1, + anon_sym_EQ_GT, + [76177] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3046), 1, sym_identifier, - [63531] = 2, - ACTIONS(366), 1, + [76184] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2399), 1, - anon_sym_LPAREN, - [63538] = 2, - ACTIONS(366), 1, + ACTIONS(3048), 1, + anon_sym_COLON, + [76191] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2401), 1, + ACTIONS(3050), 1, + anon_sym_GT, + [76198] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2854), 1, + anon_sym_EQ_GT, + [76205] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2908), 1, anon_sym_EQ_GT, - [63545] = 2, - ACTIONS(366), 1, + [76212] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3052), 1, + anon_sym_LPAREN, + [76219] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3054), 1, + anon_sym_RPAREN, + [76226] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1997), 1, + ACTIONS(3056), 1, anon_sym_RBRACE, - [63552] = 2, - ACTIONS(366), 1, + [76233] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2403), 1, + ACTIONS(3058), 1, anon_sym_DASH_GT, - [63559] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2405), 1, - anon_sym_LBRACE, - [63566] = 2, - ACTIONS(366), 1, + [76240] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2277), 1, + ACTIONS(3060), 1, anon_sym_EQ_GT, - [63573] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2407), 1, - anon_sym_GT, - [63580] = 2, - ACTIONS(366), 1, + [76247] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2409), 1, - anon_sym_RBRACK, - [63587] = 2, - ACTIONS(366), 1, + ACTIONS(3062), 1, + anon_sym_DASH_GT, + [76254] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2411), 1, - anon_sym_EQ, - [63594] = 2, - ACTIONS(366), 1, + ACTIONS(3064), 1, + anon_sym_EQ_GT, + [76261] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2413), 1, - anon_sym_RBRACE, - [63601] = 2, - ACTIONS(366), 1, + ACTIONS(3066), 1, + anon_sym_DASH_GT, + [76268] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2415), 1, + ACTIONS(3068), 1, anon_sym_EQ_GT, - [63608] = 2, - ACTIONS(366), 1, + [76275] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2417), 1, - anon_sym_EQ_GT, - [63615] = 2, - ACTIONS(366), 1, + ACTIONS(3070), 1, + anon_sym_RBRACK, + [76282] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2419), 1, + ACTIONS(3072), 1, sym_identifier, - [63622] = 2, - ACTIONS(366), 1, + [76289] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2421), 1, - anon_sym_RPAREN, - [63629] = 2, - ACTIONS(366), 1, + ACTIONS(3074), 1, + sym_identifier, + [76296] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2423), 1, - anon_sym_GT, - [63636] = 2, - ACTIONS(366), 1, + ACTIONS(3076), 1, + sym_identifier, + [76303] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2425), 1, + ACTIONS(3078), 1, + anon_sym_EQ, + [76310] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3080), 1, sym_identifier, - [63643] = 2, - ACTIONS(366), 1, + [76317] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2427), 1, + ACTIONS(3082), 1, sym_identifier, - [63650] = 2, - ACTIONS(366), 1, + [76324] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2429), 1, - anon_sym_EQ_GT, - [63657] = 2, - ACTIONS(366), 1, + ACTIONS(3084), 1, + anon_sym_COLON, + [76331] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2431), 1, + ACTIONS(3086), 1, anon_sym_LPAREN, - [63664] = 2, - ACTIONS(366), 1, + [76338] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2433), 1, + ACTIONS(3088), 1, sym_identifier, - [63671] = 2, - ACTIONS(366), 1, + [76345] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2315), 1, + ACTIONS(2934), 1, anon_sym_LPAREN, - [63678] = 2, - ACTIONS(366), 1, + [76352] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2435), 1, + ACTIONS(2922), 1, anon_sym_EQ_GT, - [63685] = 2, - ACTIONS(366), 1, + [76359] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2437), 1, + ACTIONS(3090), 1, anon_sym_PIPE, - [63692] = 2, - ACTIONS(366), 1, + [76366] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2439), 1, - anon_sym_EQ, - [63699] = 2, - ACTIONS(366), 1, + ACTIONS(3092), 1, + anon_sym_RBRACE, + [76373] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2441), 1, - anon_sym_COLON, - [63706] = 2, - ACTIONS(366), 1, + ACTIONS(3094), 1, + sym_identifier, + [76380] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2443), 1, + ACTIONS(3096), 1, + anon_sym_RBRACE, + [76387] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3098), 1, anon_sym_RPAREN, - [63713] = 2, - ACTIONS(366), 1, + [76394] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2445), 1, - anon_sym_DASH_GT, - [63720] = 2, - ACTIONS(366), 1, + ACTIONS(3100), 1, + sym_identifier, + [76401] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2447), 1, - anon_sym_RBRACE, - [63727] = 2, - ACTIONS(366), 1, + ACTIONS(3102), 1, + anon_sym_GT, + [76408] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1560), 1, - anon_sym_RPAREN, - [63734] = 2, - ACTIONS(366), 1, + ACTIONS(3104), 1, + anon_sym_LBRACE, + [76415] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2449), 1, + ACTIONS(3106), 1, + sym_identifier, + [76422] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3108), 1, anon_sym_LBRACE, - [63741] = 2, - ACTIONS(366), 1, + [76429] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2451), 1, - anon_sym_EQ_GT, - [63748] = 2, - ACTIONS(366), 1, + ACTIONS(3110), 1, + sym_identifier, + [76436] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3112), 1, + anon_sym_LBRACE, + [76443] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2453), 1, + ACTIONS(3114), 1, anon_sym_DASH_GT, - [63755] = 2, - ACTIONS(366), 1, + [76450] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3116), 1, + anon_sym_RBRACE, + [76457] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3118), 1, + sym_identifier, + [76464] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2455), 1, + ACTIONS(3120), 1, sym_identifier, - [63762] = 2, - ACTIONS(366), 1, + [76471] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2457), 1, + ACTIONS(3122), 1, sym_identifier, - [63769] = 2, - ACTIONS(366), 1, + [76478] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2459), 1, - anon_sym_RPAREN, - [63776] = 2, - ACTIONS(366), 1, + ACTIONS(3124), 1, + sym_identifier, + [76485] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2461), 1, + ACTIONS(3126), 1, anon_sym_RPAREN, - [63783] = 2, - ACTIONS(366), 1, + [76492] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2463), 1, - anon_sym_DASH_GT, - [63790] = 2, - ACTIONS(366), 1, + ACTIONS(3128), 1, + anon_sym_RPAREN, + [76499] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2465), 1, + ACTIONS(3130), 1, anon_sym_LPAREN, - [63797] = 2, - ACTIONS(366), 1, + [76506] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2467), 1, - anon_sym_RBRACK, - [63804] = 2, - ACTIONS(366), 1, + ACTIONS(3132), 1, + anon_sym_RBRACE, + [76513] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2469), 1, + ACTIONS(3134), 1, anon_sym_LBRACE, - [63811] = 2, - ACTIONS(366), 1, + [76520] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2471), 1, - anon_sym_DASH_GT, - [63818] = 2, - ACTIONS(366), 1, + ACTIONS(3136), 1, + anon_sym_COLON, + [76527] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2473), 1, + ACTIONS(3138), 1, + anon_sym_EQ_GT, + [76534] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3140), 1, + anon_sym_RBRACE, + [76541] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3142), 1, + anon_sym_RBRACK, + [76548] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3144), 1, anon_sym_LBRACE, - [63825] = 2, - ACTIONS(366), 1, + [76555] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2475), 1, + ACTIONS(3146), 1, anon_sym_RBRACE, - [63832] = 2, - ACTIONS(366), 1, + [76562] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2477), 1, + ACTIONS(3148), 1, + anon_sym_RPAREN, + [76569] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3150), 1, + anon_sym_extra, + [76576] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3152), 1, + anon_sym_GT, + [76583] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3154), 1, + sym_identifier, + [76590] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3156), 1, + anon_sym_LPAREN, + [76597] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3158), 1, + anon_sym_LBRACE, + [76604] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3160), 1, + sym_identifier, + [76611] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(1989), 1, anon_sym_RPAREN, - [63839] = 2, - ACTIONS(366), 1, + [76618] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3162), 1, + anon_sym_module, + [76625] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2479), 1, + ACTIONS(3164), 1, anon_sym_RPAREN, - [63846] = 2, - ACTIONS(366), 1, + [76632] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2481), 1, - anon_sym_GT, - [63853] = 2, - ACTIONS(366), 1, + ACTIONS(3166), 1, + anon_sym_RBRACE, + [76639] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2483), 1, - anon_sym_RPAREN, - [63860] = 2, - ACTIONS(366), 1, + ACTIONS(3168), 1, + sym_identifier, + [76646] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2485), 1, + ACTIONS(3170), 1, anon_sym_LPAREN, - [63867] = 2, - ACTIONS(366), 1, + [76653] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2487), 1, + ACTIONS(3172), 1, anon_sym_EQ, - [63874] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(1550), 1, - anon_sym_RPAREN, - [63881] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2489), 1, - anon_sym_EQ_GT, - [63888] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2491), 1, - anon_sym_EQ_GT, - [63895] = 2, - ACTIONS(366), 1, + [76660] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2239), 1, - anon_sym_EQ_GT, - [63902] = 2, - ACTIONS(366), 1, + ACTIONS(3174), 1, + anon_sym_LBRACE, + [76667] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2493), 1, + ACTIONS(3176), 1, sym_identifier, - [63909] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2495), 1, - anon_sym_LPAREN, - [63916] = 2, - ACTIONS(366), 1, + [76674] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2497), 1, - anon_sym_RBRACE, - [63923] = 2, - ACTIONS(366), 1, + ACTIONS(3178), 1, + ts_builtin_sym_end, + [76681] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2499), 1, - anon_sym_DOT, - [63930] = 2, - ACTIONS(366), 1, + ACTIONS(3180), 1, + anon_sym_EQ, + [76688] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2501), 1, - anon_sym_RBRACE, - [63937] = 2, - ACTIONS(366), 1, + ACTIONS(3182), 1, + sym_identifier, + [76695] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2503), 1, + ACTIONS(3184), 1, anon_sym_LBRACE, - [63944] = 2, - ACTIONS(366), 1, + [76702] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2505), 1, + ACTIONS(3186), 1, anon_sym_else, - [63951] = 2, - ACTIONS(366), 1, + [76709] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2507), 1, + ACTIONS(3188), 1, anon_sym_RPAREN, - [63958] = 2, - ACTIONS(366), 1, + [76716] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2509), 1, - anon_sym_RBRACE, - [63965] = 2, - ACTIONS(366), 1, + ACTIONS(3190), 1, + anon_sym_GT, + [76723] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2511), 1, + ACTIONS(3192), 1, anon_sym_RPAREN, - [63972] = 2, - ACTIONS(366), 1, + [76730] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2513), 1, + ACTIONS(3194), 1, anon_sym_GT, - [63979] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2515), 1, - anon_sym_EQ_GT, - [63986] = 2, - ACTIONS(366), 1, + [76737] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2517), 1, - anon_sym_EQ_GT, - [63993] = 2, - ACTIONS(366), 1, + ACTIONS(3196), 1, + anon_sym_LBRACE, + [76744] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2519), 1, - anon_sym_RPAREN, - [64000] = 2, - ACTIONS(366), 1, + ACTIONS(3198), 1, + anon_sym_type, + [76751] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2521), 1, + ACTIONS(2117), 1, anon_sym_LBRACE, - [64007] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2523), 1, - anon_sym_RPAREN, - [64014] = 2, - ACTIONS(366), 1, + [76758] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2525), 1, + ACTIONS(3200), 1, anon_sym_GT, - [64021] = 2, - ACTIONS(366), 1, + [76765] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2527), 1, + ACTIONS(3202), 1, sym_identifier, - [64028] = 2, - ACTIONS(366), 1, + [76772] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2529), 1, - anon_sym_RPAREN, - [64035] = 2, - ACTIONS(366), 1, + ACTIONS(3204), 1, + sym_identifier, + [76779] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2531), 1, - anon_sym_QMARK, - [64042] = 2, - ACTIONS(366), 1, + ACTIONS(3206), 1, + sym_identifier, + [76786] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3208), 1, + anon_sym_LBRACE, + [76793] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2533), 1, + ACTIONS(3210), 1, anon_sym_RPAREN, - [64049] = 2, - ACTIONS(366), 1, + [76800] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3212), 1, + anon_sym_extra, + [76807] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3214), 1, + anon_sym_LPAREN, + [76814] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3216), 1, + anon_sym_DASH_GT, + [76821] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3218), 1, + anon_sym_RBRACE, + [76828] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3220), 1, + anon_sym_EQ, + [76835] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1318), 1, + ACTIONS(3222), 1, anon_sym_RPAREN, - [64056] = 2, - ACTIONS(366), 1, + [76842] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2535), 1, - anon_sym_LBRACE, - [64063] = 2, - ACTIONS(366), 1, + ACTIONS(3224), 1, + anon_sym_GT, + [76849] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2537), 1, - sym_identifier, - [64070] = 2, - ACTIONS(366), 1, + ACTIONS(3226), 1, + anon_sym_DASH_GT, + [76856] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2539), 1, + ACTIONS(2707), 1, + anon_sym_DOT, + [76863] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3228), 1, sym_identifier, - [64077] = 2, - ACTIONS(366), 1, + [76870] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2541), 1, - anon_sym_RBRACK, - [64084] = 2, - ACTIONS(366), 1, + ACTIONS(3230), 1, + anon_sym_EQ_GT, + [76877] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2543), 1, - anon_sym_DASH_GT, - [64091] = 2, - ACTIONS(366), 1, + ACTIONS(3232), 1, + anon_sym_EQ, + [76884] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2545), 1, + ACTIONS(3234), 1, anon_sym_LPAREN, - [64098] = 2, - ACTIONS(366), 1, + [76891] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2547), 1, + ACTIONS(3236), 1, sym_identifier, - [64105] = 2, - ACTIONS(366), 1, + [76898] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3238), 1, + anon_sym_RBRACE, + [76905] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2549), 1, + ACTIONS(3240), 1, anon_sym_PIPE, - [64112] = 2, - ACTIONS(366), 1, + [76912] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2551), 1, - anon_sym_DASH_GT, - [64119] = 2, - ACTIONS(366), 1, + ACTIONS(3242), 1, + anon_sym_RBRACE, + [76919] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2553), 1, + ACTIONS(3244), 1, anon_sym_EQ_GT, - [64126] = 2, - ACTIONS(366), 1, + [76926] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2555), 1, - anon_sym_LPAREN, - [64133] = 2, - ACTIONS(366), 1, + ACTIONS(3246), 1, + anon_sym_EQ_GT, + [76933] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2029), 1, + ACTIONS(3248), 1, anon_sym_RBRACE, - [64140] = 2, - ACTIONS(366), 1, - sym_line_comment, - ACTIONS(2557), 1, - anon_sym_RPAREN, - [64147] = 2, - ACTIONS(366), 1, + [76940] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2559), 1, + ACTIONS(3250), 1, anon_sym_GT, - [64154] = 2, - ACTIONS(366), 1, + [76947] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2561), 1, + ACTIONS(3252), 1, + anon_sym_EQ_GT, + [76954] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3254), 1, sym_identifier, - [64161] = 2, - ACTIONS(366), 1, + [76961] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2563), 1, + ACTIONS(3256), 1, + anon_sym_RPAREN, + [76968] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3258), 1, + anon_sym_DASH_GT, + [76975] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3260), 1, sym_identifier, - [64168] = 2, - ACTIONS(366), 1, + [76982] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2565), 1, - anon_sym_RBRACK, - [64175] = 2, - ACTIONS(366), 1, + ACTIONS(3262), 1, + sym_identifier, + [76989] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2567), 1, + ACTIONS(3264), 1, anon_sym_RPAREN, - [64182] = 2, - ACTIONS(366), 1, + [76996] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, - anon_sym_EQ, - [64189] = 2, - ACTIONS(366), 1, + ACTIONS(3266), 1, + anon_sym_RPAREN, + [77003] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2249), 1, + ACTIONS(3268), 1, anon_sym_EQ_GT, - [64196] = 2, - ACTIONS(366), 1, + [77010] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2571), 1, + ACTIONS(3270), 1, anon_sym_EQ_GT, - [64203] = 2, - ACTIONS(366), 1, + [77017] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2573), 1, - anon_sym_LPAREN, - [64210] = 2, - ACTIONS(366), 1, + ACTIONS(2045), 1, + anon_sym_effect, + [77024] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(2043), 1, + anon_sym_type, + [77031] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2575), 1, + ACTIONS(3272), 1, anon_sym_RPAREN, - [64217] = 2, - ACTIONS(366), 1, + [77038] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2577), 1, - sym_identifier, - [64224] = 2, - ACTIONS(366), 1, + ACTIONS(3274), 1, + anon_sym_GT, + [77045] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2579), 1, + ACTIONS(3276), 1, + anon_sym_RPAREN, + [77052] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3278), 1, anon_sym_LPAREN, - [64231] = 2, - ACTIONS(366), 1, + [77059] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2581), 1, - anon_sym_LBRACE, - [64238] = 2, - ACTIONS(366), 1, + ACTIONS(3280), 1, + sym_identifier, + [77066] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1558), 1, + ACTIONS(2011), 1, anon_sym_RPAREN, - [64245] = 2, - ACTIONS(366), 1, + [77073] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2583), 1, - anon_sym_EQ_GT, - [64252] = 2, - ACTIONS(366), 1, + ACTIONS(3282), 1, + anon_sym_PIPE, + [77080] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2585), 1, - anon_sym_LPAREN, - [64259] = 2, - ACTIONS(366), 1, + ACTIONS(3284), 1, + anon_sym_LBRACE, + [77087] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2587), 1, - sym_identifier, - [64266] = 2, - ACTIONS(366), 1, + ACTIONS(3286), 1, + anon_sym_EQ, + [77094] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2589), 1, - anon_sym_COLON, - [64273] = 2, - ACTIONS(366), 1, + ACTIONS(3288), 1, + anon_sym_RBRACE, + [77101] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2591), 1, + ACTIONS(3290), 1, sym_identifier, - [64280] = 2, - ACTIONS(366), 1, + [77108] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2593), 1, + ACTIONS(3292), 1, anon_sym_GT, - [64287] = 2, - ACTIONS(366), 1, + [77115] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2595), 1, + ACTIONS(3294), 1, anon_sym_else, - [64294] = 2, - ACTIONS(366), 1, + [77122] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(3296), 1, anon_sym_RPAREN, - [64301] = 2, - ACTIONS(366), 1, + [77129] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(1307), 1, + ACTIONS(3298), 1, + anon_sym_GT, + [77136] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3300), 1, anon_sym_COLON, - [64308] = 2, - ACTIONS(366), 1, + [77143] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2599), 1, - anon_sym_RPAREN, - [64315] = 2, - ACTIONS(366), 1, + ACTIONS(3302), 1, + anon_sym_GT, + [77150] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2601), 1, - anon_sym_fn, - [64322] = 2, - ACTIONS(366), 1, + ACTIONS(3304), 1, + anon_sym_RPAREN, + [77157] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2603), 1, - anon_sym_EQ, - [64329] = 2, - ACTIONS(366), 1, + ACTIONS(3306), 1, + anon_sym_RPAREN, + [77164] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2605), 1, - anon_sym_RBRACE, - [64336] = 2, - ACTIONS(366), 1, + ACTIONS(3308), 1, + anon_sym_LBRACE, + [77171] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2607), 1, + ACTIONS(3310), 1, anon_sym_RPAREN, - [64343] = 2, - ACTIONS(366), 1, + [77178] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2609), 1, + ACTIONS(3312), 1, + anon_sym_fn, + [77185] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3314), 1, sym_identifier, - [64350] = 2, - ACTIONS(366), 1, + [77192] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2611), 1, + ACTIONS(3316), 1, + anon_sym_else, + [77199] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3318), 1, + anon_sym_EQ_GT, + [77206] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3320), 1, anon_sym_RPAREN, - [64357] = 2, - ACTIONS(366), 1, + [77213] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2613), 1, - anon_sym_LBRACE, - [64364] = 2, - ACTIONS(366), 1, + ACTIONS(3322), 1, + anon_sym_DASH_GT, + [77220] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2615), 1, + ACTIONS(3324), 1, + sym_identifier, + [77227] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3326), 1, sym_identifier, - [64371] = 2, - ACTIONS(366), 1, + [77234] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2617), 1, + ACTIONS(3328), 1, + anon_sym_EQ_GT, + [77241] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3330), 1, anon_sym_RPAREN, - [64378] = 2, - ACTIONS(366), 1, + [77248] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2619), 1, - anon_sym_RBRACK, - [64385] = 2, - ACTIONS(366), 1, + ACTIONS(3332), 1, + anon_sym_PIPE, + [77255] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2621), 1, - sym_identifier, - [64392] = 2, - ACTIONS(366), 1, + ACTIONS(3334), 1, + anon_sym_DASH_GT, + [77262] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2623), 1, - anon_sym_GT, - [64399] = 2, - ACTIONS(366), 1, + ACTIONS(3336), 1, + anon_sym_EQ, + [77269] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2625), 1, - anon_sym_GT, - [64406] = 2, - ACTIONS(366), 1, + ACTIONS(3338), 1, + anon_sym_RPAREN, + [77276] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2627), 1, + ACTIONS(3340), 1, anon_sym_GT, - [64413] = 2, - ACTIONS(366), 1, + [77283] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2629), 1, - anon_sym_PIPE, - [64420] = 2, - ACTIONS(366), 1, + ACTIONS(3342), 1, + sym_identifier, + [77290] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2631), 1, - anon_sym_RBRACE, - [64427] = 2, - ACTIONS(366), 1, + ACTIONS(3344), 1, + anon_sym_RBRACK, + [77297] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2633), 1, + ACTIONS(2001), 1, anon_sym_RPAREN, - [64434] = 2, - ACTIONS(366), 1, + [77304] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2635), 1, + ACTIONS(3346), 1, anon_sym_RPAREN, - [64441] = 2, - ACTIONS(366), 1, + [77311] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2637), 1, - anon_sym_RBRACE, - [64448] = 2, - ACTIONS(366), 1, + ACTIONS(3348), 1, + anon_sym_RPAREN, + [77318] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2639), 1, + ACTIONS(3350), 1, anon_sym_LPAREN, - [64455] = 2, - ACTIONS(366), 1, + [77325] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2641), 1, - anon_sym_DASH_GT, - [64462] = 2, - ACTIONS(366), 1, + ACTIONS(3352), 1, + anon_sym_EQ, + [77332] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2643), 1, + ACTIONS(3354), 1, sym_identifier, - [64469] = 2, - ACTIONS(366), 1, + [77339] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2645), 1, + ACTIONS(3356), 1, sym_identifier, - [64476] = 2, - ACTIONS(366), 1, + [77346] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2647), 1, - anon_sym_RBRACE, - [64483] = 2, - ACTIONS(366), 1, + ACTIONS(3358), 1, + anon_sym_LPAREN, + [77353] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2649), 1, - sym_identifier, - [64490] = 2, - ACTIONS(366), 1, + ACTIONS(3360), 1, + anon_sym_LPAREN, + [77360] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2651), 1, + ACTIONS(3362), 1, anon_sym_LBRACE, - [64497] = 2, - ACTIONS(366), 1, + [77367] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2653), 1, + ACTIONS(3364), 1, anon_sym_LPAREN, - [64504] = 2, - ACTIONS(366), 1, + [77374] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2655), 1, - sym_identifier, - [64511] = 2, - ACTIONS(366), 1, + ACTIONS(3366), 1, + anon_sym_EQ_GT, + [77381] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2657), 1, + ACTIONS(3368), 1, sym_identifier, - [64518] = 2, - ACTIONS(366), 1, + [77388] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2659), 1, + ACTIONS(3370), 1, + anon_sym_DASH_GT, + [77395] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3372), 1, anon_sym_LBRACE, - [64525] = 2, - ACTIONS(366), 1, + [77402] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2335), 1, + ACTIONS(2966), 1, anon_sym_LPAREN, - [64532] = 2, - ACTIONS(366), 1, + [77409] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2661), 1, + ACTIONS(3374), 1, + sym_identifier, + [77416] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3376), 1, sym_identifier, - [64539] = 2, - ACTIONS(366), 1, + [77423] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2663), 1, + ACTIONS(3378), 1, anon_sym_LBRACE, - [64546] = 2, - ACTIONS(366), 1, + [77430] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2665), 1, + ACTIONS(3380), 1, sym_identifier, - [64553] = 2, - ACTIONS(366), 1, + [77437] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2667), 1, + ACTIONS(3382), 1, + anon_sym_LPAREN, + [77444] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3384), 1, sym_identifier, - [64560] = 2, - ACTIONS(366), 1, + [77451] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2669), 1, - anon_sym_COLON, - [64567] = 2, - ACTIONS(366), 1, + ACTIONS(3386), 1, + anon_sym_RBRACK, + [77458] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2671), 1, - sym_identifier, - [64574] = 2, - ACTIONS(366), 1, + ACTIONS(3388), 1, + anon_sym_RBRACK, + [77465] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2673), 1, + ACTIONS(3390), 1, sym_identifier, - [64581] = 2, - ACTIONS(366), 1, + [77472] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2675), 1, + ACTIONS(3392), 1, anon_sym_LPAREN, - [64588] = 2, - ACTIONS(366), 1, + [77479] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2677), 1, - anon_sym_RBRACE, - [64595] = 2, - ACTIONS(366), 1, + ACTIONS(3394), 1, + sym_identifier, + [77486] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2679), 1, + ACTIONS(3396), 1, sym_identifier, - [64602] = 2, - ACTIONS(366), 1, + [77493] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3398), 1, + anon_sym_RPAREN, + [77500] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3400), 1, + anon_sym_DASH_GT, + [77507] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2681), 1, + ACTIONS(3402), 1, anon_sym_GT, - [64609] = 2, - ACTIONS(366), 1, + [77514] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2683), 1, - sym_identifier, - [64616] = 2, - ACTIONS(366), 1, + ACTIONS(3404), 1, + anon_sym_DASH_GT, + [77521] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2685), 1, + ACTIONS(3406), 1, anon_sym_QMARK, - [64623] = 2, - ACTIONS(366), 1, + [77528] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2687), 1, - anon_sym_RPAREN, - [64630] = 2, - ACTIONS(366), 1, + ACTIONS(3408), 1, + anon_sym_EQ, + [77535] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2689), 1, + ACTIONS(3410), 1, anon_sym_LPAREN, - [64637] = 2, - ACTIONS(366), 1, + [77542] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3412), 1, + anon_sym_RPAREN, + [77549] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3414), 1, + anon_sym_EQ, + [77556] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2691), 1, + ACTIONS(3416), 1, anon_sym_GT, - [64644] = 2, - ACTIONS(366), 1, + [77563] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2693), 1, + ACTIONS(3418), 1, anon_sym_LPAREN, - [64651] = 2, - ACTIONS(366), 1, + [77570] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2695), 1, - anon_sym_RBRACK, - [64658] = 2, - ACTIONS(366), 1, + ACTIONS(3420), 1, + anon_sym_RPAREN, + [77577] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2697), 1, + ACTIONS(3422), 1, sym_identifier, - [64665] = 2, - ACTIONS(366), 1, + [77584] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3424), 1, + anon_sym_EQ, + [77591] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3426), 1, + anon_sym_GT, + [77598] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2699), 1, + ACTIONS(3428), 1, anon_sym_LBRACE, - [64672] = 2, - ACTIONS(366), 1, + [77605] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2701), 1, + ACTIONS(3430), 1, anon_sym_LPAREN, - [64679] = 2, - ACTIONS(366), 1, + [77612] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2703), 1, - anon_sym_RPAREN, - [64686] = 2, - ACTIONS(366), 1, + ACTIONS(3432), 1, + anon_sym_EQ, + [77619] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2705), 1, + ACTIONS(3434), 1, anon_sym_LPAREN, - [64693] = 2, - ACTIONS(366), 1, + [77626] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2707), 1, + ACTIONS(3436), 1, anon_sym_LBRACE, - [64700] = 2, - ACTIONS(366), 1, + [77633] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2225), 1, - anon_sym_EQ_GT, - [64707] = 2, - ACTIONS(366), 1, + ACTIONS(2804), 1, + anon_sym_RBRACE, + [77640] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2709), 1, + ACTIONS(3438), 1, + anon_sym_RBRACE, + [77647] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3440), 1, sym_identifier, - [64714] = 2, - ACTIONS(366), 1, + [77654] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2711), 1, + ACTIONS(3442), 1, anon_sym_LPAREN, - [64721] = 2, - ACTIONS(366), 1, + [77661] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2713), 1, - sym_identifier, - [64728] = 2, - ACTIONS(366), 1, + ACTIONS(3444), 1, + anon_sym_module, + [77668] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2715), 1, - sym_identifier, - [64735] = 2, - ACTIONS(366), 1, + ACTIONS(3446), 1, + anon_sym_RBRACK, + [77675] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2717), 1, + ACTIONS(3448), 1, anon_sym_QMARK, - [64742] = 2, - ACTIONS(366), 1, + [77682] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2719), 1, + ACTIONS(1991), 1, + anon_sym_RPAREN, + [77689] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3450), 1, anon_sym_LPAREN, - [64749] = 2, - ACTIONS(366), 1, + [77696] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2721), 1, + ACTIONS(3452), 1, anon_sym_LPAREN, - [64756] = 2, - ACTIONS(366), 1, + [77703] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2723), 1, + ACTIONS(3454), 1, sym_identifier, - [64763] = 2, - ACTIONS(366), 1, + [77710] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2725), 1, + ACTIONS(3456), 1, + anon_sym_LPAREN, + [77717] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3458), 1, anon_sym_QMARK, - [64770] = 2, - ACTIONS(366), 1, + [77724] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2727), 1, + ACTIONS(3460), 1, anon_sym_fn, - [64777] = 2, - ACTIONS(366), 1, + [77731] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2729), 1, + ACTIONS(3462), 1, + anon_sym_module, + [77738] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3464), 1, + anon_sym_LPAREN, + [77745] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3466), 1, sym_identifier, - [64784] = 2, - ACTIONS(366), 1, + [77752] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2731), 1, + ACTIONS(2802), 1, anon_sym_DOT, - [64791] = 2, - ACTIONS(366), 1, + [77759] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2733), 1, + ACTIONS(3468), 1, sym_identifier, - [64798] = 2, - ACTIONS(366), 1, + [77766] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2735), 1, + ACTIONS(3470), 1, anon_sym_fn, - [64805] = 2, - ACTIONS(366), 1, + [77773] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2737), 1, - anon_sym_COLON, - [64812] = 2, - ACTIONS(366), 1, + ACTIONS(3472), 1, + anon_sym_module, + [77780] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2739), 1, + ACTIONS(3474), 1, anon_sym_LPAREN, - [64819] = 2, - ACTIONS(366), 1, + [77787] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3476), 1, + anon_sym_LBRACE, + [77794] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2741), 1, + ACTIONS(3478), 1, + sym_identifier, + [77801] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3480), 1, anon_sym_RBRACE, - [64826] = 2, - ACTIONS(366), 1, + [77808] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2743), 1, + ACTIONS(3482), 1, anon_sym_GT, - [64833] = 2, - ACTIONS(366), 1, + [77815] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2745), 1, - anon_sym_RPAREN, - [64840] = 2, - ACTIONS(366), 1, + ACTIONS(3484), 1, + anon_sym_LPAREN, + [77822] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2747), 1, + ACTIONS(3486), 1, + anon_sym_LPAREN, + [77829] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3488), 1, anon_sym_GT, - [64847] = 2, - ACTIONS(366), 1, + [77836] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2749), 1, - anon_sym_EQ, - [64854] = 2, - ACTIONS(366), 1, + ACTIONS(3490), 1, + anon_sym_LBRACE, + [77843] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3492), 1, + sym_identifier, + [77850] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2751), 1, + ACTIONS(2810), 1, anon_sym_DOT, - [64861] = 2, - ACTIONS(366), 1, + [77857] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2753), 1, + ACTIONS(3494), 1, sym_identifier, - [64868] = 2, - ACTIONS(366), 1, + [77864] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2755), 1, + ACTIONS(3496), 1, sym_identifier, - [64875] = 2, - ACTIONS(366), 1, + [77871] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2757), 1, + ACTIONS(3498), 1, anon_sym_RBRACE, - [64882] = 2, - ACTIONS(366), 1, + [77878] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2759), 1, + ACTIONS(3500), 1, anon_sym_GT, - [64889] = 2, - ACTIONS(366), 1, + [77885] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2761), 1, + ACTIONS(3502), 1, anon_sym_GT, - [64896] = 2, - ACTIONS(366), 1, + [77892] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2763), 1, + ACTIONS(3504), 1, anon_sym_RBRACE, - [64903] = 2, - ACTIONS(366), 1, + [77899] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2765), 1, + ACTIONS(3506), 1, anon_sym_LPAREN, - [64910] = 2, - ACTIONS(366), 1, + [77906] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2767), 1, + ACTIONS(2882), 1, + anon_sym_EQ_GT, + [77913] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3508), 1, sym_identifier, - [64917] = 2, - ACTIONS(366), 1, + [77920] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2769), 1, - anon_sym_GT, - [64924] = 2, - ACTIONS(366), 1, + ACTIONS(2653), 1, + anon_sym_RBRACE, + [77927] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3510), 1, + anon_sym_RBRACE, + [77934] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2771), 1, + ACTIONS(3512), 1, anon_sym_RPAREN, - [64931] = 2, - ACTIONS(366), 1, + [77941] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2773), 1, + ACTIONS(3514), 1, sym_identifier, - [64938] = 2, - ACTIONS(366), 1, + [77948] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2775), 1, - ts_builtin_sym_end, - [64945] = 2, - ACTIONS(366), 1, + ACTIONS(3516), 1, + anon_sym_GT, + [77955] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2777), 1, + ACTIONS(3518), 1, anon_sym_LPAREN, - [64952] = 2, - ACTIONS(366), 1, + [77962] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2779), 1, - sym_identifier, - [64959] = 2, - ACTIONS(366), 1, + ACTIONS(3520), 1, + anon_sym_RBRACE, + [77969] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2781), 1, - anon_sym_EQ, - [64966] = 2, - ACTIONS(366), 1, + ACTIONS(3522), 1, + anon_sym_LBRACE, + [77976] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2783), 1, - anon_sym_LPAREN, - [64973] = 2, - ACTIONS(366), 1, + ACTIONS(3524), 1, + anon_sym_COLON, + [77983] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2785), 1, - anon_sym_RBRACE, - [64980] = 2, - ACTIONS(366), 1, + ACTIONS(3526), 1, + anon_sym_RPAREN, + [77990] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2787), 1, - anon_sym_else, - [64987] = 2, - ACTIONS(366), 1, + ACTIONS(3528), 1, + anon_sym_LBRACE, + [77997] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3530), 1, + anon_sym_EQ_GT, + [78004] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2789), 1, + ACTIONS(3532), 1, + anon_sym_fn, + [78011] = 2, + ACTIONS(430), 1, + sym_line_comment, + ACTIONS(3534), 1, anon_sym_RPAREN, - [64994] = 2, - ACTIONS(366), 1, + [78018] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2791), 1, - anon_sym_GT, - [65001] = 2, - ACTIONS(366), 1, + ACTIONS(3536), 1, + anon_sym_fn, + [78025] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2793), 1, - anon_sym_PIPE, - [65008] = 2, - ACTIONS(366), 1, + ACTIONS(3538), 1, + anon_sym_LBRACE, + [78032] = 2, + ACTIONS(430), 1, sym_line_comment, - ACTIONS(2795), 1, - anon_sym_RBRACE, + ACTIONS(3540), 1, + anon_sym_RPAREN, }; static const uint32_t ts_small_parse_table_map[] = { - [SMALL_STATE(20)] = 0, - [SMALL_STATE(21)] = 119, - [SMALL_STATE(22)] = 238, - [SMALL_STATE(23)] = 357, - [SMALL_STATE(24)] = 476, - [SMALL_STATE(25)] = 595, - [SMALL_STATE(26)] = 714, - [SMALL_STATE(27)] = 824, - [SMALL_STATE(28)] = 934, - [SMALL_STATE(29)] = 1044, - [SMALL_STATE(30)] = 1154, - [SMALL_STATE(31)] = 1264, - [SMALL_STATE(32)] = 1374, - [SMALL_STATE(33)] = 1484, - [SMALL_STATE(34)] = 1594, - [SMALL_STATE(35)] = 1704, - [SMALL_STATE(36)] = 1814, - [SMALL_STATE(37)] = 1924, - [SMALL_STATE(38)] = 2034, - [SMALL_STATE(39)] = 2144, - [SMALL_STATE(40)] = 2254, - [SMALL_STATE(41)] = 2361, - [SMALL_STATE(42)] = 2468, - [SMALL_STATE(43)] = 2575, - [SMALL_STATE(44)] = 2682, - [SMALL_STATE(45)] = 2789, - [SMALL_STATE(46)] = 2896, - [SMALL_STATE(47)] = 3003, - [SMALL_STATE(48)] = 3110, - [SMALL_STATE(49)] = 3217, - [SMALL_STATE(50)] = 3324, - [SMALL_STATE(51)] = 3431, - [SMALL_STATE(52)] = 3538, - [SMALL_STATE(53)] = 3645, - [SMALL_STATE(54)] = 3752, - [SMALL_STATE(55)] = 3859, - [SMALL_STATE(56)] = 3966, - [SMALL_STATE(57)] = 4073, - [SMALL_STATE(58)] = 4180, - [SMALL_STATE(59)] = 4287, - [SMALL_STATE(60)] = 4394, - [SMALL_STATE(61)] = 4501, - [SMALL_STATE(62)] = 4608, - [SMALL_STATE(63)] = 4715, - [SMALL_STATE(64)] = 4822, - [SMALL_STATE(65)] = 4929, - [SMALL_STATE(66)] = 5036, - [SMALL_STATE(67)] = 5143, - [SMALL_STATE(68)] = 5250, - [SMALL_STATE(69)] = 5357, - [SMALL_STATE(70)] = 5464, - [SMALL_STATE(71)] = 5571, - [SMALL_STATE(72)] = 5678, - [SMALL_STATE(73)] = 5785, - [SMALL_STATE(74)] = 5892, - [SMALL_STATE(75)] = 5999, - [SMALL_STATE(76)] = 6106, - [SMALL_STATE(77)] = 6215, - [SMALL_STATE(78)] = 6322, - [SMALL_STATE(79)] = 6429, - [SMALL_STATE(80)] = 6536, - [SMALL_STATE(81)] = 6643, - [SMALL_STATE(82)] = 6750, - [SMALL_STATE(83)] = 6857, - [SMALL_STATE(84)] = 6964, - [SMALL_STATE(85)] = 7071, - [SMALL_STATE(86)] = 7178, - [SMALL_STATE(87)] = 7285, - [SMALL_STATE(88)] = 7392, - [SMALL_STATE(89)] = 7499, - [SMALL_STATE(90)] = 7606, - [SMALL_STATE(91)] = 7713, - [SMALL_STATE(92)] = 7820, - [SMALL_STATE(93)] = 7927, - [SMALL_STATE(94)] = 8034, - [SMALL_STATE(95)] = 8141, - [SMALL_STATE(96)] = 8248, - [SMALL_STATE(97)] = 8355, - [SMALL_STATE(98)] = 8462, - [SMALL_STATE(99)] = 8569, - [SMALL_STATE(100)] = 8676, - [SMALL_STATE(101)] = 8783, - [SMALL_STATE(102)] = 8890, - [SMALL_STATE(103)] = 8997, - [SMALL_STATE(104)] = 9104, - [SMALL_STATE(105)] = 9211, - [SMALL_STATE(106)] = 9318, - [SMALL_STATE(107)] = 9425, - [SMALL_STATE(108)] = 9532, - [SMALL_STATE(109)] = 9639, - [SMALL_STATE(110)] = 9746, - [SMALL_STATE(111)] = 9853, - [SMALL_STATE(112)] = 9960, - [SMALL_STATE(113)] = 10067, - [SMALL_STATE(114)] = 10174, - [SMALL_STATE(115)] = 10281, - [SMALL_STATE(116)] = 10388, - [SMALL_STATE(117)] = 10495, - [SMALL_STATE(118)] = 10602, - [SMALL_STATE(119)] = 10709, - [SMALL_STATE(120)] = 10816, - [SMALL_STATE(121)] = 10923, - [SMALL_STATE(122)] = 11030, - [SMALL_STATE(123)] = 11137, - [SMALL_STATE(124)] = 11244, - [SMALL_STATE(125)] = 11351, - [SMALL_STATE(126)] = 11458, - [SMALL_STATE(127)] = 11565, - [SMALL_STATE(128)] = 11672, - [SMALL_STATE(129)] = 11779, - [SMALL_STATE(130)] = 11886, - [SMALL_STATE(131)] = 11993, - [SMALL_STATE(132)] = 12100, - [SMALL_STATE(133)] = 12207, - [SMALL_STATE(134)] = 12314, - [SMALL_STATE(135)] = 12421, - [SMALL_STATE(136)] = 12528, - [SMALL_STATE(137)] = 12635, - [SMALL_STATE(138)] = 12742, - [SMALL_STATE(139)] = 12849, - [SMALL_STATE(140)] = 12956, - [SMALL_STATE(141)] = 13063, - [SMALL_STATE(142)] = 13170, - [SMALL_STATE(143)] = 13277, - [SMALL_STATE(144)] = 13384, - [SMALL_STATE(145)] = 13491, - [SMALL_STATE(146)] = 13598, - [SMALL_STATE(147)] = 13705, - [SMALL_STATE(148)] = 13812, - [SMALL_STATE(149)] = 13919, - [SMALL_STATE(150)] = 14026, - [SMALL_STATE(151)] = 14133, - [SMALL_STATE(152)] = 14240, - [SMALL_STATE(153)] = 14347, - [SMALL_STATE(154)] = 14454, - [SMALL_STATE(155)] = 14561, - [SMALL_STATE(156)] = 14668, - [SMALL_STATE(157)] = 14775, - [SMALL_STATE(158)] = 14882, - [SMALL_STATE(159)] = 14989, - [SMALL_STATE(160)] = 15096, - [SMALL_STATE(161)] = 15203, - [SMALL_STATE(162)] = 15310, - [SMALL_STATE(163)] = 15417, - [SMALL_STATE(164)] = 15524, - [SMALL_STATE(165)] = 15631, - [SMALL_STATE(166)] = 15738, - [SMALL_STATE(167)] = 15845, - [SMALL_STATE(168)] = 15952, - [SMALL_STATE(169)] = 16059, - [SMALL_STATE(170)] = 16166, - [SMALL_STATE(171)] = 16273, - [SMALL_STATE(172)] = 16380, - [SMALL_STATE(173)] = 16487, - [SMALL_STATE(174)] = 16594, - [SMALL_STATE(175)] = 16701, - [SMALL_STATE(176)] = 16808, - [SMALL_STATE(177)] = 16915, - [SMALL_STATE(178)] = 17022, - [SMALL_STATE(179)] = 17129, - [SMALL_STATE(180)] = 17236, - [SMALL_STATE(181)] = 17343, - [SMALL_STATE(182)] = 17450, - [SMALL_STATE(183)] = 17557, - [SMALL_STATE(184)] = 17664, - [SMALL_STATE(185)] = 17771, - [SMALL_STATE(186)] = 17878, - [SMALL_STATE(187)] = 17985, - [SMALL_STATE(188)] = 18092, - [SMALL_STATE(189)] = 18199, - [SMALL_STATE(190)] = 18306, - [SMALL_STATE(191)] = 18413, - [SMALL_STATE(192)] = 18520, - [SMALL_STATE(193)] = 18627, - [SMALL_STATE(194)] = 18734, - [SMALL_STATE(195)] = 18841, - [SMALL_STATE(196)] = 18948, - [SMALL_STATE(197)] = 19055, - [SMALL_STATE(198)] = 19162, - [SMALL_STATE(199)] = 19269, - [SMALL_STATE(200)] = 19376, - [SMALL_STATE(201)] = 19483, - [SMALL_STATE(202)] = 19590, - [SMALL_STATE(203)] = 19697, - [SMALL_STATE(204)] = 19804, - [SMALL_STATE(205)] = 19911, - [SMALL_STATE(206)] = 20018, - [SMALL_STATE(207)] = 20125, - [SMALL_STATE(208)] = 20232, - [SMALL_STATE(209)] = 20339, - [SMALL_STATE(210)] = 20446, - [SMALL_STATE(211)] = 20553, - [SMALL_STATE(212)] = 20660, - [SMALL_STATE(213)] = 20767, - [SMALL_STATE(214)] = 20874, - [SMALL_STATE(215)] = 20981, - [SMALL_STATE(216)] = 21088, - [SMALL_STATE(217)] = 21195, - [SMALL_STATE(218)] = 21302, - [SMALL_STATE(219)] = 21409, - [SMALL_STATE(220)] = 21516, - [SMALL_STATE(221)] = 21623, - [SMALL_STATE(222)] = 21730, - [SMALL_STATE(223)] = 21801, - [SMALL_STATE(224)] = 21908, - [SMALL_STATE(225)] = 22015, - [SMALL_STATE(226)] = 22122, - [SMALL_STATE(227)] = 22229, - [SMALL_STATE(228)] = 22336, - [SMALL_STATE(229)] = 22443, - [SMALL_STATE(230)] = 22550, - [SMALL_STATE(231)] = 22657, - [SMALL_STATE(232)] = 22764, - [SMALL_STATE(233)] = 22871, - [SMALL_STATE(234)] = 22978, - [SMALL_STATE(235)] = 23085, - [SMALL_STATE(236)] = 23192, - [SMALL_STATE(237)] = 23299, - [SMALL_STATE(238)] = 23406, - [SMALL_STATE(239)] = 23513, - [SMALL_STATE(240)] = 23620, - [SMALL_STATE(241)] = 23727, - [SMALL_STATE(242)] = 23834, - [SMALL_STATE(243)] = 23941, - [SMALL_STATE(244)] = 24048, - [SMALL_STATE(245)] = 24155, - [SMALL_STATE(246)] = 24262, - [SMALL_STATE(247)] = 24369, - [SMALL_STATE(248)] = 24476, - [SMALL_STATE(249)] = 24583, - [SMALL_STATE(250)] = 24690, - [SMALL_STATE(251)] = 24797, - [SMALL_STATE(252)] = 24904, - [SMALL_STATE(253)] = 25011, - [SMALL_STATE(254)] = 25118, - [SMALL_STATE(255)] = 25225, - [SMALL_STATE(256)] = 25332, - [SMALL_STATE(257)] = 25439, - [SMALL_STATE(258)] = 25546, - [SMALL_STATE(259)] = 25653, - [SMALL_STATE(260)] = 25760, - [SMALL_STATE(261)] = 25867, - [SMALL_STATE(262)] = 25974, - [SMALL_STATE(263)] = 26081, - [SMALL_STATE(264)] = 26147, - [SMALL_STATE(265)] = 26215, - [SMALL_STATE(266)] = 26283, - [SMALL_STATE(267)] = 26349, - [SMALL_STATE(268)] = 26408, - [SMALL_STATE(269)] = 26467, - [SMALL_STATE(270)] = 26526, - [SMALL_STATE(271)] = 26585, - [SMALL_STATE(272)] = 26644, - [SMALL_STATE(273)] = 26703, - [SMALL_STATE(274)] = 26762, - [SMALL_STATE(275)] = 26821, - [SMALL_STATE(276)] = 26880, - [SMALL_STATE(277)] = 26939, - [SMALL_STATE(278)] = 26998, - [SMALL_STATE(279)] = 27057, - [SMALL_STATE(280)] = 27116, - [SMALL_STATE(281)] = 27175, - [SMALL_STATE(282)] = 27234, - [SMALL_STATE(283)] = 27293, - [SMALL_STATE(284)] = 27352, - [SMALL_STATE(285)] = 27425, - [SMALL_STATE(286)] = 27484, - [SMALL_STATE(287)] = 27543, - [SMALL_STATE(288)] = 27622, - [SMALL_STATE(289)] = 27699, - [SMALL_STATE(290)] = 27770, - [SMALL_STATE(291)] = 27837, - [SMALL_STATE(292)] = 27902, - [SMALL_STATE(293)] = 27961, - [SMALL_STATE(294)] = 28046, - [SMALL_STATE(295)] = 28105, - [SMALL_STATE(296)] = 28164, - [SMALL_STATE(297)] = 28223, - [SMALL_STATE(298)] = 28282, - [SMALL_STATE(299)] = 28341, - [SMALL_STATE(300)] = 28400, - [SMALL_STATE(301)] = 28459, - [SMALL_STATE(302)] = 28518, - [SMALL_STATE(303)] = 28577, - [SMALL_STATE(304)] = 28636, - [SMALL_STATE(305)] = 28725, - [SMALL_STATE(306)] = 28784, - [SMALL_STATE(307)] = 28843, - [SMALL_STATE(308)] = 28928, - [SMALL_STATE(309)] = 28993, - [SMALL_STATE(310)] = 29082, - [SMALL_STATE(311)] = 29141, - [SMALL_STATE(312)] = 29200, - [SMALL_STATE(313)] = 29259, - [SMALL_STATE(314)] = 29318, - [SMALL_STATE(315)] = 29403, - [SMALL_STATE(316)] = 29462, - [SMALL_STATE(317)] = 29551, - [SMALL_STATE(318)] = 29610, - [SMALL_STATE(319)] = 29669, - [SMALL_STATE(320)] = 29754, - [SMALL_STATE(321)] = 29813, - [SMALL_STATE(322)] = 29872, - [SMALL_STATE(323)] = 29957, - [SMALL_STATE(324)] = 30016, - [SMALL_STATE(325)] = 30101, - [SMALL_STATE(326)] = 30160, - [SMALL_STATE(327)] = 30219, - [SMALL_STATE(328)] = 30278, - [SMALL_STATE(329)] = 30337, - [SMALL_STATE(330)] = 30396, - [SMALL_STATE(331)] = 30455, - [SMALL_STATE(332)] = 30540, - [SMALL_STATE(333)] = 30599, - [SMALL_STATE(334)] = 30658, - [SMALL_STATE(335)] = 30717, - [SMALL_STATE(336)] = 30776, - [SMALL_STATE(337)] = 30835, - [SMALL_STATE(338)] = 30894, - [SMALL_STATE(339)] = 30953, - [SMALL_STATE(340)] = 31012, - [SMALL_STATE(341)] = 31097, - [SMALL_STATE(342)] = 31156, - [SMALL_STATE(343)] = 31215, - [SMALL_STATE(344)] = 31274, - [SMALL_STATE(345)] = 31359, - [SMALL_STATE(346)] = 31418, - [SMALL_STATE(347)] = 31477, - [SMALL_STATE(348)] = 31544, - [SMALL_STATE(349)] = 31603, - [SMALL_STATE(350)] = 31688, - [SMALL_STATE(351)] = 31747, - [SMALL_STATE(352)] = 31832, - [SMALL_STATE(353)] = 31891, - [SMALL_STATE(354)] = 31961, - [SMALL_STATE(355)] = 32045, - [SMALL_STATE(356)] = 32129, - [SMALL_STATE(357)] = 32213, - [SMALL_STATE(358)] = 32299, - [SMALL_STATE(359)] = 32383, - [SMALL_STATE(360)] = 32467, - [SMALL_STATE(361)] = 32551, - [SMALL_STATE(362)] = 32635, - [SMALL_STATE(363)] = 32719, - [SMALL_STATE(364)] = 32803, - [SMALL_STATE(365)] = 32887, - [SMALL_STATE(366)] = 32971, - [SMALL_STATE(367)] = 33055, - [SMALL_STATE(368)] = 33139, - [SMALL_STATE(369)] = 33223, - [SMALL_STATE(370)] = 33307, - [SMALL_STATE(371)] = 33391, - [SMALL_STATE(372)] = 33475, - [SMALL_STATE(373)] = 33559, - [SMALL_STATE(374)] = 33643, - [SMALL_STATE(375)] = 33727, - [SMALL_STATE(376)] = 33811, - [SMALL_STATE(377)] = 33895, - [SMALL_STATE(378)] = 33979, - [SMALL_STATE(379)] = 34063, - [SMALL_STATE(380)] = 34147, - [SMALL_STATE(381)] = 34231, - [SMALL_STATE(382)] = 34315, - [SMALL_STATE(383)] = 34399, - [SMALL_STATE(384)] = 34483, - [SMALL_STATE(385)] = 34569, - [SMALL_STATE(386)] = 34653, - [SMALL_STATE(387)] = 34737, - [SMALL_STATE(388)] = 34821, - [SMALL_STATE(389)] = 34905, - [SMALL_STATE(390)] = 34989, - [SMALL_STATE(391)] = 35073, - [SMALL_STATE(392)] = 35157, - [SMALL_STATE(393)] = 35241, - [SMALL_STATE(394)] = 35325, - [SMALL_STATE(395)] = 35409, - [SMALL_STATE(396)] = 35493, - [SMALL_STATE(397)] = 35577, - [SMALL_STATE(398)] = 35661, - [SMALL_STATE(399)] = 35745, - [SMALL_STATE(400)] = 35829, - [SMALL_STATE(401)] = 35913, - [SMALL_STATE(402)] = 35997, - [SMALL_STATE(403)] = 36081, - [SMALL_STATE(404)] = 36165, - [SMALL_STATE(405)] = 36237, - [SMALL_STATE(406)] = 36321, - [SMALL_STATE(407)] = 36405, - [SMALL_STATE(408)] = 36489, - [SMALL_STATE(409)] = 36573, - [SMALL_STATE(410)] = 36657, - [SMALL_STATE(411)] = 36741, - [SMALL_STATE(412)] = 36825, - [SMALL_STATE(413)] = 36909, - [SMALL_STATE(414)] = 36993, - [SMALL_STATE(415)] = 37071, - [SMALL_STATE(416)] = 37155, - [SMALL_STATE(417)] = 37231, - [SMALL_STATE(418)] = 37315, - [SMALL_STATE(419)] = 37381, - [SMALL_STATE(420)] = 37465, - [SMALL_STATE(421)] = 37549, - [SMALL_STATE(422)] = 37633, - [SMALL_STATE(423)] = 37717, - [SMALL_STATE(424)] = 37801, - [SMALL_STATE(425)] = 37885, - [SMALL_STATE(426)] = 37969, - [SMALL_STATE(427)] = 38053, - [SMALL_STATE(428)] = 38137, - [SMALL_STATE(429)] = 38221, - [SMALL_STATE(430)] = 38305, - [SMALL_STATE(431)] = 38389, - [SMALL_STATE(432)] = 38473, - [SMALL_STATE(433)] = 38557, - [SMALL_STATE(434)] = 38641, - [SMALL_STATE(435)] = 38725, - [SMALL_STATE(436)] = 38809, - [SMALL_STATE(437)] = 38893, - [SMALL_STATE(438)] = 38977, - [SMALL_STATE(439)] = 39061, - [SMALL_STATE(440)] = 39145, - [SMALL_STATE(441)] = 39211, - [SMALL_STATE(442)] = 39295, - [SMALL_STATE(443)] = 39379, - [SMALL_STATE(444)] = 39463, - [SMALL_STATE(445)] = 39547, - [SMALL_STATE(446)] = 39633, - [SMALL_STATE(447)] = 39719, - [SMALL_STATE(448)] = 39803, - [SMALL_STATE(449)] = 39889, - [SMALL_STATE(450)] = 39975, - [SMALL_STATE(451)] = 40061, - [SMALL_STATE(452)] = 40145, - [SMALL_STATE(453)] = 40229, - [SMALL_STATE(454)] = 40315, - [SMALL_STATE(455)] = 40365, - [SMALL_STATE(456)] = 40415, - [SMALL_STATE(457)] = 40465, - [SMALL_STATE(458)] = 40515, - [SMALL_STATE(459)] = 40565, - [SMALL_STATE(460)] = 40615, - [SMALL_STATE(461)] = 40665, - [SMALL_STATE(462)] = 40710, - [SMALL_STATE(463)] = 40759, - [SMALL_STATE(464)] = 40806, - [SMALL_STATE(465)] = 40855, - [SMALL_STATE(466)] = 40904, - [SMALL_STATE(467)] = 40953, - [SMALL_STATE(468)] = 41002, - [SMALL_STATE(469)] = 41051, - [SMALL_STATE(470)] = 41100, - [SMALL_STATE(471)] = 41149, - [SMALL_STATE(472)] = 41198, - [SMALL_STATE(473)] = 41247, - [SMALL_STATE(474)] = 41296, - [SMALL_STATE(475)] = 41341, - [SMALL_STATE(476)] = 41390, - [SMALL_STATE(477)] = 41435, - [SMALL_STATE(478)] = 41484, - [SMALL_STATE(479)] = 41528, - [SMALL_STATE(480)] = 41572, - [SMALL_STATE(481)] = 41616, - [SMALL_STATE(482)] = 41660, - [SMALL_STATE(483)] = 41704, - [SMALL_STATE(484)] = 41748, - [SMALL_STATE(485)] = 41792, - [SMALL_STATE(486)] = 41836, - [SMALL_STATE(487)] = 41880, - [SMALL_STATE(488)] = 41928, - [SMALL_STATE(489)] = 41972, - [SMALL_STATE(490)] = 42018, - [SMALL_STATE(491)] = 42064, - [SMALL_STATE(492)] = 42108, - [SMALL_STATE(493)] = 42154, - [SMALL_STATE(494)] = 42198, - [SMALL_STATE(495)] = 42244, - [SMALL_STATE(496)] = 42290, - [SMALL_STATE(497)] = 42334, - [SMALL_STATE(498)] = 42378, - [SMALL_STATE(499)] = 42422, - [SMALL_STATE(500)] = 42468, - [SMALL_STATE(501)] = 42512, - [SMALL_STATE(502)] = 42556, - [SMALL_STATE(503)] = 42600, - [SMALL_STATE(504)] = 42644, - [SMALL_STATE(505)] = 42690, - [SMALL_STATE(506)] = 42734, - [SMALL_STATE(507)] = 42778, - [SMALL_STATE(508)] = 42822, - [SMALL_STATE(509)] = 42866, - [SMALL_STATE(510)] = 42910, - [SMALL_STATE(511)] = 42954, - [SMALL_STATE(512)] = 42998, - [SMALL_STATE(513)] = 43042, - [SMALL_STATE(514)] = 43086, - [SMALL_STATE(515)] = 43130, - [SMALL_STATE(516)] = 43174, - [SMALL_STATE(517)] = 43218, - [SMALL_STATE(518)] = 43262, - [SMALL_STATE(519)] = 43306, - [SMALL_STATE(520)] = 43354, - [SMALL_STATE(521)] = 43398, - [SMALL_STATE(522)] = 43442, - [SMALL_STATE(523)] = 43486, - [SMALL_STATE(524)] = 43530, - [SMALL_STATE(525)] = 43576, - [SMALL_STATE(526)] = 43620, - [SMALL_STATE(527)] = 43664, - [SMALL_STATE(528)] = 43710, - [SMALL_STATE(529)] = 43754, - [SMALL_STATE(530)] = 43798, - [SMALL_STATE(531)] = 43842, - [SMALL_STATE(532)] = 43886, - [SMALL_STATE(533)] = 43929, - [SMALL_STATE(534)] = 43972, - [SMALL_STATE(535)] = 44015, - [SMALL_STATE(536)] = 44058, - [SMALL_STATE(537)] = 44101, - [SMALL_STATE(538)] = 44144, - [SMALL_STATE(539)] = 44187, - [SMALL_STATE(540)] = 44230, - [SMALL_STATE(541)] = 44273, - [SMALL_STATE(542)] = 44316, - [SMALL_STATE(543)] = 44359, - [SMALL_STATE(544)] = 44402, - [SMALL_STATE(545)] = 44445, - [SMALL_STATE(546)] = 44488, - [SMALL_STATE(547)] = 44531, - [SMALL_STATE(548)] = 44574, - [SMALL_STATE(549)] = 44617, - [SMALL_STATE(550)] = 44660, - [SMALL_STATE(551)] = 44703, - [SMALL_STATE(552)] = 44746, - [SMALL_STATE(553)] = 44789, - [SMALL_STATE(554)] = 44832, - [SMALL_STATE(555)] = 44875, - [SMALL_STATE(556)] = 44918, - [SMALL_STATE(557)] = 44961, - [SMALL_STATE(558)] = 45004, - [SMALL_STATE(559)] = 45047, - [SMALL_STATE(560)] = 45090, - [SMALL_STATE(561)] = 45133, - [SMALL_STATE(562)] = 45176, - [SMALL_STATE(563)] = 45219, - [SMALL_STATE(564)] = 45262, - [SMALL_STATE(565)] = 45305, - [SMALL_STATE(566)] = 45348, - [SMALL_STATE(567)] = 45391, - [SMALL_STATE(568)] = 45434, - [SMALL_STATE(569)] = 45477, - [SMALL_STATE(570)] = 45520, - [SMALL_STATE(571)] = 45563, - [SMALL_STATE(572)] = 45606, - [SMALL_STATE(573)] = 45649, - [SMALL_STATE(574)] = 45692, - [SMALL_STATE(575)] = 45735, - [SMALL_STATE(576)] = 45778, - [SMALL_STATE(577)] = 45821, - [SMALL_STATE(578)] = 45864, - [SMALL_STATE(579)] = 45907, - [SMALL_STATE(580)] = 45950, - [SMALL_STATE(581)] = 45993, - [SMALL_STATE(582)] = 46036, - [SMALL_STATE(583)] = 46079, - [SMALL_STATE(584)] = 46122, - [SMALL_STATE(585)] = 46165, - [SMALL_STATE(586)] = 46208, - [SMALL_STATE(587)] = 46251, - [SMALL_STATE(588)] = 46294, - [SMALL_STATE(589)] = 46337, - [SMALL_STATE(590)] = 46380, - [SMALL_STATE(591)] = 46423, - [SMALL_STATE(592)] = 46466, - [SMALL_STATE(593)] = 46509, - [SMALL_STATE(594)] = 46552, - [SMALL_STATE(595)] = 46595, - [SMALL_STATE(596)] = 46638, - [SMALL_STATE(597)] = 46681, - [SMALL_STATE(598)] = 46724, - [SMALL_STATE(599)] = 46767, - [SMALL_STATE(600)] = 46810, - [SMALL_STATE(601)] = 46859, - [SMALL_STATE(602)] = 46902, - [SMALL_STATE(603)] = 46945, - [SMALL_STATE(604)] = 46988, - [SMALL_STATE(605)] = 47031, - [SMALL_STATE(606)] = 47074, - [SMALL_STATE(607)] = 47117, - [SMALL_STATE(608)] = 47160, - [SMALL_STATE(609)] = 47203, - [SMALL_STATE(610)] = 47246, - [SMALL_STATE(611)] = 47289, - [SMALL_STATE(612)] = 47332, - [SMALL_STATE(613)] = 47375, - [SMALL_STATE(614)] = 47418, - [SMALL_STATE(615)] = 47461, - [SMALL_STATE(616)] = 47504, - [SMALL_STATE(617)] = 47547, - [SMALL_STATE(618)] = 47590, - [SMALL_STATE(619)] = 47633, - [SMALL_STATE(620)] = 47676, - [SMALL_STATE(621)] = 47718, - [SMALL_STATE(622)] = 47760, - [SMALL_STATE(623)] = 47802, - [SMALL_STATE(624)] = 47844, - [SMALL_STATE(625)] = 47912, - [SMALL_STATE(626)] = 47962, - [SMALL_STATE(627)] = 48030, - [SMALL_STATE(628)] = 48078, - [SMALL_STATE(629)] = 48128, - [SMALL_STATE(630)] = 48170, - [SMALL_STATE(631)] = 48238, - [SMALL_STATE(632)] = 48280, - [SMALL_STATE(633)] = 48322, - [SMALL_STATE(634)] = 48364, - [SMALL_STATE(635)] = 48406, - [SMALL_STATE(636)] = 48474, - [SMALL_STATE(637)] = 48530, - [SMALL_STATE(638)] = 48572, - [SMALL_STATE(639)] = 48614, - [SMALL_STATE(640)] = 48656, - [SMALL_STATE(641)] = 48698, - [SMALL_STATE(642)] = 48766, - [SMALL_STATE(643)] = 48808, - [SMALL_STATE(644)] = 48876, - [SMALL_STATE(645)] = 48918, - [SMALL_STATE(646)] = 48960, - [SMALL_STATE(647)] = 49002, - [SMALL_STATE(648)] = 49064, - [SMALL_STATE(649)] = 49106, - [SMALL_STATE(650)] = 49148, - [SMALL_STATE(651)] = 49216, - [SMALL_STATE(652)] = 49258, - [SMALL_STATE(653)] = 49300, - [SMALL_STATE(654)] = 49342, - [SMALL_STATE(655)] = 49384, - [SMALL_STATE(656)] = 49426, - [SMALL_STATE(657)] = 49468, - [SMALL_STATE(658)] = 49510, - [SMALL_STATE(659)] = 49552, - [SMALL_STATE(660)] = 49620, - [SMALL_STATE(661)] = 49662, - [SMALL_STATE(662)] = 49730, - [SMALL_STATE(663)] = 49772, - [SMALL_STATE(664)] = 49832, - [SMALL_STATE(665)] = 49874, - [SMALL_STATE(666)] = 49942, - [SMALL_STATE(667)] = 49984, - [SMALL_STATE(668)] = 50052, - [SMALL_STATE(669)] = 50106, - [SMALL_STATE(670)] = 50169, - [SMALL_STATE(671)] = 50232, - [SMALL_STATE(672)] = 50279, - [SMALL_STATE(673)] = 50336, - [SMALL_STATE(674)] = 50387, - [SMALL_STATE(675)] = 50436, - [SMALL_STATE(676)] = 50481, - [SMALL_STATE(677)] = 50522, - [SMALL_STATE(678)] = 50579, - [SMALL_STATE(679)] = 50636, - [SMALL_STATE(680)] = 50693, - [SMALL_STATE(681)] = 50750, - [SMALL_STATE(682)] = 50807, - [SMALL_STATE(683)] = 50864, - [SMALL_STATE(684)] = 50921, - [SMALL_STATE(685)] = 50978, - [SMALL_STATE(686)] = 51035, - [SMALL_STATE(687)] = 51076, - [SMALL_STATE(688)] = 51133, - [SMALL_STATE(689)] = 51190, - [SMALL_STATE(690)] = 51247, - [SMALL_STATE(691)] = 51304, - [SMALL_STATE(692)] = 51361, - [SMALL_STATE(693)] = 51418, - [SMALL_STATE(694)] = 51475, - [SMALL_STATE(695)] = 51532, - [SMALL_STATE(696)] = 51589, - [SMALL_STATE(697)] = 51646, - [SMALL_STATE(698)] = 51703, - [SMALL_STATE(699)] = 51760, - [SMALL_STATE(700)] = 51817, - [SMALL_STATE(701)] = 51874, - [SMALL_STATE(702)] = 51931, - [SMALL_STATE(703)] = 51988, - [SMALL_STATE(704)] = 52045, - [SMALL_STATE(705)] = 52102, - [SMALL_STATE(706)] = 52159, - [SMALL_STATE(707)] = 52216, - [SMALL_STATE(708)] = 52273, - [SMALL_STATE(709)] = 52330, - [SMALL_STATE(710)] = 52387, - [SMALL_STATE(711)] = 52444, - [SMALL_STATE(712)] = 52501, - [SMALL_STATE(713)] = 52558, - [SMALL_STATE(714)] = 52615, - [SMALL_STATE(715)] = 52672, - [SMALL_STATE(716)] = 52729, - [SMALL_STATE(717)] = 52786, - [SMALL_STATE(718)] = 52843, - [SMALL_STATE(719)] = 52900, - [SMALL_STATE(720)] = 52957, - [SMALL_STATE(721)] = 53014, - [SMALL_STATE(722)] = 53071, - [SMALL_STATE(723)] = 53128, - [SMALL_STATE(724)] = 53185, - [SMALL_STATE(725)] = 53224, - [SMALL_STATE(726)] = 53267, - [SMALL_STATE(727)] = 53325, - [SMALL_STATE(728)] = 53383, - [SMALL_STATE(729)] = 53441, - [SMALL_STATE(730)] = 53495, - [SMALL_STATE(731)] = 53553, - [SMALL_STATE(732)] = 53584, - [SMALL_STATE(733)] = 53637, - [SMALL_STATE(734)] = 53690, - [SMALL_STATE(735)] = 53743, - [SMALL_STATE(736)] = 53796, - [SMALL_STATE(737)] = 53849, - [SMALL_STATE(738)] = 53901, - [SMALL_STATE(739)] = 53953, - [SMALL_STATE(740)] = 54005, - [SMALL_STATE(741)] = 54057, - [SMALL_STATE(742)] = 54109, - [SMALL_STATE(743)] = 54161, - [SMALL_STATE(744)] = 54213, - [SMALL_STATE(745)] = 54265, - [SMALL_STATE(746)] = 54317, - [SMALL_STATE(747)] = 54369, - [SMALL_STATE(748)] = 54421, - [SMALL_STATE(749)] = 54473, - [SMALL_STATE(750)] = 54525, - [SMALL_STATE(751)] = 54577, - [SMALL_STATE(752)] = 54629, - [SMALL_STATE(753)] = 54681, - [SMALL_STATE(754)] = 54733, - [SMALL_STATE(755)] = 54785, - [SMALL_STATE(756)] = 54837, - [SMALL_STATE(757)] = 54889, - [SMALL_STATE(758)] = 54941, - [SMALL_STATE(759)] = 54993, - [SMALL_STATE(760)] = 55045, - [SMALL_STATE(761)] = 55097, - [SMALL_STATE(762)] = 55149, - [SMALL_STATE(763)] = 55201, - [SMALL_STATE(764)] = 55253, - [SMALL_STATE(765)] = 55305, - [SMALL_STATE(766)] = 55357, - [SMALL_STATE(767)] = 55409, - [SMALL_STATE(768)] = 55461, - [SMALL_STATE(769)] = 55513, - [SMALL_STATE(770)] = 55565, - [SMALL_STATE(771)] = 55617, - [SMALL_STATE(772)] = 55669, - [SMALL_STATE(773)] = 55721, - [SMALL_STATE(774)] = 55770, - [SMALL_STATE(775)] = 55819, - [SMALL_STATE(776)] = 55868, - [SMALL_STATE(777)] = 55915, - [SMALL_STATE(778)] = 55962, - [SMALL_STATE(779)] = 56011, - [SMALL_STATE(780)] = 56058, - [SMALL_STATE(781)] = 56107, - [SMALL_STATE(782)] = 56156, - [SMALL_STATE(783)] = 56205, - [SMALL_STATE(784)] = 56249, - [SMALL_STATE(785)] = 56293, - [SMALL_STATE(786)] = 56337, - [SMALL_STATE(787)] = 56381, - [SMALL_STATE(788)] = 56425, - [SMALL_STATE(789)] = 56469, - [SMALL_STATE(790)] = 56513, - [SMALL_STATE(791)] = 56557, - [SMALL_STATE(792)] = 56598, - [SMALL_STATE(793)] = 56639, - [SMALL_STATE(794)] = 56680, - [SMALL_STATE(795)] = 56720, - [SMALL_STATE(796)] = 56760, - [SMALL_STATE(797)] = 56800, - [SMALL_STATE(798)] = 56837, - [SMALL_STATE(799)] = 56874, - [SMALL_STATE(800)] = 56911, - [SMALL_STATE(801)] = 56937, - [SMALL_STATE(802)] = 56972, - [SMALL_STATE(803)] = 57007, - [SMALL_STATE(804)] = 57042, - [SMALL_STATE(805)] = 57077, - [SMALL_STATE(806)] = 57112, - [SMALL_STATE(807)] = 57147, - [SMALL_STATE(808)] = 57182, - [SMALL_STATE(809)] = 57217, - [SMALL_STATE(810)] = 57252, - [SMALL_STATE(811)] = 57272, - [SMALL_STATE(812)] = 57292, - [SMALL_STATE(813)] = 57312, - [SMALL_STATE(814)] = 57332, - [SMALL_STATE(815)] = 57352, - [SMALL_STATE(816)] = 57378, - [SMALL_STATE(817)] = 57404, - [SMALL_STATE(818)] = 57430, - [SMALL_STATE(819)] = 57456, - [SMALL_STATE(820)] = 57482, - [SMALL_STATE(821)] = 57508, - [SMALL_STATE(822)] = 57531, - [SMALL_STATE(823)] = 57554, - [SMALL_STATE(824)] = 57577, - [SMALL_STATE(825)] = 57596, - [SMALL_STATE(826)] = 57615, - [SMALL_STATE(827)] = 57638, - [SMALL_STATE(828)] = 57661, - [SMALL_STATE(829)] = 57681, - [SMALL_STATE(830)] = 57701, - [SMALL_STATE(831)] = 57721, - [SMALL_STATE(832)] = 57741, - [SMALL_STATE(833)] = 57761, - [SMALL_STATE(834)] = 57781, - [SMALL_STATE(835)] = 57801, - [SMALL_STATE(836)] = 57821, - [SMALL_STATE(837)] = 57841, - [SMALL_STATE(838)] = 57861, - [SMALL_STATE(839)] = 57881, - [SMALL_STATE(840)] = 57901, - [SMALL_STATE(841)] = 57929, - [SMALL_STATE(842)] = 57949, - [SMALL_STATE(843)] = 57969, - [SMALL_STATE(844)] = 57989, - [SMALL_STATE(845)] = 58009, - [SMALL_STATE(846)] = 58029, - [SMALL_STATE(847)] = 58049, - [SMALL_STATE(848)] = 58069, - [SMALL_STATE(849)] = 58089, - [SMALL_STATE(850)] = 58109, - [SMALL_STATE(851)] = 58129, - [SMALL_STATE(852)] = 58149, - [SMALL_STATE(853)] = 58169, - [SMALL_STATE(854)] = 58189, - [SMALL_STATE(855)] = 58209, - [SMALL_STATE(856)] = 58229, - [SMALL_STATE(857)] = 58249, - [SMALL_STATE(858)] = 58269, - [SMALL_STATE(859)] = 58289, - [SMALL_STATE(860)] = 58309, - [SMALL_STATE(861)] = 58329, - [SMALL_STATE(862)] = 58349, - [SMALL_STATE(863)] = 58369, - [SMALL_STATE(864)] = 58389, - [SMALL_STATE(865)] = 58409, - [SMALL_STATE(866)] = 58429, - [SMALL_STATE(867)] = 58449, - [SMALL_STATE(868)] = 58469, - [SMALL_STATE(869)] = 58489, - [SMALL_STATE(870)] = 58509, - [SMALL_STATE(871)] = 58529, - [SMALL_STATE(872)] = 58549, - [SMALL_STATE(873)] = 58569, - [SMALL_STATE(874)] = 58589, - [SMALL_STATE(875)] = 58609, - [SMALL_STATE(876)] = 58629, - [SMALL_STATE(877)] = 58649, - [SMALL_STATE(878)] = 58669, - [SMALL_STATE(879)] = 58689, - [SMALL_STATE(880)] = 58709, - [SMALL_STATE(881)] = 58729, - [SMALL_STATE(882)] = 58749, - [SMALL_STATE(883)] = 58769, - [SMALL_STATE(884)] = 58789, - [SMALL_STATE(885)] = 58809, - [SMALL_STATE(886)] = 58829, - [SMALL_STATE(887)] = 58849, - [SMALL_STATE(888)] = 58869, - [SMALL_STATE(889)] = 58889, - [SMALL_STATE(890)] = 58909, - [SMALL_STATE(891)] = 58929, - [SMALL_STATE(892)] = 58951, - [SMALL_STATE(893)] = 58971, - [SMALL_STATE(894)] = 58994, - [SMALL_STATE(895)] = 59017, - [SMALL_STATE(896)] = 59039, - [SMALL_STATE(897)] = 59061, - [SMALL_STATE(898)] = 59083, - [SMALL_STATE(899)] = 59105, - [SMALL_STATE(900)] = 59127, - [SMALL_STATE(901)] = 59149, - [SMALL_STATE(902)] = 59171, - [SMALL_STATE(903)] = 59193, - [SMALL_STATE(904)] = 59209, - [SMALL_STATE(905)] = 59231, - [SMALL_STATE(906)] = 59253, - [SMALL_STATE(907)] = 59275, - [SMALL_STATE(908)] = 59297, - [SMALL_STATE(909)] = 59319, - [SMALL_STATE(910)] = 59341, - [SMALL_STATE(911)] = 59363, - [SMALL_STATE(912)] = 59375, - [SMALL_STATE(913)] = 59397, - [SMALL_STATE(914)] = 59419, - [SMALL_STATE(915)] = 59441, - [SMALL_STATE(916)] = 59463, - [SMALL_STATE(917)] = 59485, - [SMALL_STATE(918)] = 59507, - [SMALL_STATE(919)] = 59529, - [SMALL_STATE(920)] = 59551, - [SMALL_STATE(921)] = 59573, - [SMALL_STATE(922)] = 59590, - [SMALL_STATE(923)] = 59609, - [SMALL_STATE(924)] = 59628, - [SMALL_STATE(925)] = 59647, - [SMALL_STATE(926)] = 59666, - [SMALL_STATE(927)] = 59683, - [SMALL_STATE(928)] = 59702, - [SMALL_STATE(929)] = 59721, - [SMALL_STATE(930)] = 59740, - [SMALL_STATE(931)] = 59757, - [SMALL_STATE(932)] = 59776, - [SMALL_STATE(933)] = 59793, - [SMALL_STATE(934)] = 59810, - [SMALL_STATE(935)] = 59827, - [SMALL_STATE(936)] = 59844, - [SMALL_STATE(937)] = 59863, - [SMALL_STATE(938)] = 59882, - [SMALL_STATE(939)] = 59901, - [SMALL_STATE(940)] = 59920, - [SMALL_STATE(941)] = 59939, - [SMALL_STATE(942)] = 59956, - [SMALL_STATE(943)] = 59975, - [SMALL_STATE(944)] = 59994, - [SMALL_STATE(945)] = 60013, - [SMALL_STATE(946)] = 60032, - [SMALL_STATE(947)] = 60049, - [SMALL_STATE(948)] = 60068, - [SMALL_STATE(949)] = 60087, - [SMALL_STATE(950)] = 60106, - [SMALL_STATE(951)] = 60123, - [SMALL_STATE(952)] = 60140, - [SMALL_STATE(953)] = 60157, - [SMALL_STATE(954)] = 60174, - [SMALL_STATE(955)] = 60193, - [SMALL_STATE(956)] = 60210, - [SMALL_STATE(957)] = 60229, - [SMALL_STATE(958)] = 60246, - [SMALL_STATE(959)] = 60263, - [SMALL_STATE(960)] = 60280, - [SMALL_STATE(961)] = 60299, - [SMALL_STATE(962)] = 60316, - [SMALL_STATE(963)] = 60333, - [SMALL_STATE(964)] = 60350, - [SMALL_STATE(965)] = 60367, - [SMALL_STATE(966)] = 60384, - [SMALL_STATE(967)] = 60403, - [SMALL_STATE(968)] = 60419, - [SMALL_STATE(969)] = 60433, - [SMALL_STATE(970)] = 60449, - [SMALL_STATE(971)] = 60465, - [SMALL_STATE(972)] = 60479, - [SMALL_STATE(973)] = 60489, - [SMALL_STATE(974)] = 60503, - [SMALL_STATE(975)] = 60517, - [SMALL_STATE(976)] = 60533, - [SMALL_STATE(977)] = 60549, - [SMALL_STATE(978)] = 60563, - [SMALL_STATE(979)] = 60573, - [SMALL_STATE(980)] = 60587, - [SMALL_STATE(981)] = 60601, - [SMALL_STATE(982)] = 60617, - [SMALL_STATE(983)] = 60633, - [SMALL_STATE(984)] = 60643, - [SMALL_STATE(985)] = 60653, - [SMALL_STATE(986)] = 60667, - [SMALL_STATE(987)] = 60681, - [SMALL_STATE(988)] = 60691, - [SMALL_STATE(989)] = 60705, - [SMALL_STATE(990)] = 60715, - [SMALL_STATE(991)] = 60725, - [SMALL_STATE(992)] = 60735, - [SMALL_STATE(993)] = 60745, - [SMALL_STATE(994)] = 60759, - [SMALL_STATE(995)] = 60773, - [SMALL_STATE(996)] = 60787, - [SMALL_STATE(997)] = 60797, - [SMALL_STATE(998)] = 60813, - [SMALL_STATE(999)] = 60829, - [SMALL_STATE(1000)] = 60845, - [SMALL_STATE(1001)] = 60859, - [SMALL_STATE(1002)] = 60873, - [SMALL_STATE(1003)] = 60889, - [SMALL_STATE(1004)] = 60905, - [SMALL_STATE(1005)] = 60915, - [SMALL_STATE(1006)] = 60931, - [SMALL_STATE(1007)] = 60945, - [SMALL_STATE(1008)] = 60961, - [SMALL_STATE(1009)] = 60975, - [SMALL_STATE(1010)] = 60991, - [SMALL_STATE(1011)] = 61007, - [SMALL_STATE(1012)] = 61021, - [SMALL_STATE(1013)] = 61035, - [SMALL_STATE(1014)] = 61051, - [SMALL_STATE(1015)] = 61063, - [SMALL_STATE(1016)] = 61079, - [SMALL_STATE(1017)] = 61095, - [SMALL_STATE(1018)] = 61111, - [SMALL_STATE(1019)] = 61127, - [SMALL_STATE(1020)] = 61141, - [SMALL_STATE(1021)] = 61157, - [SMALL_STATE(1022)] = 61171, - [SMALL_STATE(1023)] = 61185, - [SMALL_STATE(1024)] = 61199, - [SMALL_STATE(1025)] = 61213, - [SMALL_STATE(1026)] = 61229, - [SMALL_STATE(1027)] = 61245, - [SMALL_STATE(1028)] = 61259, - [SMALL_STATE(1029)] = 61269, - [SMALL_STATE(1030)] = 61285, - [SMALL_STATE(1031)] = 61299, - [SMALL_STATE(1032)] = 61309, - [SMALL_STATE(1033)] = 61323, - [SMALL_STATE(1034)] = 61337, - [SMALL_STATE(1035)] = 61347, - [SMALL_STATE(1036)] = 61361, - [SMALL_STATE(1037)] = 61375, - [SMALL_STATE(1038)] = 61389, - [SMALL_STATE(1039)] = 61402, - [SMALL_STATE(1040)] = 61415, - [SMALL_STATE(1041)] = 61428, - [SMALL_STATE(1042)] = 61441, - [SMALL_STATE(1043)] = 61454, - [SMALL_STATE(1044)] = 61467, - [SMALL_STATE(1045)] = 61480, - [SMALL_STATE(1046)] = 61493, - [SMALL_STATE(1047)] = 61506, - [SMALL_STATE(1048)] = 61519, - [SMALL_STATE(1049)] = 61532, - [SMALL_STATE(1050)] = 61545, - [SMALL_STATE(1051)] = 61558, - [SMALL_STATE(1052)] = 61571, - [SMALL_STATE(1053)] = 61584, - [SMALL_STATE(1054)] = 61597, - [SMALL_STATE(1055)] = 61610, - [SMALL_STATE(1056)] = 61623, - [SMALL_STATE(1057)] = 61636, - [SMALL_STATE(1058)] = 61649, - [SMALL_STATE(1059)] = 61662, - [SMALL_STATE(1060)] = 61675, - [SMALL_STATE(1061)] = 61688, - [SMALL_STATE(1062)] = 61701, - [SMALL_STATE(1063)] = 61714, - [SMALL_STATE(1064)] = 61727, - [SMALL_STATE(1065)] = 61738, - [SMALL_STATE(1066)] = 61751, - [SMALL_STATE(1067)] = 61764, - [SMALL_STATE(1068)] = 61777, - [SMALL_STATE(1069)] = 61790, - [SMALL_STATE(1070)] = 61803, - [SMALL_STATE(1071)] = 61816, - [SMALL_STATE(1072)] = 61829, - [SMALL_STATE(1073)] = 61842, - [SMALL_STATE(1074)] = 61855, - [SMALL_STATE(1075)] = 61868, - [SMALL_STATE(1076)] = 61881, - [SMALL_STATE(1077)] = 61894, - [SMALL_STATE(1078)] = 61907, - [SMALL_STATE(1079)] = 61920, - [SMALL_STATE(1080)] = 61933, - [SMALL_STATE(1081)] = 61946, - [SMALL_STATE(1082)] = 61959, - [SMALL_STATE(1083)] = 61972, - [SMALL_STATE(1084)] = 61985, - [SMALL_STATE(1085)] = 61998, - [SMALL_STATE(1086)] = 62011, - [SMALL_STATE(1087)] = 62024, - [SMALL_STATE(1088)] = 62037, - [SMALL_STATE(1089)] = 62050, - [SMALL_STATE(1090)] = 62063, - [SMALL_STATE(1091)] = 62076, - [SMALL_STATE(1092)] = 62089, - [SMALL_STATE(1093)] = 62102, - [SMALL_STATE(1094)] = 62113, - [SMALL_STATE(1095)] = 62126, - [SMALL_STATE(1096)] = 62139, - [SMALL_STATE(1097)] = 62150, - [SMALL_STATE(1098)] = 62163, - [SMALL_STATE(1099)] = 62172, - [SMALL_STATE(1100)] = 62185, - [SMALL_STATE(1101)] = 62198, - [SMALL_STATE(1102)] = 62211, - [SMALL_STATE(1103)] = 62224, - [SMALL_STATE(1104)] = 62237, - [SMALL_STATE(1105)] = 62250, - [SMALL_STATE(1106)] = 62263, - [SMALL_STATE(1107)] = 62276, - [SMALL_STATE(1108)] = 62289, - [SMALL_STATE(1109)] = 62302, - [SMALL_STATE(1110)] = 62315, - [SMALL_STATE(1111)] = 62328, - [SMALL_STATE(1112)] = 62341, - [SMALL_STATE(1113)] = 62354, - [SMALL_STATE(1114)] = 62367, - [SMALL_STATE(1115)] = 62380, - [SMALL_STATE(1116)] = 62389, - [SMALL_STATE(1117)] = 62398, - [SMALL_STATE(1118)] = 62411, - [SMALL_STATE(1119)] = 62424, - [SMALL_STATE(1120)] = 62437, - [SMALL_STATE(1121)] = 62450, - [SMALL_STATE(1122)] = 62463, - [SMALL_STATE(1123)] = 62476, - [SMALL_STATE(1124)] = 62489, - [SMALL_STATE(1125)] = 62502, - [SMALL_STATE(1126)] = 62513, - [SMALL_STATE(1127)] = 62526, - [SMALL_STATE(1128)] = 62539, - [SMALL_STATE(1129)] = 62552, - [SMALL_STATE(1130)] = 62565, - [SMALL_STATE(1131)] = 62578, - [SMALL_STATE(1132)] = 62591, - [SMALL_STATE(1133)] = 62604, - [SMALL_STATE(1134)] = 62617, - [SMALL_STATE(1135)] = 62630, - [SMALL_STATE(1136)] = 62643, - [SMALL_STATE(1137)] = 62656, - [SMALL_STATE(1138)] = 62669, - [SMALL_STATE(1139)] = 62682, - [SMALL_STATE(1140)] = 62695, - [SMALL_STATE(1141)] = 62708, - [SMALL_STATE(1142)] = 62721, - [SMALL_STATE(1143)] = 62732, - [SMALL_STATE(1144)] = 62745, - [SMALL_STATE(1145)] = 62758, - [SMALL_STATE(1146)] = 62771, - [SMALL_STATE(1147)] = 62784, - [SMALL_STATE(1148)] = 62797, - [SMALL_STATE(1149)] = 62810, - [SMALL_STATE(1150)] = 62818, - [SMALL_STATE(1151)] = 62828, - [SMALL_STATE(1152)] = 62838, - [SMALL_STATE(1153)] = 62848, - [SMALL_STATE(1154)] = 62856, - [SMALL_STATE(1155)] = 62866, - [SMALL_STATE(1156)] = 62876, - [SMALL_STATE(1157)] = 62886, - [SMALL_STATE(1158)] = 62896, - [SMALL_STATE(1159)] = 62904, - [SMALL_STATE(1160)] = 62914, - [SMALL_STATE(1161)] = 62924, - [SMALL_STATE(1162)] = 62934, - [SMALL_STATE(1163)] = 62944, - [SMALL_STATE(1164)] = 62954, - [SMALL_STATE(1165)] = 62964, - [SMALL_STATE(1166)] = 62974, - [SMALL_STATE(1167)] = 62984, - [SMALL_STATE(1168)] = 62994, - [SMALL_STATE(1169)] = 63004, - [SMALL_STATE(1170)] = 63012, - [SMALL_STATE(1171)] = 63022, - [SMALL_STATE(1172)] = 63032, - [SMALL_STATE(1173)] = 63040, - [SMALL_STATE(1174)] = 63050, - [SMALL_STATE(1175)] = 63060, - [SMALL_STATE(1176)] = 63070, - [SMALL_STATE(1177)] = 63080, - [SMALL_STATE(1178)] = 63090, - [SMALL_STATE(1179)] = 63100, - [SMALL_STATE(1180)] = 63110, - [SMALL_STATE(1181)] = 63120, - [SMALL_STATE(1182)] = 63130, - [SMALL_STATE(1183)] = 63138, - [SMALL_STATE(1184)] = 63148, - [SMALL_STATE(1185)] = 63158, - [SMALL_STATE(1186)] = 63168, - [SMALL_STATE(1187)] = 63178, - [SMALL_STATE(1188)] = 63186, - [SMALL_STATE(1189)] = 63194, - [SMALL_STATE(1190)] = 63202, - [SMALL_STATE(1191)] = 63212, - [SMALL_STATE(1192)] = 63222, - [SMALL_STATE(1193)] = 63232, - [SMALL_STATE(1194)] = 63240, - [SMALL_STATE(1195)] = 63248, - [SMALL_STATE(1196)] = 63258, - [SMALL_STATE(1197)] = 63266, - [SMALL_STATE(1198)] = 63274, - [SMALL_STATE(1199)] = 63284, - [SMALL_STATE(1200)] = 63292, - [SMALL_STATE(1201)] = 63302, - [SMALL_STATE(1202)] = 63310, - [SMALL_STATE(1203)] = 63320, - [SMALL_STATE(1204)] = 63330, - [SMALL_STATE(1205)] = 63338, - [SMALL_STATE(1206)] = 63348, - [SMALL_STATE(1207)] = 63358, - [SMALL_STATE(1208)] = 63368, - [SMALL_STATE(1209)] = 63378, - [SMALL_STATE(1210)] = 63388, - [SMALL_STATE(1211)] = 63398, - [SMALL_STATE(1212)] = 63405, - [SMALL_STATE(1213)] = 63412, - [SMALL_STATE(1214)] = 63419, - [SMALL_STATE(1215)] = 63426, - [SMALL_STATE(1216)] = 63433, - [SMALL_STATE(1217)] = 63440, - [SMALL_STATE(1218)] = 63447, - [SMALL_STATE(1219)] = 63454, - [SMALL_STATE(1220)] = 63461, - [SMALL_STATE(1221)] = 63468, - [SMALL_STATE(1222)] = 63475, - [SMALL_STATE(1223)] = 63482, - [SMALL_STATE(1224)] = 63489, - [SMALL_STATE(1225)] = 63496, - [SMALL_STATE(1226)] = 63503, - [SMALL_STATE(1227)] = 63510, - [SMALL_STATE(1228)] = 63517, - [SMALL_STATE(1229)] = 63524, - [SMALL_STATE(1230)] = 63531, - [SMALL_STATE(1231)] = 63538, - [SMALL_STATE(1232)] = 63545, - [SMALL_STATE(1233)] = 63552, - [SMALL_STATE(1234)] = 63559, - [SMALL_STATE(1235)] = 63566, - [SMALL_STATE(1236)] = 63573, - [SMALL_STATE(1237)] = 63580, - [SMALL_STATE(1238)] = 63587, - [SMALL_STATE(1239)] = 63594, - [SMALL_STATE(1240)] = 63601, - [SMALL_STATE(1241)] = 63608, - [SMALL_STATE(1242)] = 63615, - [SMALL_STATE(1243)] = 63622, - [SMALL_STATE(1244)] = 63629, - [SMALL_STATE(1245)] = 63636, - [SMALL_STATE(1246)] = 63643, - [SMALL_STATE(1247)] = 63650, - [SMALL_STATE(1248)] = 63657, - [SMALL_STATE(1249)] = 63664, - [SMALL_STATE(1250)] = 63671, - [SMALL_STATE(1251)] = 63678, - [SMALL_STATE(1252)] = 63685, - [SMALL_STATE(1253)] = 63692, - [SMALL_STATE(1254)] = 63699, - [SMALL_STATE(1255)] = 63706, - [SMALL_STATE(1256)] = 63713, - [SMALL_STATE(1257)] = 63720, - [SMALL_STATE(1258)] = 63727, - [SMALL_STATE(1259)] = 63734, - [SMALL_STATE(1260)] = 63741, - [SMALL_STATE(1261)] = 63748, - [SMALL_STATE(1262)] = 63755, - [SMALL_STATE(1263)] = 63762, - [SMALL_STATE(1264)] = 63769, - [SMALL_STATE(1265)] = 63776, - [SMALL_STATE(1266)] = 63783, - [SMALL_STATE(1267)] = 63790, - [SMALL_STATE(1268)] = 63797, - [SMALL_STATE(1269)] = 63804, - [SMALL_STATE(1270)] = 63811, - [SMALL_STATE(1271)] = 63818, - [SMALL_STATE(1272)] = 63825, - [SMALL_STATE(1273)] = 63832, - [SMALL_STATE(1274)] = 63839, - [SMALL_STATE(1275)] = 63846, - [SMALL_STATE(1276)] = 63853, - [SMALL_STATE(1277)] = 63860, - [SMALL_STATE(1278)] = 63867, - [SMALL_STATE(1279)] = 63874, - [SMALL_STATE(1280)] = 63881, - [SMALL_STATE(1281)] = 63888, - [SMALL_STATE(1282)] = 63895, - [SMALL_STATE(1283)] = 63902, - [SMALL_STATE(1284)] = 63909, - [SMALL_STATE(1285)] = 63916, - [SMALL_STATE(1286)] = 63923, - [SMALL_STATE(1287)] = 63930, - [SMALL_STATE(1288)] = 63937, - [SMALL_STATE(1289)] = 63944, - [SMALL_STATE(1290)] = 63951, - [SMALL_STATE(1291)] = 63958, - [SMALL_STATE(1292)] = 63965, - [SMALL_STATE(1293)] = 63972, - [SMALL_STATE(1294)] = 63979, - [SMALL_STATE(1295)] = 63986, - [SMALL_STATE(1296)] = 63993, - [SMALL_STATE(1297)] = 64000, - [SMALL_STATE(1298)] = 64007, - [SMALL_STATE(1299)] = 64014, - [SMALL_STATE(1300)] = 64021, - [SMALL_STATE(1301)] = 64028, - [SMALL_STATE(1302)] = 64035, - [SMALL_STATE(1303)] = 64042, - [SMALL_STATE(1304)] = 64049, - [SMALL_STATE(1305)] = 64056, - [SMALL_STATE(1306)] = 64063, - [SMALL_STATE(1307)] = 64070, - [SMALL_STATE(1308)] = 64077, - [SMALL_STATE(1309)] = 64084, - [SMALL_STATE(1310)] = 64091, - [SMALL_STATE(1311)] = 64098, - [SMALL_STATE(1312)] = 64105, - [SMALL_STATE(1313)] = 64112, - [SMALL_STATE(1314)] = 64119, - [SMALL_STATE(1315)] = 64126, - [SMALL_STATE(1316)] = 64133, - [SMALL_STATE(1317)] = 64140, - [SMALL_STATE(1318)] = 64147, - [SMALL_STATE(1319)] = 64154, - [SMALL_STATE(1320)] = 64161, - [SMALL_STATE(1321)] = 64168, - [SMALL_STATE(1322)] = 64175, - [SMALL_STATE(1323)] = 64182, - [SMALL_STATE(1324)] = 64189, - [SMALL_STATE(1325)] = 64196, - [SMALL_STATE(1326)] = 64203, - [SMALL_STATE(1327)] = 64210, - [SMALL_STATE(1328)] = 64217, - [SMALL_STATE(1329)] = 64224, - [SMALL_STATE(1330)] = 64231, - [SMALL_STATE(1331)] = 64238, - [SMALL_STATE(1332)] = 64245, - [SMALL_STATE(1333)] = 64252, - [SMALL_STATE(1334)] = 64259, - [SMALL_STATE(1335)] = 64266, - [SMALL_STATE(1336)] = 64273, - [SMALL_STATE(1337)] = 64280, - [SMALL_STATE(1338)] = 64287, - [SMALL_STATE(1339)] = 64294, - [SMALL_STATE(1340)] = 64301, - [SMALL_STATE(1341)] = 64308, - [SMALL_STATE(1342)] = 64315, - [SMALL_STATE(1343)] = 64322, - [SMALL_STATE(1344)] = 64329, - [SMALL_STATE(1345)] = 64336, - [SMALL_STATE(1346)] = 64343, - [SMALL_STATE(1347)] = 64350, - [SMALL_STATE(1348)] = 64357, - [SMALL_STATE(1349)] = 64364, - [SMALL_STATE(1350)] = 64371, - [SMALL_STATE(1351)] = 64378, - [SMALL_STATE(1352)] = 64385, - [SMALL_STATE(1353)] = 64392, - [SMALL_STATE(1354)] = 64399, - [SMALL_STATE(1355)] = 64406, - [SMALL_STATE(1356)] = 64413, - [SMALL_STATE(1357)] = 64420, - [SMALL_STATE(1358)] = 64427, - [SMALL_STATE(1359)] = 64434, - [SMALL_STATE(1360)] = 64441, - [SMALL_STATE(1361)] = 64448, - [SMALL_STATE(1362)] = 64455, - [SMALL_STATE(1363)] = 64462, - [SMALL_STATE(1364)] = 64469, - [SMALL_STATE(1365)] = 64476, - [SMALL_STATE(1366)] = 64483, - [SMALL_STATE(1367)] = 64490, - [SMALL_STATE(1368)] = 64497, - [SMALL_STATE(1369)] = 64504, - [SMALL_STATE(1370)] = 64511, - [SMALL_STATE(1371)] = 64518, - [SMALL_STATE(1372)] = 64525, - [SMALL_STATE(1373)] = 64532, - [SMALL_STATE(1374)] = 64539, - [SMALL_STATE(1375)] = 64546, - [SMALL_STATE(1376)] = 64553, - [SMALL_STATE(1377)] = 64560, - [SMALL_STATE(1378)] = 64567, - [SMALL_STATE(1379)] = 64574, - [SMALL_STATE(1380)] = 64581, - [SMALL_STATE(1381)] = 64588, - [SMALL_STATE(1382)] = 64595, - [SMALL_STATE(1383)] = 64602, - [SMALL_STATE(1384)] = 64609, - [SMALL_STATE(1385)] = 64616, - [SMALL_STATE(1386)] = 64623, - [SMALL_STATE(1387)] = 64630, - [SMALL_STATE(1388)] = 64637, - [SMALL_STATE(1389)] = 64644, - [SMALL_STATE(1390)] = 64651, - [SMALL_STATE(1391)] = 64658, - [SMALL_STATE(1392)] = 64665, - [SMALL_STATE(1393)] = 64672, - [SMALL_STATE(1394)] = 64679, - [SMALL_STATE(1395)] = 64686, - [SMALL_STATE(1396)] = 64693, - [SMALL_STATE(1397)] = 64700, - [SMALL_STATE(1398)] = 64707, - [SMALL_STATE(1399)] = 64714, - [SMALL_STATE(1400)] = 64721, - [SMALL_STATE(1401)] = 64728, - [SMALL_STATE(1402)] = 64735, - [SMALL_STATE(1403)] = 64742, - [SMALL_STATE(1404)] = 64749, - [SMALL_STATE(1405)] = 64756, - [SMALL_STATE(1406)] = 64763, - [SMALL_STATE(1407)] = 64770, - [SMALL_STATE(1408)] = 64777, - [SMALL_STATE(1409)] = 64784, - [SMALL_STATE(1410)] = 64791, - [SMALL_STATE(1411)] = 64798, - [SMALL_STATE(1412)] = 64805, - [SMALL_STATE(1413)] = 64812, - [SMALL_STATE(1414)] = 64819, - [SMALL_STATE(1415)] = 64826, - [SMALL_STATE(1416)] = 64833, - [SMALL_STATE(1417)] = 64840, - [SMALL_STATE(1418)] = 64847, - [SMALL_STATE(1419)] = 64854, - [SMALL_STATE(1420)] = 64861, - [SMALL_STATE(1421)] = 64868, - [SMALL_STATE(1422)] = 64875, - [SMALL_STATE(1423)] = 64882, - [SMALL_STATE(1424)] = 64889, - [SMALL_STATE(1425)] = 64896, - [SMALL_STATE(1426)] = 64903, - [SMALL_STATE(1427)] = 64910, - [SMALL_STATE(1428)] = 64917, - [SMALL_STATE(1429)] = 64924, - [SMALL_STATE(1430)] = 64931, - [SMALL_STATE(1431)] = 64938, - [SMALL_STATE(1432)] = 64945, - [SMALL_STATE(1433)] = 64952, - [SMALL_STATE(1434)] = 64959, - [SMALL_STATE(1435)] = 64966, - [SMALL_STATE(1436)] = 64973, - [SMALL_STATE(1437)] = 64980, - [SMALL_STATE(1438)] = 64987, - [SMALL_STATE(1439)] = 64994, - [SMALL_STATE(1440)] = 65001, - [SMALL_STATE(1441)] = 65008, + [SMALL_STATE(24)] = 0, + [SMALL_STATE(25)] = 70, + [SMALL_STATE(26)] = 192, + [SMALL_STATE(27)] = 314, + [SMALL_STATE(28)] = 394, + [SMALL_STATE(29)] = 516, + [SMALL_STATE(30)] = 638, + [SMALL_STATE(31)] = 708, + [SMALL_STATE(32)] = 830, + [SMALL_STATE(33)] = 906, + [SMALL_STATE(34)] = 1028, + [SMALL_STATE(35)] = 1105, + [SMALL_STATE(36)] = 1182, + [SMALL_STATE(37)] = 1247, + [SMALL_STATE(38)] = 1322, + [SMALL_STATE(39)] = 1390, + [SMALL_STATE(40)] = 1460, + [SMALL_STATE(41)] = 1528, + [SMALL_STATE(42)] = 1591, + [SMALL_STATE(43)] = 1654, + [SMALL_STATE(44)] = 1717, + [SMALL_STATE(45)] = 1780, + [SMALL_STATE(46)] = 1843, + [SMALL_STATE(47)] = 1906, + [SMALL_STATE(48)] = 2019, + [SMALL_STATE(49)] = 2082, + [SMALL_STATE(50)] = 2145, + [SMALL_STATE(51)] = 2208, + [SMALL_STATE(52)] = 2271, + [SMALL_STATE(53)] = 2334, + [SMALL_STATE(54)] = 2397, + [SMALL_STATE(55)] = 2460, + [SMALL_STATE(56)] = 2523, + [SMALL_STATE(57)] = 2586, + [SMALL_STATE(58)] = 2655, + [SMALL_STATE(59)] = 2718, + [SMALL_STATE(60)] = 2831, + [SMALL_STATE(61)] = 2894, + [SMALL_STATE(62)] = 2957, + [SMALL_STATE(63)] = 3020, + [SMALL_STATE(64)] = 3083, + [SMALL_STATE(65)] = 3146, + [SMALL_STATE(66)] = 3259, + [SMALL_STATE(67)] = 3322, + [SMALL_STATE(68)] = 3435, + [SMALL_STATE(69)] = 3498, + [SMALL_STATE(70)] = 3611, + [SMALL_STATE(71)] = 3724, + [SMALL_STATE(72)] = 3837, + [SMALL_STATE(73)] = 3900, + [SMALL_STATE(74)] = 3963, + [SMALL_STATE(75)] = 4032, + [SMALL_STATE(76)] = 4095, + [SMALL_STATE(77)] = 4158, + [SMALL_STATE(78)] = 4271, + [SMALL_STATE(79)] = 4334, + [SMALL_STATE(80)] = 4397, + [SMALL_STATE(81)] = 4510, + [SMALL_STATE(82)] = 4573, + [SMALL_STATE(83)] = 4686, + [SMALL_STATE(84)] = 4749, + [SMALL_STATE(85)] = 4812, + [SMALL_STATE(86)] = 4875, + [SMALL_STATE(87)] = 4988, + [SMALL_STATE(88)] = 5051, + [SMALL_STATE(89)] = 5164, + [SMALL_STATE(90)] = 5277, + [SMALL_STATE(91)] = 5390, + [SMALL_STATE(92)] = 5500, + [SMALL_STATE(93)] = 5610, + [SMALL_STATE(94)] = 5720, + [SMALL_STATE(95)] = 5830, + [SMALL_STATE(96)] = 5940, + [SMALL_STATE(97)] = 6050, + [SMALL_STATE(98)] = 6160, + [SMALL_STATE(99)] = 6270, + [SMALL_STATE(100)] = 6380, + [SMALL_STATE(101)] = 6490, + [SMALL_STATE(102)] = 6600, + [SMALL_STATE(103)] = 6710, + [SMALL_STATE(104)] = 6820, + [SMALL_STATE(105)] = 6930, + [SMALL_STATE(106)] = 7040, + [SMALL_STATE(107)] = 7150, + [SMALL_STATE(108)] = 7260, + [SMALL_STATE(109)] = 7370, + [SMALL_STATE(110)] = 7480, + [SMALL_STATE(111)] = 7590, + [SMALL_STATE(112)] = 7700, + [SMALL_STATE(113)] = 7810, + [SMALL_STATE(114)] = 7920, + [SMALL_STATE(115)] = 8030, + [SMALL_STATE(116)] = 8140, + [SMALL_STATE(117)] = 8250, + [SMALL_STATE(118)] = 8360, + [SMALL_STATE(119)] = 8470, + [SMALL_STATE(120)] = 8580, + [SMALL_STATE(121)] = 8690, + [SMALL_STATE(122)] = 8800, + [SMALL_STATE(123)] = 8910, + [SMALL_STATE(124)] = 9020, + [SMALL_STATE(125)] = 9112, + [SMALL_STATE(126)] = 9222, + [SMALL_STATE(127)] = 9332, + [SMALL_STATE(128)] = 9442, + [SMALL_STATE(129)] = 9552, + [SMALL_STATE(130)] = 9662, + [SMALL_STATE(131)] = 9772, + [SMALL_STATE(132)] = 9884, + [SMALL_STATE(133)] = 9994, + [SMALL_STATE(134)] = 10104, + [SMALL_STATE(135)] = 10214, + [SMALL_STATE(136)] = 10324, + [SMALL_STATE(137)] = 10434, + [SMALL_STATE(138)] = 10544, + [SMALL_STATE(139)] = 10654, + [SMALL_STATE(140)] = 10764, + [SMALL_STATE(141)] = 10874, + [SMALL_STATE(142)] = 10984, + [SMALL_STATE(143)] = 11094, + [SMALL_STATE(144)] = 11204, + [SMALL_STATE(145)] = 11314, + [SMALL_STATE(146)] = 11424, + [SMALL_STATE(147)] = 11534, + [SMALL_STATE(148)] = 11644, + [SMALL_STATE(149)] = 11754, + [SMALL_STATE(150)] = 11864, + [SMALL_STATE(151)] = 11974, + [SMALL_STATE(152)] = 12084, + [SMALL_STATE(153)] = 12194, + [SMALL_STATE(154)] = 12304, + [SMALL_STATE(155)] = 12366, + [SMALL_STATE(156)] = 12428, + [SMALL_STATE(157)] = 12490, + [SMALL_STATE(158)] = 12552, + [SMALL_STATE(159)] = 12662, + [SMALL_STATE(160)] = 12724, + [SMALL_STATE(161)] = 12834, + [SMALL_STATE(162)] = 12904, + [SMALL_STATE(163)] = 12966, + [SMALL_STATE(164)] = 13054, + [SMALL_STATE(165)] = 13142, + [SMALL_STATE(166)] = 13252, + [SMALL_STATE(167)] = 13362, + [SMALL_STATE(168)] = 13472, + [SMALL_STATE(169)] = 13582, + [SMALL_STATE(170)] = 13692, + [SMALL_STATE(171)] = 13802, + [SMALL_STATE(172)] = 13912, + [SMALL_STATE(173)] = 14022, + [SMALL_STATE(174)] = 14132, + [SMALL_STATE(175)] = 14194, + [SMALL_STATE(176)] = 14256, + [SMALL_STATE(177)] = 14318, + [SMALL_STATE(178)] = 14428, + [SMALL_STATE(179)] = 14490, + [SMALL_STATE(180)] = 14600, + [SMALL_STATE(181)] = 14662, + [SMALL_STATE(182)] = 14724, + [SMALL_STATE(183)] = 14786, + [SMALL_STATE(184)] = 14856, + [SMALL_STATE(185)] = 14932, + [SMALL_STATE(186)] = 14994, + [SMALL_STATE(187)] = 15104, + [SMALL_STATE(188)] = 15186, + [SMALL_STATE(189)] = 15266, + [SMALL_STATE(190)] = 15340, + [SMALL_STATE(191)] = 15408, + [SMALL_STATE(192)] = 15470, + [SMALL_STATE(193)] = 15532, + [SMALL_STATE(194)] = 15642, + [SMALL_STATE(195)] = 15730, + [SMALL_STATE(196)] = 15792, + [SMALL_STATE(197)] = 15854, + [SMALL_STATE(198)] = 15964, + [SMALL_STATE(199)] = 16026, + [SMALL_STATE(200)] = 16136, + [SMALL_STATE(201)] = 16198, + [SMALL_STATE(202)] = 16260, + [SMALL_STATE(203)] = 16322, + [SMALL_STATE(204)] = 16384, + [SMALL_STATE(205)] = 16472, + [SMALL_STATE(206)] = 16582, + [SMALL_STATE(207)] = 16644, + [SMALL_STATE(208)] = 16706, + [SMALL_STATE(209)] = 16816, + [SMALL_STATE(210)] = 16926, + [SMALL_STATE(211)] = 17014, + [SMALL_STATE(212)] = 17124, + [SMALL_STATE(213)] = 17234, + [SMALL_STATE(214)] = 17296, + [SMALL_STATE(215)] = 17384, + [SMALL_STATE(216)] = 17446, + [SMALL_STATE(217)] = 17534, + [SMALL_STATE(218)] = 17644, + [SMALL_STATE(219)] = 17732, + [SMALL_STATE(220)] = 17842, + [SMALL_STATE(221)] = 17952, + [SMALL_STATE(222)] = 18014, + [SMALL_STATE(223)] = 18076, + [SMALL_STATE(224)] = 18186, + [SMALL_STATE(225)] = 18296, + [SMALL_STATE(226)] = 18384, + [SMALL_STATE(227)] = 18494, + [SMALL_STATE(228)] = 18604, + [SMALL_STATE(229)] = 18714, + [SMALL_STATE(230)] = 18776, + [SMALL_STATE(231)] = 18838, + [SMALL_STATE(232)] = 18948, + [SMALL_STATE(233)] = 19058, + [SMALL_STATE(234)] = 19168, + [SMALL_STATE(235)] = 19256, + [SMALL_STATE(236)] = 19366, + [SMALL_STATE(237)] = 19476, + [SMALL_STATE(238)] = 19586, + [SMALL_STATE(239)] = 19674, + [SMALL_STATE(240)] = 19784, + [SMALL_STATE(241)] = 19894, + [SMALL_STATE(242)] = 20004, + [SMALL_STATE(243)] = 20114, + [SMALL_STATE(244)] = 20224, + [SMALL_STATE(245)] = 20286, + [SMALL_STATE(246)] = 20396, + [SMALL_STATE(247)] = 20506, + [SMALL_STATE(248)] = 20616, + [SMALL_STATE(249)] = 20726, + [SMALL_STATE(250)] = 20836, + [SMALL_STATE(251)] = 20946, + [SMALL_STATE(252)] = 21056, + [SMALL_STATE(253)] = 21166, + [SMALL_STATE(254)] = 21276, + [SMALL_STATE(255)] = 21386, + [SMALL_STATE(256)] = 21496, + [SMALL_STATE(257)] = 21606, + [SMALL_STATE(258)] = 21716, + [SMALL_STATE(259)] = 21826, + [SMALL_STATE(260)] = 21936, + [SMALL_STATE(261)] = 22046, + [SMALL_STATE(262)] = 22156, + [SMALL_STATE(263)] = 22266, + [SMALL_STATE(264)] = 22376, + [SMALL_STATE(265)] = 22486, + [SMALL_STATE(266)] = 22596, + [SMALL_STATE(267)] = 22706, + [SMALL_STATE(268)] = 22816, + [SMALL_STATE(269)] = 22926, + [SMALL_STATE(270)] = 23036, + [SMALL_STATE(271)] = 23146, + [SMALL_STATE(272)] = 23256, + [SMALL_STATE(273)] = 23366, + [SMALL_STATE(274)] = 23476, + [SMALL_STATE(275)] = 23586, + [SMALL_STATE(276)] = 23696, + [SMALL_STATE(277)] = 23806, + [SMALL_STATE(278)] = 23916, + [SMALL_STATE(279)] = 24026, + [SMALL_STATE(280)] = 24136, + [SMALL_STATE(281)] = 24246, + [SMALL_STATE(282)] = 24356, + [SMALL_STATE(283)] = 24466, + [SMALL_STATE(284)] = 24576, + [SMALL_STATE(285)] = 24686, + [SMALL_STATE(286)] = 24796, + [SMALL_STATE(287)] = 24906, + [SMALL_STATE(288)] = 25016, + [SMALL_STATE(289)] = 25126, + [SMALL_STATE(290)] = 25236, + [SMALL_STATE(291)] = 25346, + [SMALL_STATE(292)] = 25456, + [SMALL_STATE(293)] = 25566, + [SMALL_STATE(294)] = 25676, + [SMALL_STATE(295)] = 25786, + [SMALL_STATE(296)] = 25896, + [SMALL_STATE(297)] = 26006, + [SMALL_STATE(298)] = 26116, + [SMALL_STATE(299)] = 26226, + [SMALL_STATE(300)] = 26336, + [SMALL_STATE(301)] = 26446, + [SMALL_STATE(302)] = 26556, + [SMALL_STATE(303)] = 26666, + [SMALL_STATE(304)] = 26776, + [SMALL_STATE(305)] = 26886, + [SMALL_STATE(306)] = 26996, + [SMALL_STATE(307)] = 27106, + [SMALL_STATE(308)] = 27216, + [SMALL_STATE(309)] = 27326, + [SMALL_STATE(310)] = 27436, + [SMALL_STATE(311)] = 27546, + [SMALL_STATE(312)] = 27656, + [SMALL_STATE(313)] = 27766, + [SMALL_STATE(314)] = 27876, + [SMALL_STATE(315)] = 27986, + [SMALL_STATE(316)] = 28096, + [SMALL_STATE(317)] = 28206, + [SMALL_STATE(318)] = 28316, + [SMALL_STATE(319)] = 28426, + [SMALL_STATE(320)] = 28536, + [SMALL_STATE(321)] = 28646, + [SMALL_STATE(322)] = 28756, + [SMALL_STATE(323)] = 28866, + [SMALL_STATE(324)] = 28976, + [SMALL_STATE(325)] = 29086, + [SMALL_STATE(326)] = 29196, + [SMALL_STATE(327)] = 29306, + [SMALL_STATE(328)] = 29416, + [SMALL_STATE(329)] = 29526, + [SMALL_STATE(330)] = 29636, + [SMALL_STATE(331)] = 29746, + [SMALL_STATE(332)] = 29856, + [SMALL_STATE(333)] = 29948, + [SMALL_STATE(334)] = 30058, + [SMALL_STATE(335)] = 30168, + [SMALL_STATE(336)] = 30278, + [SMALL_STATE(337)] = 30388, + [SMALL_STATE(338)] = 30498, + [SMALL_STATE(339)] = 30608, + [SMALL_STATE(340)] = 30700, + [SMALL_STATE(341)] = 30810, + [SMALL_STATE(342)] = 30920, + [SMALL_STATE(343)] = 31030, + [SMALL_STATE(344)] = 31140, + [SMALL_STATE(345)] = 31250, + [SMALL_STATE(346)] = 31360, + [SMALL_STATE(347)] = 31470, + [SMALL_STATE(348)] = 31580, + [SMALL_STATE(349)] = 31690, + [SMALL_STATE(350)] = 31800, + [SMALL_STATE(351)] = 31910, + [SMALL_STATE(352)] = 32020, + [SMALL_STATE(353)] = 32130, + [SMALL_STATE(354)] = 32240, + [SMALL_STATE(355)] = 32350, + [SMALL_STATE(356)] = 32460, + [SMALL_STATE(357)] = 32570, + [SMALL_STATE(358)] = 32680, + [SMALL_STATE(359)] = 32790, + [SMALL_STATE(360)] = 32900, + [SMALL_STATE(361)] = 33010, + [SMALL_STATE(362)] = 33120, + [SMALL_STATE(363)] = 33230, + [SMALL_STATE(364)] = 33340, + [SMALL_STATE(365)] = 33450, + [SMALL_STATE(366)] = 33560, + [SMALL_STATE(367)] = 33622, + [SMALL_STATE(368)] = 33709, + [SMALL_STATE(369)] = 33796, + [SMALL_STATE(370)] = 33883, + [SMALL_STATE(371)] = 33970, + [SMALL_STATE(372)] = 34059, + [SMALL_STATE(373)] = 34146, + [SMALL_STATE(374)] = 34233, + [SMALL_STATE(375)] = 34320, + [SMALL_STATE(376)] = 34407, + [SMALL_STATE(377)] = 34494, + [SMALL_STATE(378)] = 34581, + [SMALL_STATE(379)] = 34668, + [SMALL_STATE(380)] = 34755, + [SMALL_STATE(381)] = 34842, + [SMALL_STATE(382)] = 34929, + [SMALL_STATE(383)] = 35016, + [SMALL_STATE(384)] = 35103, + [SMALL_STATE(385)] = 35190, + [SMALL_STATE(386)] = 35277, + [SMALL_STATE(387)] = 35364, + [SMALL_STATE(388)] = 35451, + [SMALL_STATE(389)] = 35538, + [SMALL_STATE(390)] = 35625, + [SMALL_STATE(391)] = 35712, + [SMALL_STATE(392)] = 35799, + [SMALL_STATE(393)] = 35886, + [SMALL_STATE(394)] = 35973, + [SMALL_STATE(395)] = 36060, + [SMALL_STATE(396)] = 36147, + [SMALL_STATE(397)] = 36234, + [SMALL_STATE(398)] = 36321, + [SMALL_STATE(399)] = 36408, + [SMALL_STATE(400)] = 36495, + [SMALL_STATE(401)] = 36582, + [SMALL_STATE(402)] = 36669, + [SMALL_STATE(403)] = 36756, + [SMALL_STATE(404)] = 36843, + [SMALL_STATE(405)] = 36932, + [SMALL_STATE(406)] = 37019, + [SMALL_STATE(407)] = 37106, + [SMALL_STATE(408)] = 37193, + [SMALL_STATE(409)] = 37280, + [SMALL_STATE(410)] = 37367, + [SMALL_STATE(411)] = 37454, + [SMALL_STATE(412)] = 37541, + [SMALL_STATE(413)] = 37628, + [SMALL_STATE(414)] = 37715, + [SMALL_STATE(415)] = 37802, + [SMALL_STATE(416)] = 37889, + [SMALL_STATE(417)] = 37976, + [SMALL_STATE(418)] = 38063, + [SMALL_STATE(419)] = 38150, + [SMALL_STATE(420)] = 38237, + [SMALL_STATE(421)] = 38324, + [SMALL_STATE(422)] = 38411, + [SMALL_STATE(423)] = 38498, + [SMALL_STATE(424)] = 38585, + [SMALL_STATE(425)] = 38672, + [SMALL_STATE(426)] = 38759, + [SMALL_STATE(427)] = 38846, + [SMALL_STATE(428)] = 38933, + [SMALL_STATE(429)] = 39020, + [SMALL_STATE(430)] = 39107, + [SMALL_STATE(431)] = 39194, + [SMALL_STATE(432)] = 39281, + [SMALL_STATE(433)] = 39368, + [SMALL_STATE(434)] = 39455, + [SMALL_STATE(435)] = 39542, + [SMALL_STATE(436)] = 39629, + [SMALL_STATE(437)] = 39716, + [SMALL_STATE(438)] = 39785, + [SMALL_STATE(439)] = 39872, + [SMALL_STATE(440)] = 39959, + [SMALL_STATE(441)] = 40046, + [SMALL_STATE(442)] = 40133, + [SMALL_STATE(443)] = 40220, + [SMALL_STATE(444)] = 40307, + [SMALL_STATE(445)] = 40394, + [SMALL_STATE(446)] = 40463, + [SMALL_STATE(447)] = 40552, + [SMALL_STATE(448)] = 40627, + [SMALL_STATE(449)] = 40714, + [SMALL_STATE(450)] = 40801, + [SMALL_STATE(451)] = 40888, + [SMALL_STATE(452)] = 40969, + [SMALL_STATE(453)] = 41048, + [SMALL_STATE(454)] = 41137, + [SMALL_STATE(455)] = 41210, + [SMALL_STATE(456)] = 41299, + [SMALL_STATE(457)] = 41386, + [SMALL_STATE(458)] = 41475, + [SMALL_STATE(459)] = 41562, + [SMALL_STATE(460)] = 41651, + [SMALL_STATE(461)] = 41740, + [SMALL_STATE(462)] = 41827, + [SMALL_STATE(463)] = 41914, + [SMALL_STATE(464)] = 42001, + [SMALL_STATE(465)] = 42088, + [SMALL_STATE(466)] = 42175, + [SMALL_STATE(467)] = 42262, + [SMALL_STATE(468)] = 42349, + [SMALL_STATE(469)] = 42406, + [SMALL_STATE(470)] = 42463, + [SMALL_STATE(471)] = 42515, + [SMALL_STATE(472)] = 42572, + [SMALL_STATE(473)] = 42622, + [SMALL_STATE(474)] = 42680, + [SMALL_STATE(475)] = 42730, + [SMALL_STATE(476)] = 42780, + [SMALL_STATE(477)] = 42830, + [SMALL_STATE(478)] = 42884, + [SMALL_STATE(479)] = 42938, + [SMALL_STATE(480)] = 42992, + [SMALL_STATE(481)] = 43046, + [SMALL_STATE(482)] = 43100, + [SMALL_STATE(483)] = 43154, + [SMALL_STATE(484)] = 43212, + [SMALL_STATE(485)] = 43266, + [SMALL_STATE(486)] = 43324, + [SMALL_STATE(487)] = 43378, + [SMALL_STATE(488)] = 43432, + [SMALL_STATE(489)] = 43482, + [SMALL_STATE(490)] = 43540, + [SMALL_STATE(491)] = 43594, + [SMALL_STATE(492)] = 43648, + [SMALL_STATE(493)] = 43701, + [SMALL_STATE(494)] = 43750, + [SMALL_STATE(495)] = 43803, + [SMALL_STATE(496)] = 43856, + [SMALL_STATE(497)] = 43905, + [SMALL_STATE(498)] = 43958, + [SMALL_STATE(499)] = 44007, + [SMALL_STATE(500)] = 44056, + [SMALL_STATE(501)] = 44109, + [SMALL_STATE(502)] = 44158, + [SMALL_STATE(503)] = 44213, + [SMALL_STATE(504)] = 44262, + [SMALL_STATE(505)] = 44311, + [SMALL_STATE(506)] = 44360, + [SMALL_STATE(507)] = 44415, + [SMALL_STATE(508)] = 44464, + [SMALL_STATE(509)] = 44519, + [SMALL_STATE(510)] = 44572, + [SMALL_STATE(511)] = 44623, + [SMALL_STATE(512)] = 44672, + [SMALL_STATE(513)] = 44721, + [SMALL_STATE(514)] = 44770, + [SMALL_STATE(515)] = 44819, + [SMALL_STATE(516)] = 44867, + [SMALL_STATE(517)] = 44915, + [SMALL_STATE(518)] = 44963, + [SMALL_STATE(519)] = 45011, + [SMALL_STATE(520)] = 45059, + [SMALL_STATE(521)] = 45107, + [SMALL_STATE(522)] = 45159, + [SMALL_STATE(523)] = 45207, + [SMALL_STATE(524)] = 45255, + [SMALL_STATE(525)] = 45303, + [SMALL_STATE(526)] = 45351, + [SMALL_STATE(527)] = 45399, + [SMALL_STATE(528)] = 45447, + [SMALL_STATE(529)] = 45499, + [SMALL_STATE(530)] = 45547, + [SMALL_STATE(531)] = 45595, + [SMALL_STATE(532)] = 45647, + [SMALL_STATE(533)] = 45695, + [SMALL_STATE(534)] = 45743, + [SMALL_STATE(535)] = 45791, + [SMALL_STATE(536)] = 45839, + [SMALL_STATE(537)] = 45891, + [SMALL_STATE(538)] = 45939, + [SMALL_STATE(539)] = 45991, + [SMALL_STATE(540)] = 46039, + [SMALL_STATE(541)] = 46091, + [SMALL_STATE(542)] = 46143, + [SMALL_STATE(543)] = 46191, + [SMALL_STATE(544)] = 46239, + [SMALL_STATE(545)] = 46287, + [SMALL_STATE(546)] = 46335, + [SMALL_STATE(547)] = 46383, + [SMALL_STATE(548)] = 46431, + [SMALL_STATE(549)] = 46479, + [SMALL_STATE(550)] = 46527, + [SMALL_STATE(551)] = 46575, + [SMALL_STATE(552)] = 46627, + [SMALL_STATE(553)] = 46675, + [SMALL_STATE(554)] = 46723, + [SMALL_STATE(555)] = 46771, + [SMALL_STATE(556)] = 46819, + [SMALL_STATE(557)] = 46867, + [SMALL_STATE(558)] = 46915, + [SMALL_STATE(559)] = 46963, + [SMALL_STATE(560)] = 47011, + [SMALL_STATE(561)] = 47059, + [SMALL_STATE(562)] = 47111, + [SMALL_STATE(563)] = 47159, + [SMALL_STATE(564)] = 47207, + [SMALL_STATE(565)] = 47255, + [SMALL_STATE(566)] = 47307, + [SMALL_STATE(567)] = 47355, + [SMALL_STATE(568)] = 47403, + [SMALL_STATE(569)] = 47451, + [SMALL_STATE(570)] = 47499, + [SMALL_STATE(571)] = 47551, + [SMALL_STATE(572)] = 47599, + [SMALL_STATE(573)] = 47647, + [SMALL_STATE(574)] = 47695, + [SMALL_STATE(575)] = 47743, + [SMALL_STATE(576)] = 47791, + [SMALL_STATE(577)] = 47843, + [SMALL_STATE(578)] = 47895, + [SMALL_STATE(579)] = 47947, + [SMALL_STATE(580)] = 47999, + [SMALL_STATE(581)] = 48047, + [SMALL_STATE(582)] = 48095, + [SMALL_STATE(583)] = 48143, + [SMALL_STATE(584)] = 48191, + [SMALL_STATE(585)] = 48239, + [SMALL_STATE(586)] = 48287, + [SMALL_STATE(587)] = 48335, + [SMALL_STATE(588)] = 48383, + [SMALL_STATE(589)] = 48431, + [SMALL_STATE(590)] = 48479, + [SMALL_STATE(591)] = 48527, + [SMALL_STATE(592)] = 48575, + [SMALL_STATE(593)] = 48623, + [SMALL_STATE(594)] = 48671, + [SMALL_STATE(595)] = 48719, + [SMALL_STATE(596)] = 48767, + [SMALL_STATE(597)] = 48814, + [SMALL_STATE(598)] = 48861, + [SMALL_STATE(599)] = 48910, + [SMALL_STATE(600)] = 48959, + [SMALL_STATE(601)] = 49006, + [SMALL_STATE(602)] = 49055, + [SMALL_STATE(603)] = 49104, + [SMALL_STATE(604)] = 49151, + [SMALL_STATE(605)] = 49198, + [SMALL_STATE(606)] = 49245, + [SMALL_STATE(607)] = 49294, + [SMALL_STATE(608)] = 49341, + [SMALL_STATE(609)] = 49388, + [SMALL_STATE(610)] = 49437, + [SMALL_STATE(611)] = 49486, + [SMALL_STATE(612)] = 49533, + [SMALL_STATE(613)] = 49582, + [SMALL_STATE(614)] = 49629, + [SMALL_STATE(615)] = 49678, + [SMALL_STATE(616)] = 49725, + [SMALL_STATE(617)] = 49771, + [SMALL_STATE(618)] = 49817, + [SMALL_STATE(619)] = 49863, + [SMALL_STATE(620)] = 49909, + [SMALL_STATE(621)] = 49955, + [SMALL_STATE(622)] = 50001, + [SMALL_STATE(623)] = 50047, + [SMALL_STATE(624)] = 50093, + [SMALL_STATE(625)] = 50139, + [SMALL_STATE(626)] = 50185, + [SMALL_STATE(627)] = 50231, + [SMALL_STATE(628)] = 50277, + [SMALL_STATE(629)] = 50323, + [SMALL_STATE(630)] = 50369, + [SMALL_STATE(631)] = 50415, + [SMALL_STATE(632)] = 50461, + [SMALL_STATE(633)] = 50507, + [SMALL_STATE(634)] = 50553, + [SMALL_STATE(635)] = 50599, + [SMALL_STATE(636)] = 50645, + [SMALL_STATE(637)] = 50691, + [SMALL_STATE(638)] = 50737, + [SMALL_STATE(639)] = 50783, + [SMALL_STATE(640)] = 50829, + [SMALL_STATE(641)] = 50875, + [SMALL_STATE(642)] = 50921, + [SMALL_STATE(643)] = 50967, + [SMALL_STATE(644)] = 51013, + [SMALL_STATE(645)] = 51059, + [SMALL_STATE(646)] = 51105, + [SMALL_STATE(647)] = 51151, + [SMALL_STATE(648)] = 51197, + [SMALL_STATE(649)] = 51243, + [SMALL_STATE(650)] = 51289, + [SMALL_STATE(651)] = 51335, + [SMALL_STATE(652)] = 51381, + [SMALL_STATE(653)] = 51427, + [SMALL_STATE(654)] = 51473, + [SMALL_STATE(655)] = 51519, + [SMALL_STATE(656)] = 51565, + [SMALL_STATE(657)] = 51611, + [SMALL_STATE(658)] = 51657, + [SMALL_STATE(659)] = 51703, + [SMALL_STATE(660)] = 51749, + [SMALL_STATE(661)] = 51795, + [SMALL_STATE(662)] = 51841, + [SMALL_STATE(663)] = 51887, + [SMALL_STATE(664)] = 51933, + [SMALL_STATE(665)] = 51979, + [SMALL_STATE(666)] = 52025, + [SMALL_STATE(667)] = 52071, + [SMALL_STATE(668)] = 52117, + [SMALL_STATE(669)] = 52163, + [SMALL_STATE(670)] = 52209, + [SMALL_STATE(671)] = 52255, + [SMALL_STATE(672)] = 52301, + [SMALL_STATE(673)] = 52347, + [SMALL_STATE(674)] = 52393, + [SMALL_STATE(675)] = 52439, + [SMALL_STATE(676)] = 52485, + [SMALL_STATE(677)] = 52531, + [SMALL_STATE(678)] = 52577, + [SMALL_STATE(679)] = 52623, + [SMALL_STATE(680)] = 52669, + [SMALL_STATE(681)] = 52715, + [SMALL_STATE(682)] = 52761, + [SMALL_STATE(683)] = 52807, + [SMALL_STATE(684)] = 52853, + [SMALL_STATE(685)] = 52899, + [SMALL_STATE(686)] = 52945, + [SMALL_STATE(687)] = 52991, + [SMALL_STATE(688)] = 53037, + [SMALL_STATE(689)] = 53083, + [SMALL_STATE(690)] = 53129, + [SMALL_STATE(691)] = 53175, + [SMALL_STATE(692)] = 53221, + [SMALL_STATE(693)] = 53267, + [SMALL_STATE(694)] = 53313, + [SMALL_STATE(695)] = 53359, + [SMALL_STATE(696)] = 53405, + [SMALL_STATE(697)] = 53451, + [SMALL_STATE(698)] = 53497, + [SMALL_STATE(699)] = 53543, + [SMALL_STATE(700)] = 53589, + [SMALL_STATE(701)] = 53635, + [SMALL_STATE(702)] = 53681, + [SMALL_STATE(703)] = 53727, + [SMALL_STATE(704)] = 53773, + [SMALL_STATE(705)] = 53819, + [SMALL_STATE(706)] = 53865, + [SMALL_STATE(707)] = 53911, + [SMALL_STATE(708)] = 53957, + [SMALL_STATE(709)] = 54003, + [SMALL_STATE(710)] = 54049, + [SMALL_STATE(711)] = 54095, + [SMALL_STATE(712)] = 54141, + [SMALL_STATE(713)] = 54187, + [SMALL_STATE(714)] = 54233, + [SMALL_STATE(715)] = 54279, + [SMALL_STATE(716)] = 54325, + [SMALL_STATE(717)] = 54374, + [SMALL_STATE(718)] = 54423, + [SMALL_STATE(719)] = 54478, + [SMALL_STATE(720)] = 54522, + [SMALL_STATE(721)] = 54565, + [SMALL_STATE(722)] = 54614, + [SMALL_STATE(723)] = 54670, + [SMALL_STATE(724)] = 54712, + [SMALL_STATE(725)] = 54754, + [SMALL_STATE(726)] = 54796, + [SMALL_STATE(727)] = 54846, + [SMALL_STATE(728)] = 54888, + [SMALL_STATE(729)] = 54956, + [SMALL_STATE(730)] = 55024, + [SMALL_STATE(731)] = 55066, + [SMALL_STATE(732)] = 55108, + [SMALL_STATE(733)] = 55150, + [SMALL_STATE(734)] = 55192, + [SMALL_STATE(735)] = 55234, + [SMALL_STATE(736)] = 55276, + [SMALL_STATE(737)] = 55318, + [SMALL_STATE(738)] = 55368, + [SMALL_STATE(739)] = 55410, + [SMALL_STATE(740)] = 55472, + [SMALL_STATE(741)] = 55532, + [SMALL_STATE(742)] = 55586, + [SMALL_STATE(743)] = 55634, + [SMALL_STATE(744)] = 55676, + [SMALL_STATE(745)] = 55718, + [SMALL_STATE(746)] = 55786, + [SMALL_STATE(747)] = 55828, + [SMALL_STATE(748)] = 55870, + [SMALL_STATE(749)] = 55912, + [SMALL_STATE(750)] = 55954, + [SMALL_STATE(751)] = 55996, + [SMALL_STATE(752)] = 56038, + [SMALL_STATE(753)] = 56080, + [SMALL_STATE(754)] = 56122, + [SMALL_STATE(755)] = 56190, + [SMALL_STATE(756)] = 56232, + [SMALL_STATE(757)] = 56274, + [SMALL_STATE(758)] = 56342, + [SMALL_STATE(759)] = 56384, + [SMALL_STATE(760)] = 56452, + [SMALL_STATE(761)] = 56494, + [SMALL_STATE(762)] = 56562, + [SMALL_STATE(763)] = 56630, + [SMALL_STATE(764)] = 56672, + [SMALL_STATE(765)] = 56714, + [SMALL_STATE(766)] = 56782, + [SMALL_STATE(767)] = 56824, + [SMALL_STATE(768)] = 56866, + [SMALL_STATE(769)] = 56934, + [SMALL_STATE(770)] = 57002, + [SMALL_STATE(771)] = 57044, + [SMALL_STATE(772)] = 57086, + [SMALL_STATE(773)] = 57149, + [SMALL_STATE(774)] = 57212, + [SMALL_STATE(775)] = 57275, + [SMALL_STATE(776)] = 57338, + [SMALL_STATE(777)] = 57401, + [SMALL_STATE(778)] = 57464, + [SMALL_STATE(779)] = 57527, + [SMALL_STATE(780)] = 57590, + [SMALL_STATE(781)] = 57653, + [SMALL_STATE(782)] = 57716, + [SMALL_STATE(783)] = 57779, + [SMALL_STATE(784)] = 57842, + [SMALL_STATE(785)] = 57905, + [SMALL_STATE(786)] = 57968, + [SMALL_STATE(787)] = 58031, + [SMALL_STATE(788)] = 58094, + [SMALL_STATE(789)] = 58157, + [SMALL_STATE(790)] = 58220, + [SMALL_STATE(791)] = 58283, + [SMALL_STATE(792)] = 58346, + [SMALL_STATE(793)] = 58409, + [SMALL_STATE(794)] = 58472, + [SMALL_STATE(795)] = 58535, + [SMALL_STATE(796)] = 58598, + [SMALL_STATE(797)] = 58661, + [SMALL_STATE(798)] = 58724, + [SMALL_STATE(799)] = 58787, + [SMALL_STATE(800)] = 58850, + [SMALL_STATE(801)] = 58913, + [SMALL_STATE(802)] = 58976, + [SMALL_STATE(803)] = 59039, + [SMALL_STATE(804)] = 59102, + [SMALL_STATE(805)] = 59165, + [SMALL_STATE(806)] = 59228, + [SMALL_STATE(807)] = 59291, + [SMALL_STATE(808)] = 59354, + [SMALL_STATE(809)] = 59417, + [SMALL_STATE(810)] = 59464, + [SMALL_STATE(811)] = 59517, + [SMALL_STATE(812)] = 59574, + [SMALL_STATE(813)] = 59629, + [SMALL_STATE(814)] = 59680, + [SMALL_STATE(815)] = 59743, + [SMALL_STATE(816)] = 59806, + [SMALL_STATE(817)] = 59869, + [SMALL_STATE(818)] = 59932, + [SMALL_STATE(819)] = 59995, + [SMALL_STATE(820)] = 60058, + [SMALL_STATE(821)] = 60121, + [SMALL_STATE(822)] = 60184, + [SMALL_STATE(823)] = 60247, + [SMALL_STATE(824)] = 60294, + [SMALL_STATE(825)] = 60357, + [SMALL_STATE(826)] = 60420, + [SMALL_STATE(827)] = 60483, + [SMALL_STATE(828)] = 60542, + [SMALL_STATE(829)] = 60601, + [SMALL_STATE(830)] = 60660, + [SMALL_STATE(831)] = 60719, + [SMALL_STATE(832)] = 60778, + [SMALL_STATE(833)] = 60837, + [SMALL_STATE(834)] = 60896, + [SMALL_STATE(835)] = 60955, + [SMALL_STATE(836)] = 61014, + [SMALL_STATE(837)] = 61063, + [SMALL_STATE(838)] = 61122, + [SMALL_STATE(839)] = 61181, + [SMALL_STATE(840)] = 61240, + [SMALL_STATE(841)] = 61299, + [SMALL_STATE(842)] = 61358, + [SMALL_STATE(843)] = 61417, + [SMALL_STATE(844)] = 61476, + [SMALL_STATE(845)] = 61535, + [SMALL_STATE(846)] = 61594, + [SMALL_STATE(847)] = 61653, + [SMALL_STATE(848)] = 61712, + [SMALL_STATE(849)] = 61771, + [SMALL_STATE(850)] = 61830, + [SMALL_STATE(851)] = 61889, + [SMALL_STATE(852)] = 61948, + [SMALL_STATE(853)] = 62007, + [SMALL_STATE(854)] = 62066, + [SMALL_STATE(855)] = 62125, + [SMALL_STATE(856)] = 62184, + [SMALL_STATE(857)] = 62243, + [SMALL_STATE(858)] = 62288, + [SMALL_STATE(859)] = 62347, + [SMALL_STATE(860)] = 62406, + [SMALL_STATE(861)] = 62465, + [SMALL_STATE(862)] = 62524, + [SMALL_STATE(863)] = 62582, + [SMALL_STATE(864)] = 62636, + [SMALL_STATE(865)] = 62694, + [SMALL_STATE(866)] = 62752, + [SMALL_STATE(867)] = 62810, + [SMALL_STATE(868)] = 62841, + [SMALL_STATE(869)] = 62894, + [SMALL_STATE(870)] = 62945, + [SMALL_STATE(871)] = 62998, + [SMALL_STATE(872)] = 63051, + [SMALL_STATE(873)] = 63104, + [SMALL_STATE(874)] = 63157, + [SMALL_STATE(875)] = 63208, + [SMALL_STATE(876)] = 63260, + [SMALL_STATE(877)] = 63310, + [SMALL_STATE(878)] = 63362, + [SMALL_STATE(879)] = 63414, + [SMALL_STATE(880)] = 63466, + [SMALL_STATE(881)] = 63518, + [SMALL_STATE(882)] = 63570, + [SMALL_STATE(883)] = 63622, + [SMALL_STATE(884)] = 63674, + [SMALL_STATE(885)] = 63726, + [SMALL_STATE(886)] = 63776, + [SMALL_STATE(887)] = 63828, + [SMALL_STATE(888)] = 63880, + [SMALL_STATE(889)] = 63932, + [SMALL_STATE(890)] = 63984, + [SMALL_STATE(891)] = 64036, + [SMALL_STATE(892)] = 64088, + [SMALL_STATE(893)] = 64140, + [SMALL_STATE(894)] = 64192, + [SMALL_STATE(895)] = 64244, + [SMALL_STATE(896)] = 64296, + [SMALL_STATE(897)] = 64348, + [SMALL_STATE(898)] = 64400, + [SMALL_STATE(899)] = 64450, + [SMALL_STATE(900)] = 64502, + [SMALL_STATE(901)] = 64554, + [SMALL_STATE(902)] = 64606, + [SMALL_STATE(903)] = 64658, + [SMALL_STATE(904)] = 64710, + [SMALL_STATE(905)] = 64762, + [SMALL_STATE(906)] = 64814, + [SMALL_STATE(907)] = 64866, + [SMALL_STATE(908)] = 64918, + [SMALL_STATE(909)] = 64970, + [SMALL_STATE(910)] = 65022, + [SMALL_STATE(911)] = 65074, + [SMALL_STATE(912)] = 65126, + [SMALL_STATE(913)] = 65178, + [SMALL_STATE(914)] = 65230, + [SMALL_STATE(915)] = 65279, + [SMALL_STATE(916)] = 65326, + [SMALL_STATE(917)] = 65373, + [SMALL_STATE(918)] = 65422, + [SMALL_STATE(919)] = 65469, + [SMALL_STATE(920)] = 65516, + [SMALL_STATE(921)] = 65563, + [SMALL_STATE(922)] = 65598, + [SMALL_STATE(923)] = 65647, + [SMALL_STATE(924)] = 65696, + [SMALL_STATE(925)] = 65745, + [SMALL_STATE(926)] = 65778, + [SMALL_STATE(927)] = 65827, + [SMALL_STATE(928)] = 65874, + [SMALL_STATE(929)] = 65921, + [SMALL_STATE(930)] = 65968, + [SMALL_STATE(931)] = 66017, + [SMALL_STATE(932)] = 66061, + [SMALL_STATE(933)] = 66105, + [SMALL_STATE(934)] = 66149, + [SMALL_STATE(935)] = 66194, + [SMALL_STATE(936)] = 66239, + [SMALL_STATE(937)] = 66284, + [SMALL_STATE(938)] = 66329, + [SMALL_STATE(939)] = 66374, + [SMALL_STATE(940)] = 66417, + [SMALL_STATE(941)] = 66462, + [SMALL_STATE(942)] = 66507, + [SMALL_STATE(943)] = 66550, + [SMALL_STATE(944)] = 66595, + [SMALL_STATE(945)] = 66638, + [SMALL_STATE(946)] = 66683, + [SMALL_STATE(947)] = 66710, + [SMALL_STATE(948)] = 66739, + [SMALL_STATE(949)] = 66779, + [SMALL_STATE(950)] = 66807, + [SMALL_STATE(951)] = 66847, + [SMALL_STATE(952)] = 66887, + [SMALL_STATE(953)] = 66919, + [SMALL_STATE(954)] = 66947, + [SMALL_STATE(955)] = 66970, + [SMALL_STATE(956)] = 67004, + [SMALL_STATE(957)] = 67038, + [SMALL_STATE(958)] = 67072, + [SMALL_STATE(959)] = 67106, + [SMALL_STATE(960)] = 67140, + [SMALL_STATE(961)] = 67174, + [SMALL_STATE(962)] = 67208, + [SMALL_STATE(963)] = 67242, + [SMALL_STATE(964)] = 67276, + [SMALL_STATE(965)] = 67310, + [SMALL_STATE(966)] = 67344, + [SMALL_STATE(967)] = 67378, + [SMALL_STATE(968)] = 67404, + [SMALL_STATE(969)] = 67427, + [SMALL_STATE(970)] = 67448, + [SMALL_STATE(971)] = 67469, + [SMALL_STATE(972)] = 67490, + [SMALL_STATE(973)] = 67511, + [SMALL_STATE(974)] = 67534, + [SMALL_STATE(975)] = 67552, + [SMALL_STATE(976)] = 67570, + [SMALL_STATE(977)] = 67596, + [SMALL_STATE(978)] = 67616, + [SMALL_STATE(979)] = 67636, + [SMALL_STATE(980)] = 67654, + [SMALL_STATE(981)] = 67674, + [SMALL_STATE(982)] = 67694, + [SMALL_STATE(983)] = 67712, + [SMALL_STATE(984)] = 67732, + [SMALL_STATE(985)] = 67750, + [SMALL_STATE(986)] = 67779, + [SMALL_STATE(987)] = 67802, + [SMALL_STATE(988)] = 67831, + [SMALL_STATE(989)] = 67860, + [SMALL_STATE(990)] = 67889, + [SMALL_STATE(991)] = 67910, + [SMALL_STATE(992)] = 67939, + [SMALL_STATE(993)] = 67962, + [SMALL_STATE(994)] = 67991, + [SMALL_STATE(995)] = 68012, + [SMALL_STATE(996)] = 68035, + [SMALL_STATE(997)] = 68064, + [SMALL_STATE(998)] = 68093, + [SMALL_STATE(999)] = 68116, + [SMALL_STATE(1000)] = 68150, + [SMALL_STATE(1001)] = 68170, + [SMALL_STATE(1002)] = 68196, + [SMALL_STATE(1003)] = 68216, + [SMALL_STATE(1004)] = 68236, + [SMALL_STATE(1005)] = 68256, + [SMALL_STATE(1006)] = 68288, + [SMALL_STATE(1007)] = 68314, + [SMALL_STATE(1008)] = 68334, + [SMALL_STATE(1009)] = 68360, + [SMALL_STATE(1010)] = 68386, + [SMALL_STATE(1011)] = 68406, + [SMALL_STATE(1012)] = 68432, + [SMALL_STATE(1013)] = 68452, + [SMALL_STATE(1014)] = 68484, + [SMALL_STATE(1015)] = 68512, + [SMALL_STATE(1016)] = 68538, + [SMALL_STATE(1017)] = 68570, + [SMALL_STATE(1018)] = 68593, + [SMALL_STATE(1019)] = 68616, + [SMALL_STATE(1020)] = 68639, + [SMALL_STATE(1021)] = 68662, + [SMALL_STATE(1022)] = 68685, + [SMALL_STATE(1023)] = 68708, + [SMALL_STATE(1024)] = 68731, + [SMALL_STATE(1025)] = 68748, + [SMALL_STATE(1026)] = 68771, + [SMALL_STATE(1027)] = 68794, + [SMALL_STATE(1028)] = 68817, + [SMALL_STATE(1029)] = 68840, + [SMALL_STATE(1030)] = 68863, + [SMALL_STATE(1031)] = 68886, + [SMALL_STATE(1032)] = 68909, + [SMALL_STATE(1033)] = 68932, + [SMALL_STATE(1034)] = 68955, + [SMALL_STATE(1035)] = 68978, + [SMALL_STATE(1036)] = 69001, + [SMALL_STATE(1037)] = 69024, + [SMALL_STATE(1038)] = 69047, + [SMALL_STATE(1039)] = 69070, + [SMALL_STATE(1040)] = 69093, + [SMALL_STATE(1041)] = 69116, + [SMALL_STATE(1042)] = 69139, + [SMALL_STATE(1043)] = 69168, + [SMALL_STATE(1044)] = 69191, + [SMALL_STATE(1045)] = 69214, + [SMALL_STATE(1046)] = 69237, + [SMALL_STATE(1047)] = 69260, + [SMALL_STATE(1048)] = 69283, + [SMALL_STATE(1049)] = 69306, + [SMALL_STATE(1050)] = 69329, + [SMALL_STATE(1051)] = 69352, + [SMALL_STATE(1052)] = 69375, + [SMALL_STATE(1053)] = 69398, + [SMALL_STATE(1054)] = 69421, + [SMALL_STATE(1055)] = 69444, + [SMALL_STATE(1056)] = 69461, + [SMALL_STATE(1057)] = 69484, + [SMALL_STATE(1058)] = 69507, + [SMALL_STATE(1059)] = 69530, + [SMALL_STATE(1060)] = 69553, + [SMALL_STATE(1061)] = 69576, + [SMALL_STATE(1062)] = 69599, + [SMALL_STATE(1063)] = 69622, + [SMALL_STATE(1064)] = 69645, + [SMALL_STATE(1065)] = 69668, + [SMALL_STATE(1066)] = 69691, + [SMALL_STATE(1067)] = 69714, + [SMALL_STATE(1068)] = 69731, + [SMALL_STATE(1069)] = 69754, + [SMALL_STATE(1070)] = 69777, + [SMALL_STATE(1071)] = 69800, + [SMALL_STATE(1072)] = 69823, + [SMALL_STATE(1073)] = 69846, + [SMALL_STATE(1074)] = 69869, + [SMALL_STATE(1075)] = 69892, + [SMALL_STATE(1076)] = 69915, + [SMALL_STATE(1077)] = 69938, + [SMALL_STATE(1078)] = 69961, + [SMALL_STATE(1079)] = 69984, + [SMALL_STATE(1080)] = 70007, + [SMALL_STATE(1081)] = 70030, + [SMALL_STATE(1082)] = 70053, + [SMALL_STATE(1083)] = 70076, + [SMALL_STATE(1084)] = 70099, + [SMALL_STATE(1085)] = 70122, + [SMALL_STATE(1086)] = 70145, + [SMALL_STATE(1087)] = 70168, + [SMALL_STATE(1088)] = 70191, + [SMALL_STATE(1089)] = 70214, + [SMALL_STATE(1090)] = 70237, + [SMALL_STATE(1091)] = 70260, + [SMALL_STATE(1092)] = 70283, + [SMALL_STATE(1093)] = 70306, + [SMALL_STATE(1094)] = 70329, + [SMALL_STATE(1095)] = 70352, + [SMALL_STATE(1096)] = 70375, + [SMALL_STATE(1097)] = 70398, + [SMALL_STATE(1098)] = 70421, + [SMALL_STATE(1099)] = 70444, + [SMALL_STATE(1100)] = 70467, + [SMALL_STATE(1101)] = 70481, + [SMALL_STATE(1102)] = 70495, + [SMALL_STATE(1103)] = 70509, + [SMALL_STATE(1104)] = 70523, + [SMALL_STATE(1105)] = 70537, + [SMALL_STATE(1106)] = 70551, + [SMALL_STATE(1107)] = 70573, + [SMALL_STATE(1108)] = 70587, + [SMALL_STATE(1109)] = 70601, + [SMALL_STATE(1110)] = 70615, + [SMALL_STATE(1111)] = 70629, + [SMALL_STATE(1112)] = 70643, + [SMALL_STATE(1113)] = 70657, + [SMALL_STATE(1114)] = 70671, + [SMALL_STATE(1115)] = 70685, + [SMALL_STATE(1116)] = 70699, + [SMALL_STATE(1117)] = 70713, + [SMALL_STATE(1118)] = 70727, + [SMALL_STATE(1119)] = 70741, + [SMALL_STATE(1120)] = 70755, + [SMALL_STATE(1121)] = 70769, + [SMALL_STATE(1122)] = 70791, + [SMALL_STATE(1123)] = 70813, + [SMALL_STATE(1124)] = 70835, + [SMALL_STATE(1125)] = 70857, + [SMALL_STATE(1126)] = 70879, + [SMALL_STATE(1127)] = 70901, + [SMALL_STATE(1128)] = 70923, + [SMALL_STATE(1129)] = 70945, + [SMALL_STATE(1130)] = 70967, + [SMALL_STATE(1131)] = 70983, + [SMALL_STATE(1132)] = 71005, + [SMALL_STATE(1133)] = 71027, + [SMALL_STATE(1134)] = 71049, + [SMALL_STATE(1135)] = 71071, + [SMALL_STATE(1136)] = 71093, + [SMALL_STATE(1137)] = 71115, + [SMALL_STATE(1138)] = 71137, + [SMALL_STATE(1139)] = 71159, + [SMALL_STATE(1140)] = 71181, + [SMALL_STATE(1141)] = 71203, + [SMALL_STATE(1142)] = 71225, + [SMALL_STATE(1143)] = 71247, + [SMALL_STATE(1144)] = 71269, + [SMALL_STATE(1145)] = 71291, + [SMALL_STATE(1146)] = 71313, + [SMALL_STATE(1147)] = 71330, + [SMALL_STATE(1148)] = 71349, + [SMALL_STATE(1149)] = 71368, + [SMALL_STATE(1150)] = 71385, + [SMALL_STATE(1151)] = 71402, + [SMALL_STATE(1152)] = 71421, + [SMALL_STATE(1153)] = 71440, + [SMALL_STATE(1154)] = 71459, + [SMALL_STATE(1155)] = 71478, + [SMALL_STATE(1156)] = 71495, + [SMALL_STATE(1157)] = 71512, + [SMALL_STATE(1158)] = 71531, + [SMALL_STATE(1159)] = 71548, + [SMALL_STATE(1160)] = 71567, + [SMALL_STATE(1161)] = 71586, + [SMALL_STATE(1162)] = 71603, + [SMALL_STATE(1163)] = 71622, + [SMALL_STATE(1164)] = 71639, + [SMALL_STATE(1165)] = 71656, + [SMALL_STATE(1166)] = 71675, + [SMALL_STATE(1167)] = 71694, + [SMALL_STATE(1168)] = 71711, + [SMALL_STATE(1169)] = 71728, + [SMALL_STATE(1170)] = 71745, + [SMALL_STATE(1171)] = 71764, + [SMALL_STATE(1172)] = 71781, + [SMALL_STATE(1173)] = 71800, + [SMALL_STATE(1174)] = 71819, + [SMALL_STATE(1175)] = 71838, + [SMALL_STATE(1176)] = 71857, + [SMALL_STATE(1177)] = 71874, + [SMALL_STATE(1178)] = 71891, + [SMALL_STATE(1179)] = 71910, + [SMALL_STATE(1180)] = 71929, + [SMALL_STATE(1181)] = 71948, + [SMALL_STATE(1182)] = 71967, + [SMALL_STATE(1183)] = 71984, + [SMALL_STATE(1184)] = 72003, + [SMALL_STATE(1185)] = 72020, + [SMALL_STATE(1186)] = 72039, + [SMALL_STATE(1187)] = 72058, + [SMALL_STATE(1188)] = 72075, + [SMALL_STATE(1189)] = 72092, + [SMALL_STATE(1190)] = 72109, + [SMALL_STATE(1191)] = 72126, + [SMALL_STATE(1192)] = 72145, + [SMALL_STATE(1193)] = 72162, + [SMALL_STATE(1194)] = 72179, + [SMALL_STATE(1195)] = 72198, + [SMALL_STATE(1196)] = 72215, + [SMALL_STATE(1197)] = 72232, + [SMALL_STATE(1198)] = 72251, + [SMALL_STATE(1199)] = 72270, + [SMALL_STATE(1200)] = 72284, + [SMALL_STATE(1201)] = 72294, + [SMALL_STATE(1202)] = 72304, + [SMALL_STATE(1203)] = 72314, + [SMALL_STATE(1204)] = 72330, + [SMALL_STATE(1205)] = 72340, + [SMALL_STATE(1206)] = 72356, + [SMALL_STATE(1207)] = 72372, + [SMALL_STATE(1208)] = 72386, + [SMALL_STATE(1209)] = 72402, + [SMALL_STATE(1210)] = 72412, + [SMALL_STATE(1211)] = 72426, + [SMALL_STATE(1212)] = 72440, + [SMALL_STATE(1213)] = 72454, + [SMALL_STATE(1214)] = 72464, + [SMALL_STATE(1215)] = 72478, + [SMALL_STATE(1216)] = 72492, + [SMALL_STATE(1217)] = 72508, + [SMALL_STATE(1218)] = 72524, + [SMALL_STATE(1219)] = 72540, + [SMALL_STATE(1220)] = 72554, + [SMALL_STATE(1221)] = 72568, + [SMALL_STATE(1222)] = 72582, + [SMALL_STATE(1223)] = 72598, + [SMALL_STATE(1224)] = 72614, + [SMALL_STATE(1225)] = 72628, + [SMALL_STATE(1226)] = 72644, + [SMALL_STATE(1227)] = 72654, + [SMALL_STATE(1228)] = 72670, + [SMALL_STATE(1229)] = 72684, + [SMALL_STATE(1230)] = 72700, + [SMALL_STATE(1231)] = 72714, + [SMALL_STATE(1232)] = 72730, + [SMALL_STATE(1233)] = 72744, + [SMALL_STATE(1234)] = 72758, + [SMALL_STATE(1235)] = 72772, + [SMALL_STATE(1236)] = 72788, + [SMALL_STATE(1237)] = 72802, + [SMALL_STATE(1238)] = 72816, + [SMALL_STATE(1239)] = 72832, + [SMALL_STATE(1240)] = 72846, + [SMALL_STATE(1241)] = 72860, + [SMALL_STATE(1242)] = 72874, + [SMALL_STATE(1243)] = 72888, + [SMALL_STATE(1244)] = 72904, + [SMALL_STATE(1245)] = 72920, + [SMALL_STATE(1246)] = 72930, + [SMALL_STATE(1247)] = 72946, + [SMALL_STATE(1248)] = 72960, + [SMALL_STATE(1249)] = 72976, + [SMALL_STATE(1250)] = 72990, + [SMALL_STATE(1251)] = 73006, + [SMALL_STATE(1252)] = 73022, + [SMALL_STATE(1253)] = 73038, + [SMALL_STATE(1254)] = 73052, + [SMALL_STATE(1255)] = 73068, + [SMALL_STATE(1256)] = 73084, + [SMALL_STATE(1257)] = 73100, + [SMALL_STATE(1258)] = 73116, + [SMALL_STATE(1259)] = 73128, + [SMALL_STATE(1260)] = 73142, + [SMALL_STATE(1261)] = 73158, + [SMALL_STATE(1262)] = 73172, + [SMALL_STATE(1263)] = 73188, + [SMALL_STATE(1264)] = 73204, + [SMALL_STATE(1265)] = 73220, + [SMALL_STATE(1266)] = 73236, + [SMALL_STATE(1267)] = 73250, + [SMALL_STATE(1268)] = 73260, + [SMALL_STATE(1269)] = 73276, + [SMALL_STATE(1270)] = 73286, + [SMALL_STATE(1271)] = 73302, + [SMALL_STATE(1272)] = 73312, + [SMALL_STATE(1273)] = 73322, + [SMALL_STATE(1274)] = 73332, + [SMALL_STATE(1275)] = 73348, + [SMALL_STATE(1276)] = 73364, + [SMALL_STATE(1277)] = 73378, + [SMALL_STATE(1278)] = 73388, + [SMALL_STATE(1279)] = 73402, + [SMALL_STATE(1280)] = 73415, + [SMALL_STATE(1281)] = 73428, + [SMALL_STATE(1282)] = 73441, + [SMALL_STATE(1283)] = 73454, + [SMALL_STATE(1284)] = 73467, + [SMALL_STATE(1285)] = 73480, + [SMALL_STATE(1286)] = 73493, + [SMALL_STATE(1287)] = 73506, + [SMALL_STATE(1288)] = 73519, + [SMALL_STATE(1289)] = 73530, + [SMALL_STATE(1290)] = 73543, + [SMALL_STATE(1291)] = 73556, + [SMALL_STATE(1292)] = 73569, + [SMALL_STATE(1293)] = 73582, + [SMALL_STATE(1294)] = 73595, + [SMALL_STATE(1295)] = 73608, + [SMALL_STATE(1296)] = 73619, + [SMALL_STATE(1297)] = 73632, + [SMALL_STATE(1298)] = 73645, + [SMALL_STATE(1299)] = 73658, + [SMALL_STATE(1300)] = 73671, + [SMALL_STATE(1301)] = 73684, + [SMALL_STATE(1302)] = 73697, + [SMALL_STATE(1303)] = 73708, + [SMALL_STATE(1304)] = 73721, + [SMALL_STATE(1305)] = 73734, + [SMALL_STATE(1306)] = 73747, + [SMALL_STATE(1307)] = 73760, + [SMALL_STATE(1308)] = 73773, + [SMALL_STATE(1309)] = 73786, + [SMALL_STATE(1310)] = 73799, + [SMALL_STATE(1311)] = 73812, + [SMALL_STATE(1312)] = 73825, + [SMALL_STATE(1313)] = 73838, + [SMALL_STATE(1314)] = 73851, + [SMALL_STATE(1315)] = 73864, + [SMALL_STATE(1316)] = 73877, + [SMALL_STATE(1317)] = 73886, + [SMALL_STATE(1318)] = 73895, + [SMALL_STATE(1319)] = 73908, + [SMALL_STATE(1320)] = 73921, + [SMALL_STATE(1321)] = 73934, + [SMALL_STATE(1322)] = 73947, + [SMALL_STATE(1323)] = 73960, + [SMALL_STATE(1324)] = 73973, + [SMALL_STATE(1325)] = 73986, + [SMALL_STATE(1326)] = 73999, + [SMALL_STATE(1327)] = 74012, + [SMALL_STATE(1328)] = 74025, + [SMALL_STATE(1329)] = 74038, + [SMALL_STATE(1330)] = 74051, + [SMALL_STATE(1331)] = 74064, + [SMALL_STATE(1332)] = 74077, + [SMALL_STATE(1333)] = 74090, + [SMALL_STATE(1334)] = 74103, + [SMALL_STATE(1335)] = 74114, + [SMALL_STATE(1336)] = 74127, + [SMALL_STATE(1337)] = 74140, + [SMALL_STATE(1338)] = 74151, + [SMALL_STATE(1339)] = 74164, + [SMALL_STATE(1340)] = 74175, + [SMALL_STATE(1341)] = 74188, + [SMALL_STATE(1342)] = 74201, + [SMALL_STATE(1343)] = 74214, + [SMALL_STATE(1344)] = 74227, + [SMALL_STATE(1345)] = 74240, + [SMALL_STATE(1346)] = 74253, + [SMALL_STATE(1347)] = 74264, + [SMALL_STATE(1348)] = 74277, + [SMALL_STATE(1349)] = 74286, + [SMALL_STATE(1350)] = 74299, + [SMALL_STATE(1351)] = 74312, + [SMALL_STATE(1352)] = 74325, + [SMALL_STATE(1353)] = 74338, + [SMALL_STATE(1354)] = 74351, + [SMALL_STATE(1355)] = 74364, + [SMALL_STATE(1356)] = 74377, + [SMALL_STATE(1357)] = 74390, + [SMALL_STATE(1358)] = 74403, + [SMALL_STATE(1359)] = 74416, + [SMALL_STATE(1360)] = 74429, + [SMALL_STATE(1361)] = 74442, + [SMALL_STATE(1362)] = 74455, + [SMALL_STATE(1363)] = 74468, + [SMALL_STATE(1364)] = 74481, + [SMALL_STATE(1365)] = 74494, + [SMALL_STATE(1366)] = 74507, + [SMALL_STATE(1367)] = 74520, + [SMALL_STATE(1368)] = 74533, + [SMALL_STATE(1369)] = 74546, + [SMALL_STATE(1370)] = 74559, + [SMALL_STATE(1371)] = 74572, + [SMALL_STATE(1372)] = 74583, + [SMALL_STATE(1373)] = 74596, + [SMALL_STATE(1374)] = 74609, + [SMALL_STATE(1375)] = 74622, + [SMALL_STATE(1376)] = 74635, + [SMALL_STATE(1377)] = 74648, + [SMALL_STATE(1378)] = 74661, + [SMALL_STATE(1379)] = 74674, + [SMALL_STATE(1380)] = 74687, + [SMALL_STATE(1381)] = 74700, + [SMALL_STATE(1382)] = 74713, + [SMALL_STATE(1383)] = 74726, + [SMALL_STATE(1384)] = 74739, + [SMALL_STATE(1385)] = 74752, + [SMALL_STATE(1386)] = 74765, + [SMALL_STATE(1387)] = 74778, + [SMALL_STATE(1388)] = 74791, + [SMALL_STATE(1389)] = 74804, + [SMALL_STATE(1390)] = 74817, + [SMALL_STATE(1391)] = 74830, + [SMALL_STATE(1392)] = 74843, + [SMALL_STATE(1393)] = 74854, + [SMALL_STATE(1394)] = 74867, + [SMALL_STATE(1395)] = 74880, + [SMALL_STATE(1396)] = 74893, + [SMALL_STATE(1397)] = 74906, + [SMALL_STATE(1398)] = 74919, + [SMALL_STATE(1399)] = 74932, + [SMALL_STATE(1400)] = 74945, + [SMALL_STATE(1401)] = 74958, + [SMALL_STATE(1402)] = 74971, + [SMALL_STATE(1403)] = 74984, + [SMALL_STATE(1404)] = 74995, + [SMALL_STATE(1405)] = 75008, + [SMALL_STATE(1406)] = 75021, + [SMALL_STATE(1407)] = 75034, + [SMALL_STATE(1408)] = 75047, + [SMALL_STATE(1409)] = 75060, + [SMALL_STATE(1410)] = 75073, + [SMALL_STATE(1411)] = 75086, + [SMALL_STATE(1412)] = 75099, + [SMALL_STATE(1413)] = 75112, + [SMALL_STATE(1414)] = 75125, + [SMALL_STATE(1415)] = 75138, + [SMALL_STATE(1416)] = 75151, + [SMALL_STATE(1417)] = 75164, + [SMALL_STATE(1418)] = 75174, + [SMALL_STATE(1419)] = 75182, + [SMALL_STATE(1420)] = 75190, + [SMALL_STATE(1421)] = 75200, + [SMALL_STATE(1422)] = 75208, + [SMALL_STATE(1423)] = 75216, + [SMALL_STATE(1424)] = 75226, + [SMALL_STATE(1425)] = 75236, + [SMALL_STATE(1426)] = 75246, + [SMALL_STATE(1427)] = 75256, + [SMALL_STATE(1428)] = 75264, + [SMALL_STATE(1429)] = 75274, + [SMALL_STATE(1430)] = 75284, + [SMALL_STATE(1431)] = 75294, + [SMALL_STATE(1432)] = 75302, + [SMALL_STATE(1433)] = 75312, + [SMALL_STATE(1434)] = 75320, + [SMALL_STATE(1435)] = 75330, + [SMALL_STATE(1436)] = 75340, + [SMALL_STATE(1437)] = 75350, + [SMALL_STATE(1438)] = 75360, + [SMALL_STATE(1439)] = 75370, + [SMALL_STATE(1440)] = 75380, + [SMALL_STATE(1441)] = 75388, + [SMALL_STATE(1442)] = 75398, + [SMALL_STATE(1443)] = 75406, + [SMALL_STATE(1444)] = 75416, + [SMALL_STATE(1445)] = 75426, + [SMALL_STATE(1446)] = 75436, + [SMALL_STATE(1447)] = 75446, + [SMALL_STATE(1448)] = 75456, + [SMALL_STATE(1449)] = 75466, + [SMALL_STATE(1450)] = 75476, + [SMALL_STATE(1451)] = 75486, + [SMALL_STATE(1452)] = 75496, + [SMALL_STATE(1453)] = 75506, + [SMALL_STATE(1454)] = 75516, + [SMALL_STATE(1455)] = 75526, + [SMALL_STATE(1456)] = 75536, + [SMALL_STATE(1457)] = 75546, + [SMALL_STATE(1458)] = 75556, + [SMALL_STATE(1459)] = 75566, + [SMALL_STATE(1460)] = 75576, + [SMALL_STATE(1461)] = 75586, + [SMALL_STATE(1462)] = 75596, + [SMALL_STATE(1463)] = 75604, + [SMALL_STATE(1464)] = 75614, + [SMALL_STATE(1465)] = 75624, + [SMALL_STATE(1466)] = 75634, + [SMALL_STATE(1467)] = 75644, + [SMALL_STATE(1468)] = 75654, + [SMALL_STATE(1469)] = 75662, + [SMALL_STATE(1470)] = 75672, + [SMALL_STATE(1471)] = 75680, + [SMALL_STATE(1472)] = 75690, + [SMALL_STATE(1473)] = 75698, + [SMALL_STATE(1474)] = 75708, + [SMALL_STATE(1475)] = 75718, + [SMALL_STATE(1476)] = 75728, + [SMALL_STATE(1477)] = 75738, + [SMALL_STATE(1478)] = 75746, + [SMALL_STATE(1479)] = 75756, + [SMALL_STATE(1480)] = 75764, + [SMALL_STATE(1481)] = 75772, + [SMALL_STATE(1482)] = 75780, + [SMALL_STATE(1483)] = 75790, + [SMALL_STATE(1484)] = 75800, + [SMALL_STATE(1485)] = 75810, + [SMALL_STATE(1486)] = 75820, + [SMALL_STATE(1487)] = 75830, + [SMALL_STATE(1488)] = 75840, + [SMALL_STATE(1489)] = 75850, + [SMALL_STATE(1490)] = 75860, + [SMALL_STATE(1491)] = 75868, + [SMALL_STATE(1492)] = 75878, + [SMALL_STATE(1493)] = 75888, + [SMALL_STATE(1494)] = 75898, + [SMALL_STATE(1495)] = 75908, + [SMALL_STATE(1496)] = 75918, + [SMALL_STATE(1497)] = 75928, + [SMALL_STATE(1498)] = 75936, + [SMALL_STATE(1499)] = 75946, + [SMALL_STATE(1500)] = 75956, + [SMALL_STATE(1501)] = 75966, + [SMALL_STATE(1502)] = 75976, + [SMALL_STATE(1503)] = 75986, + [SMALL_STATE(1504)] = 75996, + [SMALL_STATE(1505)] = 76006, + [SMALL_STATE(1506)] = 76016, + [SMALL_STATE(1507)] = 76023, + [SMALL_STATE(1508)] = 76030, + [SMALL_STATE(1509)] = 76037, + [SMALL_STATE(1510)] = 76044, + [SMALL_STATE(1511)] = 76051, + [SMALL_STATE(1512)] = 76058, + [SMALL_STATE(1513)] = 76065, + [SMALL_STATE(1514)] = 76072, + [SMALL_STATE(1515)] = 76079, + [SMALL_STATE(1516)] = 76086, + [SMALL_STATE(1517)] = 76093, + [SMALL_STATE(1518)] = 76100, + [SMALL_STATE(1519)] = 76107, + [SMALL_STATE(1520)] = 76114, + [SMALL_STATE(1521)] = 76121, + [SMALL_STATE(1522)] = 76128, + [SMALL_STATE(1523)] = 76135, + [SMALL_STATE(1524)] = 76142, + [SMALL_STATE(1525)] = 76149, + [SMALL_STATE(1526)] = 76156, + [SMALL_STATE(1527)] = 76163, + [SMALL_STATE(1528)] = 76170, + [SMALL_STATE(1529)] = 76177, + [SMALL_STATE(1530)] = 76184, + [SMALL_STATE(1531)] = 76191, + [SMALL_STATE(1532)] = 76198, + [SMALL_STATE(1533)] = 76205, + [SMALL_STATE(1534)] = 76212, + [SMALL_STATE(1535)] = 76219, + [SMALL_STATE(1536)] = 76226, + [SMALL_STATE(1537)] = 76233, + [SMALL_STATE(1538)] = 76240, + [SMALL_STATE(1539)] = 76247, + [SMALL_STATE(1540)] = 76254, + [SMALL_STATE(1541)] = 76261, + [SMALL_STATE(1542)] = 76268, + [SMALL_STATE(1543)] = 76275, + [SMALL_STATE(1544)] = 76282, + [SMALL_STATE(1545)] = 76289, + [SMALL_STATE(1546)] = 76296, + [SMALL_STATE(1547)] = 76303, + [SMALL_STATE(1548)] = 76310, + [SMALL_STATE(1549)] = 76317, + [SMALL_STATE(1550)] = 76324, + [SMALL_STATE(1551)] = 76331, + [SMALL_STATE(1552)] = 76338, + [SMALL_STATE(1553)] = 76345, + [SMALL_STATE(1554)] = 76352, + [SMALL_STATE(1555)] = 76359, + [SMALL_STATE(1556)] = 76366, + [SMALL_STATE(1557)] = 76373, + [SMALL_STATE(1558)] = 76380, + [SMALL_STATE(1559)] = 76387, + [SMALL_STATE(1560)] = 76394, + [SMALL_STATE(1561)] = 76401, + [SMALL_STATE(1562)] = 76408, + [SMALL_STATE(1563)] = 76415, + [SMALL_STATE(1564)] = 76422, + [SMALL_STATE(1565)] = 76429, + [SMALL_STATE(1566)] = 76436, + [SMALL_STATE(1567)] = 76443, + [SMALL_STATE(1568)] = 76450, + [SMALL_STATE(1569)] = 76457, + [SMALL_STATE(1570)] = 76464, + [SMALL_STATE(1571)] = 76471, + [SMALL_STATE(1572)] = 76478, + [SMALL_STATE(1573)] = 76485, + [SMALL_STATE(1574)] = 76492, + [SMALL_STATE(1575)] = 76499, + [SMALL_STATE(1576)] = 76506, + [SMALL_STATE(1577)] = 76513, + [SMALL_STATE(1578)] = 76520, + [SMALL_STATE(1579)] = 76527, + [SMALL_STATE(1580)] = 76534, + [SMALL_STATE(1581)] = 76541, + [SMALL_STATE(1582)] = 76548, + [SMALL_STATE(1583)] = 76555, + [SMALL_STATE(1584)] = 76562, + [SMALL_STATE(1585)] = 76569, + [SMALL_STATE(1586)] = 76576, + [SMALL_STATE(1587)] = 76583, + [SMALL_STATE(1588)] = 76590, + [SMALL_STATE(1589)] = 76597, + [SMALL_STATE(1590)] = 76604, + [SMALL_STATE(1591)] = 76611, + [SMALL_STATE(1592)] = 76618, + [SMALL_STATE(1593)] = 76625, + [SMALL_STATE(1594)] = 76632, + [SMALL_STATE(1595)] = 76639, + [SMALL_STATE(1596)] = 76646, + [SMALL_STATE(1597)] = 76653, + [SMALL_STATE(1598)] = 76660, + [SMALL_STATE(1599)] = 76667, + [SMALL_STATE(1600)] = 76674, + [SMALL_STATE(1601)] = 76681, + [SMALL_STATE(1602)] = 76688, + [SMALL_STATE(1603)] = 76695, + [SMALL_STATE(1604)] = 76702, + [SMALL_STATE(1605)] = 76709, + [SMALL_STATE(1606)] = 76716, + [SMALL_STATE(1607)] = 76723, + [SMALL_STATE(1608)] = 76730, + [SMALL_STATE(1609)] = 76737, + [SMALL_STATE(1610)] = 76744, + [SMALL_STATE(1611)] = 76751, + [SMALL_STATE(1612)] = 76758, + [SMALL_STATE(1613)] = 76765, + [SMALL_STATE(1614)] = 76772, + [SMALL_STATE(1615)] = 76779, + [SMALL_STATE(1616)] = 76786, + [SMALL_STATE(1617)] = 76793, + [SMALL_STATE(1618)] = 76800, + [SMALL_STATE(1619)] = 76807, + [SMALL_STATE(1620)] = 76814, + [SMALL_STATE(1621)] = 76821, + [SMALL_STATE(1622)] = 76828, + [SMALL_STATE(1623)] = 76835, + [SMALL_STATE(1624)] = 76842, + [SMALL_STATE(1625)] = 76849, + [SMALL_STATE(1626)] = 76856, + [SMALL_STATE(1627)] = 76863, + [SMALL_STATE(1628)] = 76870, + [SMALL_STATE(1629)] = 76877, + [SMALL_STATE(1630)] = 76884, + [SMALL_STATE(1631)] = 76891, + [SMALL_STATE(1632)] = 76898, + [SMALL_STATE(1633)] = 76905, + [SMALL_STATE(1634)] = 76912, + [SMALL_STATE(1635)] = 76919, + [SMALL_STATE(1636)] = 76926, + [SMALL_STATE(1637)] = 76933, + [SMALL_STATE(1638)] = 76940, + [SMALL_STATE(1639)] = 76947, + [SMALL_STATE(1640)] = 76954, + [SMALL_STATE(1641)] = 76961, + [SMALL_STATE(1642)] = 76968, + [SMALL_STATE(1643)] = 76975, + [SMALL_STATE(1644)] = 76982, + [SMALL_STATE(1645)] = 76989, + [SMALL_STATE(1646)] = 76996, + [SMALL_STATE(1647)] = 77003, + [SMALL_STATE(1648)] = 77010, + [SMALL_STATE(1649)] = 77017, + [SMALL_STATE(1650)] = 77024, + [SMALL_STATE(1651)] = 77031, + [SMALL_STATE(1652)] = 77038, + [SMALL_STATE(1653)] = 77045, + [SMALL_STATE(1654)] = 77052, + [SMALL_STATE(1655)] = 77059, + [SMALL_STATE(1656)] = 77066, + [SMALL_STATE(1657)] = 77073, + [SMALL_STATE(1658)] = 77080, + [SMALL_STATE(1659)] = 77087, + [SMALL_STATE(1660)] = 77094, + [SMALL_STATE(1661)] = 77101, + [SMALL_STATE(1662)] = 77108, + [SMALL_STATE(1663)] = 77115, + [SMALL_STATE(1664)] = 77122, + [SMALL_STATE(1665)] = 77129, + [SMALL_STATE(1666)] = 77136, + [SMALL_STATE(1667)] = 77143, + [SMALL_STATE(1668)] = 77150, + [SMALL_STATE(1669)] = 77157, + [SMALL_STATE(1670)] = 77164, + [SMALL_STATE(1671)] = 77171, + [SMALL_STATE(1672)] = 77178, + [SMALL_STATE(1673)] = 77185, + [SMALL_STATE(1674)] = 77192, + [SMALL_STATE(1675)] = 77199, + [SMALL_STATE(1676)] = 77206, + [SMALL_STATE(1677)] = 77213, + [SMALL_STATE(1678)] = 77220, + [SMALL_STATE(1679)] = 77227, + [SMALL_STATE(1680)] = 77234, + [SMALL_STATE(1681)] = 77241, + [SMALL_STATE(1682)] = 77248, + [SMALL_STATE(1683)] = 77255, + [SMALL_STATE(1684)] = 77262, + [SMALL_STATE(1685)] = 77269, + [SMALL_STATE(1686)] = 77276, + [SMALL_STATE(1687)] = 77283, + [SMALL_STATE(1688)] = 77290, + [SMALL_STATE(1689)] = 77297, + [SMALL_STATE(1690)] = 77304, + [SMALL_STATE(1691)] = 77311, + [SMALL_STATE(1692)] = 77318, + [SMALL_STATE(1693)] = 77325, + [SMALL_STATE(1694)] = 77332, + [SMALL_STATE(1695)] = 77339, + [SMALL_STATE(1696)] = 77346, + [SMALL_STATE(1697)] = 77353, + [SMALL_STATE(1698)] = 77360, + [SMALL_STATE(1699)] = 77367, + [SMALL_STATE(1700)] = 77374, + [SMALL_STATE(1701)] = 77381, + [SMALL_STATE(1702)] = 77388, + [SMALL_STATE(1703)] = 77395, + [SMALL_STATE(1704)] = 77402, + [SMALL_STATE(1705)] = 77409, + [SMALL_STATE(1706)] = 77416, + [SMALL_STATE(1707)] = 77423, + [SMALL_STATE(1708)] = 77430, + [SMALL_STATE(1709)] = 77437, + [SMALL_STATE(1710)] = 77444, + [SMALL_STATE(1711)] = 77451, + [SMALL_STATE(1712)] = 77458, + [SMALL_STATE(1713)] = 77465, + [SMALL_STATE(1714)] = 77472, + [SMALL_STATE(1715)] = 77479, + [SMALL_STATE(1716)] = 77486, + [SMALL_STATE(1717)] = 77493, + [SMALL_STATE(1718)] = 77500, + [SMALL_STATE(1719)] = 77507, + [SMALL_STATE(1720)] = 77514, + [SMALL_STATE(1721)] = 77521, + [SMALL_STATE(1722)] = 77528, + [SMALL_STATE(1723)] = 77535, + [SMALL_STATE(1724)] = 77542, + [SMALL_STATE(1725)] = 77549, + [SMALL_STATE(1726)] = 77556, + [SMALL_STATE(1727)] = 77563, + [SMALL_STATE(1728)] = 77570, + [SMALL_STATE(1729)] = 77577, + [SMALL_STATE(1730)] = 77584, + [SMALL_STATE(1731)] = 77591, + [SMALL_STATE(1732)] = 77598, + [SMALL_STATE(1733)] = 77605, + [SMALL_STATE(1734)] = 77612, + [SMALL_STATE(1735)] = 77619, + [SMALL_STATE(1736)] = 77626, + [SMALL_STATE(1737)] = 77633, + [SMALL_STATE(1738)] = 77640, + [SMALL_STATE(1739)] = 77647, + [SMALL_STATE(1740)] = 77654, + [SMALL_STATE(1741)] = 77661, + [SMALL_STATE(1742)] = 77668, + [SMALL_STATE(1743)] = 77675, + [SMALL_STATE(1744)] = 77682, + [SMALL_STATE(1745)] = 77689, + [SMALL_STATE(1746)] = 77696, + [SMALL_STATE(1747)] = 77703, + [SMALL_STATE(1748)] = 77710, + [SMALL_STATE(1749)] = 77717, + [SMALL_STATE(1750)] = 77724, + [SMALL_STATE(1751)] = 77731, + [SMALL_STATE(1752)] = 77738, + [SMALL_STATE(1753)] = 77745, + [SMALL_STATE(1754)] = 77752, + [SMALL_STATE(1755)] = 77759, + [SMALL_STATE(1756)] = 77766, + [SMALL_STATE(1757)] = 77773, + [SMALL_STATE(1758)] = 77780, + [SMALL_STATE(1759)] = 77787, + [SMALL_STATE(1760)] = 77794, + [SMALL_STATE(1761)] = 77801, + [SMALL_STATE(1762)] = 77808, + [SMALL_STATE(1763)] = 77815, + [SMALL_STATE(1764)] = 77822, + [SMALL_STATE(1765)] = 77829, + [SMALL_STATE(1766)] = 77836, + [SMALL_STATE(1767)] = 77843, + [SMALL_STATE(1768)] = 77850, + [SMALL_STATE(1769)] = 77857, + [SMALL_STATE(1770)] = 77864, + [SMALL_STATE(1771)] = 77871, + [SMALL_STATE(1772)] = 77878, + [SMALL_STATE(1773)] = 77885, + [SMALL_STATE(1774)] = 77892, + [SMALL_STATE(1775)] = 77899, + [SMALL_STATE(1776)] = 77906, + [SMALL_STATE(1777)] = 77913, + [SMALL_STATE(1778)] = 77920, + [SMALL_STATE(1779)] = 77927, + [SMALL_STATE(1780)] = 77934, + [SMALL_STATE(1781)] = 77941, + [SMALL_STATE(1782)] = 77948, + [SMALL_STATE(1783)] = 77955, + [SMALL_STATE(1784)] = 77962, + [SMALL_STATE(1785)] = 77969, + [SMALL_STATE(1786)] = 77976, + [SMALL_STATE(1787)] = 77983, + [SMALL_STATE(1788)] = 77990, + [SMALL_STATE(1789)] = 77997, + [SMALL_STATE(1790)] = 78004, + [SMALL_STATE(1791)] = 78011, + [SMALL_STATE(1792)] = 78018, + [SMALL_STATE(1793)] = 78025, + [SMALL_STATE(1794)] = 78032, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -60239,1342 +73272,1699 @@ static const TSParseActionEntry ts_parse_actions[] = { [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), - [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(265), - [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1306), - [11] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1346), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1184), - [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1342), - [19] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1319), - [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1016), - [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), - [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1249), - [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(224), - [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(239), - [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1408), - [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1371), - [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(226), - [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(45), - [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(6), - [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1326), - [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1413), - [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1215), - [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1222), - [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1283), - [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(268), - [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332), - [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), - [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(824), - [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(266), - [65] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 1, 0, 0), - [67] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 1, 0, 0), - [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1372), - [71] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), - [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1009), - [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [77] = {.entry = {.count = 1, .reusable = false}}, SHIFT(225), - [79] = {.entry = {.count = 1, .reusable = false}}, SHIFT(34), - [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(256), - [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), - [85] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1391), - [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1392), - [89] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), - [91] = {.entry = {.count = 1, .reusable = false}}, SHIFT(227), - [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(228), - [95] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2), - [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1432), - [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1393), - [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1433), - [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1310), - [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(339), - [107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), - [109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(341), - [111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(222), - [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1430), - [115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1245), - [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1198), - [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1407), - [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1363), - [123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1009), - [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), - [127] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1364), - [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), - [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1369), - [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), - [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), - [137] = {.entry = {.count = 1, .reusable = false}}, SHIFT(263), - [139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1250), - [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1016), - [143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57), - [145] = {.entry = {.count = 1, .reusable = false}}, SHIFT(30), - [147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(264), - [149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), - [151] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(264), - [154] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1430), - [157] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1245), - [160] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1198), - [163] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(247), - [166] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1407), - [169] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1363), - [172] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1009), - [175] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(5), - [178] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), - [180] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1364), - [183] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(225), - [186] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(34), - [189] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(256), - [192] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(160), - [195] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1391), - [198] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1392), - [201] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(227), - [204] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(228), - [207] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(2), - [210] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1432), - [213] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1393), - [216] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1433), - [219] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1310), - [222] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1369), - [225] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(339), - [228] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(341), - [231] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(341), - [234] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(824), - [237] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(265), - [240] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1306), - [243] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1346), - [246] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1184), - [249] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(40), - [252] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1342), - [255] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1319), - [258] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1016), - [261] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(3), - [264] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1249), - [267] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(57), - [270] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(30), - [273] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(224), - [276] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(239), - [279] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1408), - [282] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1371), - [285] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(226), - [288] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(45), - [291] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(6), - [294] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1326), - [297] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1413), - [300] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1215), - [303] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1222), - [306] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1283), - [309] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(268), - [312] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(332), - [315] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(332), - [318] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), - [320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(507), - [322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(600), - [324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1361), - [326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), - [328] = {.entry = {.count = 1, .reusable = false}}, SHIFT(998), - [330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [332] = {.entry = {.count = 1, .reusable = false}}, SHIFT(217), - [334] = {.entry = {.count = 1, .reusable = false}}, SHIFT(31), - [336] = {.entry = {.count = 1, .reusable = false}}, SHIFT(255), - [338] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), - [340] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1366), - [342] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1367), - [344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), - [346] = {.entry = {.count = 1, .reusable = false}}, SHIFT(219), - [348] = {.entry = {.count = 1, .reusable = false}}, SHIFT(220), - [350] = {.entry = {.count = 1, .reusable = false}}, SHIFT(12), - [352] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1426), - [354] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1368), - [356] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1427), - [358] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1248), - [360] = {.entry = {.count = 1, .reusable = false}}, SHIFT(596), - [362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), - [364] = {.entry = {.count = 1, .reusable = false}}, SHIFT(633), - [366] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), - [368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(612), - [370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), - [372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(541), - [374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(609), - [376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), - [378] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1395), - [380] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1025), - [382] = {.entry = {.count = 1, .reusable = false}}, SHIFT(234), - [384] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1405), - [386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), - [388] = {.entry = {.count = 1, .reusable = false}}, SHIFT(235), - [390] = {.entry = {.count = 1, .reusable = false}}, SHIFT(236), - [392] = {.entry = {.count = 1, .reusable = false}}, SHIFT(19), - [394] = {.entry = {.count = 1, .reusable = false}}, SHIFT(724), - [396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), - [398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(998), - [400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(334), - [404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(642), - [406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), - [408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), - [410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(655), - [412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), - [414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [416] = {.entry = {.count = 1, .reusable = false}}, SHIFT(725), - [418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352), - [420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), - [422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(660), - [424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), - [428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), - [430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), - [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1025), - [436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), - [438] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), - [440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), - [442] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(258), - [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(98), - [447] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(826), - [450] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1100), - [453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), - [455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), - [457] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1086), - [460] = {.entry = {.count = 1, .reusable = false}}, SHIFT(237), - [462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 4, 0, 17), - [464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 4, 0, 17), - [466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), - [468] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), - [470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 5, 1, 1), - [472] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 5, 1, 1), - [474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_expression, 4, 0, 0), - [476] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_expression, 4, 0, 0), - [478] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), - [481] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), - [484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 80), - [486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 80), - [488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 3, 0, 0), - [490] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 3, 0, 0), - [492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recv_call, 4, 0, 0), - [494] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recv_call, 4, 0, 0), - [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), - [498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), - [500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_send_call, 6, 0, 0), - [502] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_send_call, 6, 0, 0), - [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), - [506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), - [508] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_literal, 3, 0, 0), - [510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_literal, 3, 0, 0), - [512] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 3, 0, 0), - [514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 3, 0, 0), - [516] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 3, 0, 0), - [518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 3, 0, 0), - [520] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 4), - [522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 4), - [524] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 5), - [526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), - [528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 5), - [530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), - [534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [536] = {.entry = {.count = 1, .reusable = false}}, SHIFT(154), - [538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), - [542] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 6), - [544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 6), - [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 41), - [548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 41), - [550] = {.entry = {.count = 1, .reusable = false}}, SHIFT(150), - [552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pipe_expression, 3, 0, 7), - [558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pipe_expression, 3, 0, 7), - [560] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 4, 0, 10), - [562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 10), - [564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1209), - [566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [570] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 4, 0, 0), - [572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 4, 0, 0), - [574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4, 0, 0), - [576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4, 0, 0), - [578] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), - [580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), - [582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 14), - [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 14), - [586] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 1), REDUCE(sym_update_expression, 4, 0, 18), - [589] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 1), REDUCE(sym_update_expression, 4, 0, 18), - [592] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression_statement, 1, 0, 0), - [594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), - [596] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(629), - [599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), - [601] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), - [604] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), - [607] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 6), - [609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 6), - [611] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 19), - [613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 19), - [615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1336), - [617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [621] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(302), - [624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 20), - [626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 20), - [628] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 21), - [630] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 21), - [632] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(277), - [635] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 52), - [637] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 52), - [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 2, 14), - [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 2, 14), - [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 26), - [645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 26), - [647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 29), - [649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 29), - [651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 41), - [653] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 41), - [655] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 33), - [657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 33), - [659] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 44), - [661] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 44), - [663] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), - [665] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), - [667] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), - [669] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), - [671] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 58), - [673] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 58), - [675] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 66), - [677] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 66), - [679] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 2), - [681] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 2), - [683] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), - [685] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), - [687] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_spawn_expression, 2, 0, 0), - [689] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_spawn_expression, 2, 0, 0), - [691] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 2, 0, 0), - [693] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 2, 0, 0), - [695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), - [697] = {.entry = {.count = 1, .reusable = false}}, SHIFT(218), - [699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), - [701] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 32), - [703] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 6, 0, 32), - [705] = {.entry = {.count = 1, .reusable = false}}, SHIFT(238), - [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), - [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), - [717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), - [719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 34), - [721] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 34), - [723] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(609), - [726] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 46), - [728] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 46), - [730] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 47), - [732] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 47), - [734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 53), - [736] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 7, 0, 53), - [738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 54), - [740] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 54), - [742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 60), - [744] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 60), - [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 63), - [748] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 63), - [750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 68), - [752] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 68), - [754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 69), - [756] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 69), - [758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 74), - [760] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 74), - [762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 77), - [764] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 77), - [766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 78), - [768] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 78), - [770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 83), - [772] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 83), - [774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 86), - [776] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 86), - [778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 89), - [780] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 89), - [782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 90), - [784] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 90), - [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 92), - [788] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 92), - [790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 93), - [792] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 93), - [794] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 96), - [796] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 96), - [798] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 97), - [800] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 97), - [802] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 99), - [804] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 99), - [806] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 102), - [808] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 102), - [810] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 104), - [812] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 104), - [814] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 105), - [816] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 105), - [818] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(326), - [821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 107), - [823] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 107), - [825] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 108), - [827] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 108), - [829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 109), - [831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 109), - [833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 111), - [835] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 111), - [837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 114), - [839] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 114), - [841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 115), - [843] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 115), - [845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 116), - [847] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 116), - [849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 117), - [851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 117), - [853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 119), - [855] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 14, 0, 119), - [857] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3, 0, 3), - [859] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 3), - [861] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 4, 0, 8), - [863] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 4, 0, 8), - [865] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 5, 0, 30), - [867] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 30), - [869] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(640), - [872] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(612), - [875] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(295), - [878] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(611), - [881] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(613), - [884] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 4, 0, 9), - [886] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 4, 0, 9), - [888] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1328), - [890] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), - [892] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), - [894] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1151), - [897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 50), - [899] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 7, 0, 50), - [901] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), - [903] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_union_type, 1, 0, 0), - [905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1151), - [907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 2, 0, 0), - [909] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_union_type, 2, 0, 0), - [911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 72), - [913] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 8, 0, 72), - [915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 31), - [917] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 5, 0, 31), - [919] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 1), - [921] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variant, 4, 0, 1), - [923] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 0), - [925] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 0), - [927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1349), - [929] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 1), - [931] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variant, 1, 0, 1), - [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), - [935] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1226), - [937] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1178), - [940] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 0), - [942] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 3, 0, 0), - [944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1246), - [946] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_import_statement_repeat1, 2, 0, 0), - [948] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(1246), - [951] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_statement_repeat1, 2, 0, 0), - [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1178), - [955] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), - [957] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 3, 0, 0), - [959] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(1349), - [962] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 31), - [964] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 6, 0, 31), - [966] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 106), - [968] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 106), - [970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 35), - [972] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 35), - [974] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 110), - [976] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 110), - [978] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 48), - [980] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 48), - [982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 112), - [984] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 112), - [986] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 113), - [988] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 113), - [990] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 36), - [992] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 36), - [994] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 118), - [996] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 118), - [998] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), - [1000] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_identifier, 1, 0, 0), - [1002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(823), - [1004] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), SHIFT(858), - [1007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1082), - [1009] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 37), - [1011] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 6, 0, 37), - [1013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(836), - [1015] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 55), - [1017] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 55), - [1019] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 5, 0, 24), - [1021] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 24), - [1023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), - [1025] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 56), - [1027] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 56), - [1029] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 57), - [1031] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 7, 0, 57), - [1033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(851), - [1035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(833), - [1037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 59), - [1039] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 59), - [1041] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 6, 0, 43), - [1043] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 43), - [1045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(834), - [1047] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), - [1049] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_validation, 2, 0, 0), - [1051] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 45), - [1053] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 45), - [1055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 62), - [1057] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 62), - [1059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), - [1061] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 50), - [1063] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 8, 0, 50), - [1065] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 103), - [1067] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 103), - [1069] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), - [1071] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), - [1073] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 67), - [1075] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 67), - [1077] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 70), - [1079] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 70), - [1081] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 75), - [1083] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 75), - [1085] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 76), - [1087] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 76), - [1089] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 79), - [1091] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 79), - [1093] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 82), - [1095] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 82), - [1097] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 84), - [1099] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 84), - [1101] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 85), - [1103] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 85), - [1105] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 72), - [1107] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 9, 0, 72), - [1109] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 88), - [1111] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 88), - [1113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(827), - [1115] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), SHIFT(877), - [1118] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 91), - [1120] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 91), - [1122] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 42), - [1124] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 42), - [1126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 94), - [1128] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 94), - [1130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 23), - [1132] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 5, 0, 23), - [1134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(852), - [1136] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 9), - [1138] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 5, 0, 9), - [1140] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 95), - [1142] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 95), - [1144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), - [1146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 98), - [1148] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 98), - [1150] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 100), - [1152] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 100), - [1154] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 101), - [1156] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 101), - [1158] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 61), - [1160] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 61), - [1162] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 24), - [1164] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 24), - [1166] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 0), - [1168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 0), - [1170] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 5, 0, 13), - [1172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 13), - [1174] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 13), - [1176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 13), - [1178] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 5, 0, 24), - [1180] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 24), - [1182] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 24), - [1184] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 24), - [1186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), - [1188] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), - [1190] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_generic_type, 4, 0, 1), - [1192] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_generic_type, 4, 0, 1), - [1194] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 1), - [1196] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_type, 4, 0, 1), - [1198] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 6, 0, 24), - [1200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 24), - [1202] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 7, 0, 49), - [1204] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 49), - [1206] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 7, 0, 51), - [1208] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 51), - [1210] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 5, 0, 0), - [1212] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 5, 0, 0), - [1214] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 64), - [1216] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 8, 0, 64), - [1218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 51), - [1220] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 8, 0, 51), - [1222] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 6, 0, 0), - [1224] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 6, 0, 0), - [1226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 8, 0, 71), - [1228] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 71), - [1230] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 8, 0, 73), - [1232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 73), - [1234] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 9, 0, 87), - [1236] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 87), - [1238] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 9, 0, 73), - [1240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 73), - [1242] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1068), - [1245] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 13), - [1247] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 4, 0, 13), - [1249] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 13), - [1251] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 4, 0, 13), - [1253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1229), - [1255] = {.entry = {.count = 1, .reusable = false}}, SHIFT(99), - [1257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [1259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1207), - [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [1263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [1265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), - [1267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [1269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [1271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [1273] = {.entry = {.count = 1, .reusable = false}}, SHIFT(103), - [1275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), - [1277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), - [1279] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 28), - [1281] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 28), - [1283] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 28), - [1285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 28), - [1287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), - [1289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), - [1291] = {.entry = {.count = 1, .reusable = false}}, SHIFT(205), - [1293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), - [1295] = {.entry = {.count = 1, .reusable = false}}, SHIFT(201), - [1297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1177), - [1299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [1301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), - [1303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), - [1305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), - [1307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), - [1309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), - [1311] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), - [1314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [1316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(345), - [1318] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), - [1320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(651), - [1322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), - [1324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), - [1326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 11), - [1328] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 3), - [1330] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 38), - [1332] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 25), - [1334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 12), - [1336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 3), - [1338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), - [1340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), - [1342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), - [1344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), - [1346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(653), - [1348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [1350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), - [1352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), - [1354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), - [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), - [1358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), - [1360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), - [1362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(621), - [1364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [1366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [1368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), - [1370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1437), - [1372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), - [1374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(654), - [1376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), - [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301), - [1380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), - [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), - [1384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), - [1386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), - [1388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350), - [1390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), - [1392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), - [1394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), - [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(657), - [1398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), - [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1289), - [1402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), - [1404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), - [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), - [1408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(777), - [1410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(776), - [1412] = {.entry = {.count = 1, .reusable = false}}, SHIFT(840), - [1414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1174), - [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), - [1418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(794), - [1420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1179), - [1422] = {.entry = {.count = 1, .reusable = false}}, SHIFT(972), - [1424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), - [1426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(649), - [1428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [1430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), - [1432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(779), - [1434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), - [1436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [1438] = {.entry = {.count = 1, .reusable = false}}, SHIFT(891), - [1440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), - [1442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), - [1444] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(891), - [1447] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1174), - [1450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), - [1452] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(794), - [1455] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1179), - [1458] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(972), - [1461] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(596), - [1464] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(972), - [1467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), - [1469] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), - [1471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), - [1473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(652), - [1475] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(891), - [1478] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1174), - [1481] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), - [1483] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(794), - [1486] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1179), - [1489] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(972), - [1492] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(596), - [1495] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(972), - [1498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), - [1500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), - [1502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1400), - [1504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), - [1506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), - [1508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), - [1510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), - [1512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1319), - [1514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(538), - [1516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(603), - [1518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(540), - [1520] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1307), - [1523] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1223), - [1526] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1319), - [1529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), - [1531] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(824), - [1534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(551), - [1536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(533), - [1538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(615), - [1540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(557), - [1542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), - [1544] = {.entry = {.count = 1, .reusable = false}}, SHIFT(800), - [1546] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1230), - [1548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(818), - [1550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1233), - [1552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1216), - [1554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), - [1556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1256), - [1558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1313), - [1560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1261), - [1562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1168), - [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doc_comment, 1, 0, 0), - [1566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(825), - [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), - [1570] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), SHIFT_REPEAT(825), - [1573] = {.entry = {.count = 1, .reusable = false}}, SHIFT(519), - [1575] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1399), - [1577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(817), - [1579] = {.entry = {.count = 1, .reusable = false}}, SHIFT(487), - [1581] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1380), - [1583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), - [1585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), - [1587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(822), - [1589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(798), - [1591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1161), - [1593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), - [1595] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 1), - [1597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1262), - [1599] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1410), - [1601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1411), - [1603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), - [1605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1375), - [1607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1376), - [1609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1370), - [1611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1401), - [1613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), - [1615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1218), - [1617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1384), - [1619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1421), - [1621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [1623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(863), - [1625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), - [1627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1099), - [1629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [1631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(847), - [1633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), - [1635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [1637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(882), - [1639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), - [1641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [1643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(883), - [1645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), - [1647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(884), - [1649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [1651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(867), - [1653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), - [1655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), - [1657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), - [1659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(886), - [1661] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 1), - [1663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(826), - [1665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), - [1667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(865), - [1669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [1671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(868), - [1673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [1675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(866), - [1677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [1679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), - [1681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), - [1683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), - [1685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), - [1687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), - [1689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), - [1691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), - [1693] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_statement, 1, 0, 0), - [1695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [1697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(850), - [1699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [1701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), - [1703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [1705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(857), - [1707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [1709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), - [1711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), - [1713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(864), - [1715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [1717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), - [1719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), - [1721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(881), - [1723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [1725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(870), - [1727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), - [1729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(871), - [1731] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1194), - [1733] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1334), - [1735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [1737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [1739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [1741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [1743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(463), - [1745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1106), - [1747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [1749] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [1751] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [1753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [1755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(489), - [1757] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1074), - [1759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [1761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [1763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [1765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), - [1767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [1769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), - [1771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), - [1773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), - [1775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), - [1777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [1779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [1781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [1783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [1785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [1787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), - [1789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), - [1791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1014), - [1793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), - [1795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), - [1797] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1195), - [1799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(908), - [1801] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1117), - [1803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [1805] = {.entry = {.count = 1, .reusable = false}}, SHIFT(970), - [1807] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48), - [1809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), - [1811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1320), - [1813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), - [1815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), - [1817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), - [1819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(914), - [1821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1159), - [1823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), - [1825] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), - [1827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1335), - [1829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(572), - [1831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(565), - [1833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1377), - [1835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(527), - [1837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(920), - [1839] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 81), - [1841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 0), - [1843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(610), - [1845] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), - [1847] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 65), - [1849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 1), - [1851] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 27), - [1853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 39), - [1855] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 1), - [1857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(581), - [1859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), - [1861] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(42), - [1864] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 11), - [1866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), - [1868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1260), - [1870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1156), - [1872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(568), - [1874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(599), - [1876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), - [1878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), - [1880] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 1), - [1882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(906), - [1884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(601), - [1886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(905), - [1888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(602), - [1890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1251), - [1892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1152), - [1894] = {.entry = {.count = 1, .reusable = false}}, SHIFT(109), - [1896] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_list_repeat1, 2, 0, 0), - [1898] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_list_repeat1, 2, 0, 0), SHIFT_REPEAT(846), - [1901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(909), - [1903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(889), - [1905] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 1), - [1907] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), - [1909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1294), - [1911] = {.entry = {.count = 1, .reusable = true}}, SHIFT(918), - [1913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(492), - [1915] = {.entry = {.count = 1, .reusable = true}}, SHIFT(537), - [1917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), - [1919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), - [1921] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), - [1923] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1195), - [1926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(592), - [1928] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(970), - [1931] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), - [1933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1231), - [1935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1170), - [1937] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1335), - [1940] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), - [1942] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), - [1944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), - [1946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(550), - [1948] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 15), - [1950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(583), - [1952] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), - [1954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 16), - [1956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(617), - [1958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(555), - [1960] = {.entry = {.count = 1, .reusable = false}}, SHIFT(210), - [1962] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), - [1964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1185), - [1966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [1968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), - [1970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1254), - [1972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), - [1974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [1976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [1978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [1980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), - [1982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), - [1984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), - [1986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), - [1988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [1990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), - [1992] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1051), - [1995] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), - [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), - [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(797), - [2001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [2003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [2005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), - [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [2009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [2011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), - [2013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [2015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), - [2019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [2021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), - [2023] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), - [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), - [2027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(970), - [2029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), - [2031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [2033] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), - [2035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), - [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1165), - [2039] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), - [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1160), - [2043] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), - [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1412), - [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), - [2049] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), - [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(638), - [2055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), - [2057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), - [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), - [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [2063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), - [2065] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), - [2067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [2069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [2071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [2073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(639), - [2075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [2077] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), - [2079] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(988), - [2082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(620), - [2084] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 11), - [2086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [2088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [2090] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), - [2092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(903), - [2094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1109), - [2096] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), - [2098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), - [2100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), - [2102] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1160), - [2105] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), - [2107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), - [2109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), - [2111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), - [2113] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(797), - [2116] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1190), - [2119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), - [2121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [2123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(795), - [2125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(991), - [2127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [2129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [2131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 11), - [2133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), - [2135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), - [2137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), - [2139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), - [2141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), - [2143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [2145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), - [2147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [2149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), - [2151] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 40), SHIFT_REPEAT(799), - [2154] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 40), - [2156] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1165), - [2159] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), - [2161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [2163] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), - [2165] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1185), - [2168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [2170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(796), - [2172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), - [2174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [2176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), - [2178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), - [2180] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1300), - [2183] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), - [2185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), - [2187] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), - [2189] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1191), - [2192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), - [2194] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(28), - [2197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), - [2199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [2201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [2203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), - [2205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), - [2207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [2209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [2211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [2213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), - [2215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), - [2217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), - [2219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), - [2221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), - [2223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(873), - [2225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), - [2227] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 11), - [2229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), - [2231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), - [2233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(879), - [2235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), - [2237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), - [2239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), - [2241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), - [2243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), - [2245] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), - [2247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(829), - [2249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [2251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), - [2253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(859), - [2255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), - [2257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(955), - [2259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(959), - [2261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(860), - [2263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), - [2265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(854), - [2267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [2269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), - [2271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(982), - [2273] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 11), - [2275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(887), - [2277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [2279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(888), - [2281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), - [2283] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 27), - [2285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), - [2287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(934), - [2289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(952), - [2291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(958), - [2293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(961), - [2295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), - [2297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), - [2299] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1031), - [2301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(962), - [2303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1021), - [2305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(930), - [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(969), - [2309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(946), - [2311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(950), - [2313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1181), - [2315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), - [2317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1340), - [2319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(872), - [2321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [2323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), - [2325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), - [2327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), - [2329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 22), - [2331] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 1), - [2333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1200), - [2335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), - [2337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(963), - [2339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1002), - [2341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(964), - [2343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1003), - [2345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(965), - [2347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1013), - [2349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), - [2351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1017), - [2353] = {.entry = {.count = 1, .reusable = true}}, SHIFT(951), - [2355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1006), - [2357] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), - [2359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), - [2361] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [2363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [2365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), - [2367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(997), - [2369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1286), - [2371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(841), - [2373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(623), - [2375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1173), - [2377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1221), - [2379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [2381] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), - [2383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [2385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1203), - [2387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), - [2389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(496), - [2391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(544), - [2393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), - [2395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(926), - [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(631), - [2399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(820), - [2401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), - [2403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(835), - [2405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), - [2407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(546), - [2409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(547), - [2411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [2413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), - [2415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), - [2417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), - [2419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1315), - [2421] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), - [2423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(978), - [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1150), - [2427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), - [2429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), - [2431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [2433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1206), - [2435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [2437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1282), - [2439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [2441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), - [2443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), - [2445] = {.entry = {.count = 1, .reusable = true}}, SHIFT(862), - [2447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), - [2449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(807), - [2451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), - [2453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(843), - [2455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1162), - [2457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1163), - [2459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(646), - [2461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), - [2463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(838), - [2465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), - [2467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1189), - [2469] = {.entry = {.count = 1, .reusable = true}}, SHIFT(808), - [2471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(890), - [2473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(803), - [2475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), - [2477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(895), - [2479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), - [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1227), - [2483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), - [2485] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [2487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(953), - [2489] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [2491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [2493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1305), - [2495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1029), - [2497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), - [2499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1219), - [2501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(461), - [2503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), - [2505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1147), - [2507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1266), - [2509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298), - [2511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(904), - [2513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), - [2515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), - [2517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), - [2519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), - [2521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(979), - [2523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(900), - [2525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(813), - [2527] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1199), - [2529] = {.entry = {.count = 1, .reusable = true}}, SHIFT(917), - [2531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [2533] = {.entry = {.count = 1, .reusable = true}}, SHIFT(907), - [2535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), - [2537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), - [2539] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1186), - [2541] = {.entry = {.count = 1, .reusable = true}}, SHIFT(812), - [2543] = {.entry = {.count = 1, .reusable = true}}, SHIFT(839), - [2545] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [2547] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), - [2549] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1397), - [2551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(832), - [2553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [2555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), - [2557] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), - [2559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(605), - [2561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1183), - [2563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1154), - [2565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(606), - [2567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1155), - [2569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), - [2571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [2573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), - [2575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), - [2577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(500), - [2579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [2581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1041), - [2583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), - [2585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(975), - [2587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), - [2589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(892), - [2591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(333), - [2593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1333), - [2595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1119), - [2597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1362), - [2599] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), - [2601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), - [2603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(957), - [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(637), - [2607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(899), - [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1157), - [2611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), - [2613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), - [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), - [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(902), - [2619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), - [2621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1390), - [2623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), - [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1228), - [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), - [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1235), - [2631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1302), - [2633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1171), - [2635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), - [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(311), - [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(999), - [2641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(849), - [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1175), - [2645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1176), - [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), - [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1064), - [2651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(791), - [2653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), - [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1259), - [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1166), - [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(793), - [2661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), - [2663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1072), - [2665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1180), - [2667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), - [2669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(842), - [2671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1435), - [2673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), - [2675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), - [2677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), - [2679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1284), - [2681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), - [2683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1210), - [2685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), - [2687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(490), - [2689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1005), - [2691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), - [2693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), - [2695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(983), - [2697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), - [2699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(792), - [2701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), - [2703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), - [2705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), - [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1104), - [2709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1329), - [2711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(819), - [2713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1351), - [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1167), - [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), - [2719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1020), - [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(967), - [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1125), - [2725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), - [2727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1373), - [2729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1142), - [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1379), - [2733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1202), - [2735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1382), - [2737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), - [2739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), - [2741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1385), - [2743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1387), - [2745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), - [2747] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1389), - [2749] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [2751] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1398), - [2753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1205), - [2755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), - [2757] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1402), - [2759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), - [2761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1404), - [2763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), - [2765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), - [2767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1409), - [2769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1234), - [2771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(912), - [2773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(468), - [2775] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [2777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), - [2779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1419), - [2781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [2783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1015), - [2785] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), - [2787] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), - [2789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323), - [2791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1214), - [2793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1324), - [2795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(984), + [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(34), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1178), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1302), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1599), + [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1459), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1672), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1679), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1203), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1770), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(116), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(117), + [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1439), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1788), + [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(166), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(333), + [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(19), + [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1513), + [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1522), + [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1492), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1697), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1741), + [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1478), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1525), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(46), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(78), + [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(968), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(27), + [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1170), + [73] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [77] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1334), + [79] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1548), + [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1482), + [83] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), + [85] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1750), + [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1694), + [89] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1243), + [91] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1695), + [93] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), + [95] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(361), + [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(365), + [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1483), + [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1698), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(330), + [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(331), + [109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(5), + [111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1775), + [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1699), + [115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1499), + [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1551), + [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1751), + [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1484), + [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1701), + [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(154), + [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(155), + [131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(771), + [135] = {.entry = {.count = 1, .reusable = false}}, SHIFT(37), + [137] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 1, 0, 0), + [139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 1, 0, 0), + [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1704), + [143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1243), + [145] = {.entry = {.count = 1, .reusable = false}}, SHIFT(329), + [147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(67), + [149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(35), + [151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(714), + [153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(712), + [155] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), + [157] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(34), + [160] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1178), + [163] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(2), + [166] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1302), + [169] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1599), + [172] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1459), + [175] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(199), + [178] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1672), + [181] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1679), + [184] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1203), + [187] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1770), + [190] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(337), + [193] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(65), + [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(116), + [199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(117), + [202] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1439), + [205] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1788), + [208] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(166), + [211] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(333), + [214] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(19), + [217] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1513), + [220] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1522), + [223] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1492), + [226] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1697), + [229] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1741), + [232] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1478), + [235] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1525), + [238] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(46), + [241] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(78), + [244] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(78), + [247] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(968), + [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(620), + [252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(634), + [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(544), + [256] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), + [258] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(35), + [261] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1170), + [264] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(3), + [267] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1334), + [270] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1548), + [273] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1482), + [276] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(346), + [279] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1750), + [282] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1694), + [285] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1243), + [288] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1695), + [291] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(329), + [294] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(67), + [297] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(361), + [300] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(365), + [303] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1483), + [306] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1698), + [309] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(330), + [312] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(331), + [315] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(5), + [318] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1775), + [321] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1699), + [324] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1499), + [327] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1551), + [330] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1751), + [333] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1484), + [336] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(1701), + [339] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(154), + [342] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(155), + [345] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(155), + [348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), + [350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(631), + [352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(653), + [354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(640), + [356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [358] = {.entry = {.count = 1, .reusable = false}}, SHIFT(32), + [360] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1553), + [362] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1203), + [364] = {.entry = {.count = 1, .reusable = false}}, SHIFT(337), + [366] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), + [368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(730), + [370] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1735), + [372] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1264), + [374] = {.entry = {.count = 1, .reusable = false}}, SHIFT(343), + [376] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1496), + [378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), + [380] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), + [382] = {.entry = {.count = 1, .reusable = false}}, SHIFT(345), + [384] = {.entry = {.count = 1, .reusable = false}}, SHIFT(22), + [386] = {.entry = {.count = 1, .reusable = false}}, SHIFT(718), + [388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [390] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1752), + [392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(353), + [394] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1255), + [396] = {.entry = {.count = 1, .reusable = false}}, SHIFT(336), + [398] = {.entry = {.count = 1, .reusable = false}}, SHIFT(77), + [400] = {.entry = {.count = 1, .reusable = false}}, SHIFT(362), + [402] = {.entry = {.count = 1, .reusable = false}}, SHIFT(92), + [404] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1493), + [406] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1732), + [408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), + [410] = {.entry = {.count = 1, .reusable = false}}, SHIFT(91), + [412] = {.entry = {.count = 1, .reusable = false}}, SHIFT(338), + [414] = {.entry = {.count = 1, .reusable = false}}, SHIFT(23), + [416] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1783), + [418] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1733), + [420] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1417), + [422] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1630), + [424] = {.entry = {.count = 1, .reusable = false}}, SHIFT(720), + [426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), + [428] = {.entry = {.count = 1, .reusable = false}}, SHIFT(723), + [430] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), + [432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified_path, 2, 0, 0), + [434] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_qualified_path, 2, 0, 0), + [436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1767), + [438] = {.entry = {.count = 1, .reusable = false}}, SHIFT(857), + [440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1255), + [444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [448] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), + [450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), + [452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1557), + [454] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1342), + [457] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(107), + [460] = {.entry = {.count = 1, .reusable = false}}, SHIFT(165), + [462] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1008), + [465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), + [471] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), + [473] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1767), + [476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(738), + [478] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1299), + [481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(764), + [483] = {.entry = {.count = 1, .reusable = false}}, SHIFT(335), + [485] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1402), + [488] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1557), + [491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 2, 23), + [493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 2, 23), + [495] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 28), + [498] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 28), + [501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 13), + [503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 13), + [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 30), + [507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 30), + [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), + [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), + [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), + [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), + [517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(334), + [519] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), + [522] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), REDUCE(sym_map_literal, 2, 0, 0), + [525] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 5, 1, 4), + [527] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 5, 1, 4), + [529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_send_call, 6, 0, 0), + [531] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_send_call, 6, 0, 0), + [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 56), + [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 56), + [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 75), + [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 75), + [541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 56), + [543] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 56), + [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 109), + [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 109), + [549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), + [551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), + [553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_literal, 3, 0, 0), + [555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_literal, 3, 0, 0), + [557] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1345), + [560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 3, 0, 0), + [562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 3, 0, 0), + [564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), + [566] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), + [568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), + [570] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), + [572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 3, 0, 0), + [574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 3, 0, 0), + [576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [578] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 3, 0, 0), + [580] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 3, 0, 0), + [582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 2, 0, 0), + [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 2, 0, 0), + [588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), + [594] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 11), + [596] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 11), + [598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 13), + [600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 13), + [602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pipe_expression, 3, 0, 14), + [604] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pipe_expression, 3, 0, 14), + [606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1517), + [608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [612] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_literal, 4, 0, 0), + [614] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_literal, 4, 0, 0), + [616] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4, 0, 0), + [618] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4, 0, 0), + [620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(727), + [622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), + [624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), + [626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), + [628] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), + [630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(735), + [632] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 23), + [634] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 23), + [636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [638] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_expression, 4, 0, 0), + [640] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_expression, 4, 0, 0), + [642] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), + [645] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_primary_expression, 3, 0, 0), REDUCE(sym_await_call, 4, 0, 0), + [648] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recv_call, 4, 0, 0), + [650] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recv_call, 4, 0, 0), + [652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), + [654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 4, 0, 26), + [656] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 4, 0, 26), + [658] = {.entry = {.count = 1, .reusable = false}}, SHIFT(836), + [660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), + [662] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression_statement, 1, 0, 0), + [664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1613), + [666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1500), + [668] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(55), + [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), + [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [675] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168), + [677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [689] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), + [691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(349), + [695] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), + [697] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 5), + [699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 5), + [701] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_spawn_expression, 2, 0, 0), + [703] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_spawn_expression, 2, 0, 0), + [705] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield_expression, 2, 0, 0), + [707] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield_expression, 2, 0, 0), + [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), + [711] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 12), + [713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 12), + [715] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 4, 0, 21), + [717] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), + [719] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 29), + [721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 29), + [723] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 33), + [725] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 33), + [727] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 37), + [729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 37), + [731] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 43), + [733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 43), + [735] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 48), + [737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 48), + [739] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 67), + [741] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 67), + [743] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 84), + [745] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 84), + [747] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 95), + [749] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 95), + [751] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1264), + [753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), + [755] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(174), + [758] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(730), + [761] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 143), + [763] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 143), + [765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1461), + [767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), + [769] = {.entry = {.count = 1, .reusable = false}}, SHIFT(341), + [771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), + [779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [781] = {.entry = {.count = 1, .reusable = false}}, SHIFT(340), + [783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [785] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 44), + [787] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 5, 0, 44), + [789] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 6, 0, 47), + [791] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 47), + [793] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 49), + [795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 49), + [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 103), + [799] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 103), + [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 97), + [803] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 97), + [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 106), + [807] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 106), + [809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 107), + [811] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 107), + [813] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 69), + [815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 69), + [817] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 70), + [819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 70), + [821] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 7, 0, 78), + [823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 78), + [825] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 79), + [827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 79), + [829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 115), + [831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 115), + [833] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 86), + [835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 86), + [837] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 89), + [839] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 89), + [841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 118), + [843] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 118), + [845] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 98), + [847] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 98), + [849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 121), + [851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 121), + [853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 122), + [855] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 122), + [857] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 124), + [859] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 124), + [861] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 127), + [863] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 127), + [865] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(712), + [868] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 130), + [870] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 130), + [872] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 131), + [874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 131), + [876] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 133), + [878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 133), + [880] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 136), + [882] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 136), + [884] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 142), + [886] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 142), + [888] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 145), + [890] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 145), + [892] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 146), + [894] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 146), + [896] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 147), + [898] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 147), + [900] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 151), + [902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 151), + [904] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 154), + [906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 154), + [908] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 155), + [910] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 155), + [912] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 158), + [914] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 158), + [916] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 159), + [918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 159), + [920] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 10), + [922] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3, 0, 10), + [924] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 162), + [926] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 14, 0, 162), + [928] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(76), + [931] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(192), + [934] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(714), + [937] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 4, 0, 19), + [939] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 4, 0, 19), + [941] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(744), + [944] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(713), + [947] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(672), + [950] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1544), + [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1544), + [955] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 4), + [957] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variant, 1, 0, 4), + [959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1416), + [961] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_type, 4, 0, 4), + [963] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_type, 4, 0, 4), + [965] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), + [967] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_identifier, 1, 0, 0), + [969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1011), + [971] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), SHIFT(1060), + [974] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_generic_type, 4, 0, 4), + [976] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_generic_type, 4, 0, 4), + [978] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 6, 0, 0), + [980] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 6, 0, 0), + [982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 5, 0, 0), + [984] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 5, 0, 0), + [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1546), + [988] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1546), + [991] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), + [993] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), + [995] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1364), + [998] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_name, 1, 0, 0), + [1000] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_name, 1, 0, 0), + [1002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1560), + [1004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1661), + [1006] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 2, 0, 0), + [1008] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_union_type, 2, 0, 0), + [1010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1364), + [1012] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 4, 0, 20), + [1014] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 4, 0, 20), + [1016] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1614), + [1018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1360), + [1020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1015), + [1022] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), + [1024] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_union_type, 1, 0, 0), + [1026] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 101), + [1028] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 8, 0, 101), + [1030] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), + [1032] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), + [1034] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), SHIFT(1079), + [1037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 73), + [1039] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 7, 0, 73), + [1041] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 45), + [1043] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 5, 0, 45), + [1045] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), + [1047] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_target, 1, 0, 3), + [1049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), + [1051] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 102), + [1053] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 9, 0, 102), + [1055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), + [1057] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), + [1059] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), SHIFT_REPEAT(1615), + [1062] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), SHIFT_REPEAT(1715), + [1065] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 8), + [1067] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 5, 0, 8), + [1069] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), + [1071] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_target, 2, 0, 7), + [1073] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 31), + [1075] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 5, 0, 31), + [1077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), + [1079] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), + [1081] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_alias, 1, -1, 0), + [1083] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), + [1085] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 3, 0, 0), + [1087] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 102), + [1089] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 8, 0, 102), + [1091] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), + [1093] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 2), + [1095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1444), + [1097] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1511), + [1099] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), + [1101] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variant, 4, 0, 4), + [1103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), + [1105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1706), + [1107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 74), + [1109] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 7, 0, 74), + [1111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 8), + [1113] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 4, 0, 8), + [1115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 74), + [1117] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 8, 0, 74), + [1119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 31), + [1121] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 6, 0, 31), + [1123] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 152), + [1125] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 152), + [1127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 42), + [1129] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 42), + [1131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 20), + [1133] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 5, 0, 20), + [1135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 101), + [1137] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 9, 0, 101), + [1139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 62), + [1141] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 62), + [1143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 45), + [1145] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 6, 0, 45), + [1147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1595), + [1149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 64), + [1151] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 64), + [1153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 46), + [1155] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 46), + [1157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 65), + [1159] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 65), + [1161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 31), + [1163] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 6, 0, 31), + [1165] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 132), + [1167] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 132), + [1169] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 68), + [1171] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 68), + [1173] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_legacy_import_path, 2, 0, 0), + [1175] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), + [1177] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 46), + [1179] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 46), + [1181] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 50), + [1183] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 50), + [1185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 71), + [1187] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 71), + [1189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 72), + [1191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 7, 0, 72), + [1193] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 120), + [1195] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 120), + [1197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 108), + [1199] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 108), + [1201] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 134), + [1203] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 134), + [1205] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1361), + [1208] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 135), + [1210] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 135), + [1212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), + [1214] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 4, 0, 8), + [1216] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), + [1218] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), + [1220] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 51), + [1222] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 51), + [1224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 141), + [1226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 141), + [1228] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 123), + [1230] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 123), + [1232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 31), + [1234] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 5, 0, 31), + [1236] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 144), + [1238] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 144), + [1240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 100), + [1242] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 8, 0, 100), + [1244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), + [1246] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 114), + [1248] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 114), + [1250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 57), + [1252] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 57), + [1254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 99), + [1256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 99), + [1258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 148), + [1260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 148), + [1262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), + [1264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_validation, 2, 0, 0), + [1266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 96), + [1268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 96), + [1270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 153), + [1272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 153), + [1274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 27), + [1276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 4, 0, 27), + [1278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), + [1280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), + [1282] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1560), + [1285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 116), + [1287] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 116), + [1289] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), + [1291] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), + [1293] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 80), + [1295] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 80), + [1297] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1661), + [1300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 27), + [1302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 27), + [1304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 81), + [1306] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 81), + [1308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 128), + [1310] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 128), + [1312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 104), + [1314] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 104), + [1316] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 117), + [1318] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 117), + [1320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 160), + [1322] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 160), + [1324] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 83), + [1326] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 8, 0, 83), + [1328] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 129), + [1330] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 129), + [1332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 64), + [1334] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 64), + [1336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 83), + [1338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 83), + [1340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 65), + [1342] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 65), + [1344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 35), + [1346] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 5, 0, 35), + [1348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 42), + [1350] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 42), + [1352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 85), + [1354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 85), + [1356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 105), + [1358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 105), + [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 8), + [1362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 5, 0, 8), + [1364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 87), + [1366] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 87), + [1368] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 119), + [1370] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 9, 0, 119), + [1372] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 88), + [1374] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 88), + [1376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 90), + [1378] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 8, 0, 90), + [1380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 40), + [1382] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 40), + [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 73), + [1386] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 8, 0, 73), + [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 57), + [1390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 57), + [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 40), + [1394] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 40), + [1396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 63), + [1398] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 6, 0, 63), + [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1078), + [1402] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 7, 0, 82), + [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 82), + [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1038), + [1408] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 5, 0, 31), + [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 31), + [1412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), + [1414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), + [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), + [1418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1056), + [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 52), + [1422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 6, 0, 52), + [1424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), + [1426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), + [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), + [1430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 3, 0, 8), + [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 0), + [1434] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 0), + [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), + [1438] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 2, 0, 0), + [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 15), + [1442] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 2, 0, 15), + [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), + [1446] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_body, 2, 0, 0), + [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), + [1450] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 1), + [1452] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 3, 0, 6), + [1454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), + [1456] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 3, 0, 9), + [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), + [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 31), + [1462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 4, 0, 31), + [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 32), + [1466] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 4, 0, 32), + [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), + [1470] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 3, 0, 0), + [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), + [1474] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_body, 3, 0, 0), + [1476] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 4, 0, 0), + [1478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), + [1480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1747), + [1482] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1747), + [1485] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1373), + [1488] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1374), + [1491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1753), + [1493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [1495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [1497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [1499] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), + [1501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [1503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(356), + [1505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1502), + [1507] = {.entry = {.count = 1, .reusable = false}}, SHIFT(263), + [1509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [1511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [1513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [1515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [1517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1504), + [1519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [1521] = {.entry = {.count = 1, .reusable = false}}, SHIFT(315), + [1523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [1525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), + [1527] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), + [1529] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), + [1531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), + [1533] = {.entry = {.count = 1, .reusable = false}}, SHIFT(314), + [1535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), + [1537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 39), + [1539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 39), + [1541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 39), + [1543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 39), + [1545] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [1547] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1627), + [1549] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1590), + [1551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1790), + [1553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1729), + [1555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1770), + [1557] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1741), + [1559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1478), + [1561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), + [1563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1525), + [1565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), + [1567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(584), + [1569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(516), + [1571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(529), + [1573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(595), + [1575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(553), + [1577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), + [1579] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1627), + [1582] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1590), + [1585] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1790), + [1588] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1729), + [1591] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1770), + [1594] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1741), + [1597] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1478), + [1600] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(874), + [1603] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1525), + [1606] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(968), + [1609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(567), + [1611] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), + [1614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1549), + [1616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(522), + [1618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), + [1620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(580), + [1622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), + [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(582), + [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(574), + [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(592), + [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), + [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(560), + [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), + [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(646), + [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(647), + [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(650), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(657), + [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), + [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), + [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), + [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), + [1652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), + [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), + [1656] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), + [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), + [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), + [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), + [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(581), + [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [1670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), + [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [1676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), + [1678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 22), + [1680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 18), + [1682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), + [1684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 10), + [1686] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 36), + [1688] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 53), + [1690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 10), + [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1154), + [1694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [1696] = {.entry = {.count = 1, .reusable = false}}, SHIFT(999), + [1698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1465), + [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [1702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(939), + [1704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1430), + [1706] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1209), + [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1209), + [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1674), + [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), + [1728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), + [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(747), + [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(749), + [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(750), + [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(751), + [1758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), + [1762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(763), + [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), + [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), + [1768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), + [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), + [1772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350), + [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), + [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(357), + [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1663), + [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), + [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [1784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1014), + [1786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [1788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [1790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [1792] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1014), + [1795] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), + [1798] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), + [1800] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(939), + [1803] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1430), + [1806] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), + [1809] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(720), + [1812] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), + [1815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(758), + [1817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [1819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), + [1821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), + [1823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), + [1825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), + [1827] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1014), + [1830] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), + [1833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), + [1835] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(939), + [1838] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1430), + [1841] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), + [1844] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(720), + [1847] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), + [1850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [1852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(748), + [1854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [1856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(525), + [1858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1552), + [1860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1563), + [1862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1569), + [1864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1464), + [1866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1610), + [1868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(636), + [1870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), + [1872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(651), + [1874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(587), + [1876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1273), + [1878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), + [1880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(548), + [1882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1687), + [1884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(543), + [1886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1545), + [1888] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), + [1890] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1552), + [1893] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1563), + [1896] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1569), + [1899] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1770), + [1902] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1464), + [1905] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1610), + [1908] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(968), + [1911] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1529), + [1914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), + [1916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1006), + [1918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1029), + [1920] = {.entry = {.count = 1, .reusable = false}}, SHIFT(921), + [1922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1414), + [1924] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1748), + [1926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), + [1928] = {.entry = {.count = 1, .reusable = false}}, SHIFT(485), + [1930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), + [1932] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1740), + [1934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(991), + [1936] = {.entry = {.count = 1, .reusable = false}}, SHIFT(483), + [1938] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1714), + [1940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), + [1942] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doc_comment, 1, 0, 0), + [1944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), + [1946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1049), + [1948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), + [1950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), + [1952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1052), + [1954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), + [1956] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), SHIFT_REPEAT(973), + [1959] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 58), + [1961] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 41), + [1963] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), + [1965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1009), + [1967] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 76), + [1969] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 59), + [1971] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), + [1973] = {.entry = {.count = 1, .reusable = false}}, SHIFT(952), + [1975] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1526), + [1977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), + [1979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1702), + [1981] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 138), + [1983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), + [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1222), + [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1567), + [1989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1620), + [1991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1642), + [1993] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), + [1995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1625), + [1997] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 8), + [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1091), + [2001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), + [2003] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), + [2005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 93), + [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1020), + [2009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1537), + [2011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), + [2013] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 74), + [2015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), + [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1202), + [2019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1503), + [2021] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), + [2023] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1001), + [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(950), + [2027] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), + [2029] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 149), + [2031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1448), + [2033] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 157), + [2035] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 111), + [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), + [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1769), + [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1792), + [2043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1644), + [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1572), + [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1592), + [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1467), + [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), + [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1631), + [2055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 126), + [2057] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 61), + [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1085), + [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1176), + [2063] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 8), + [2065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1053), + [2067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1155), + [2069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), + [2071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1655), + [2073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1509), + [2075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1519), + [2077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1565), + [2079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), + [2081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), + [2083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1755), + [2085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1756), + [2087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1571), + [2089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1708), + [2091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1757), + [2093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1487), + [2095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1710), + [2097] = {.entry = {.count = 1, .reusable = false}}, SHIFT(925), + [2099] = {.entry = {.count = 1, .reusable = false}}, SHIFT(489), + [2101] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 113), + [2103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), + [2105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(473), + [2107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 27), + [2109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1618), + [2111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 74), + [2113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), + [2115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), + [2117] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 60), + [2119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), + [2121] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), + [2123] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 125), + [2125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 94), + [2127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), + [2129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 77), + [2131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 137), + [2133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 20), + [2135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), + [2137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 156), + [2139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 139), + [2141] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 42), + [2143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 140), + [2145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 112), + [2147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 161), + [2149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 150), + [2151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), + [2153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 92), + [2155] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 73), + [2157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [2159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [2161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), + [2163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1238), + [2165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [2167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), + [2169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1088), + [2171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [2173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1084), + [2175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), + [2177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1089), + [2179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [2181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [2183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), + [2185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), + [2187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), + [2189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), + [2191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1063), + [2193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [2195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1025), + [2197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [2199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1066), + [2201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [2203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1070), + [2205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [2207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), + [2209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [2211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1017), + [2213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), + [2215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1071), + [2217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [2219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), + [2221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [2223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1094), + [2225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [2227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1086), + [2229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [2231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1087), + [2233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), + [2235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1072), + [2237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [2239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1039), + [2241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), + [2243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1068), + [2245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), + [2247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1083), + [2249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [2251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1082), + [2253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [2255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), + [2257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), + [2259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1064), + [2261] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1468), + [2263] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1760), + [2265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [2267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), + [2269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1274), + [2271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), + [2273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), + [2275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(311), + [2277] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), + [2279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [2281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [2283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [2285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [2287] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), + [2289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), + [2291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [2293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), + [2295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), + [2297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [2299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [2301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [2303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [2305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), + [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(557), + [2309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), + [2311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [2313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), + [2315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [2317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [2319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [2321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), + [2323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [2325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [2327] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1435), + [2330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), + [2332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 22), + [2334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 91), + [2336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), + [2338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1258), + [2340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1635), + [2342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 110), + [2344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1530), + [2346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(998), + [2348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), + [2350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1518), + [2352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), + [2354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1455), + [2356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), + [2358] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1030), + [2361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_list_repeat1, 2, 0, 0), + [2363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1435), + [2365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), + [2367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), + [2369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), + [2371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), + [2373] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1274), + [2375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), + [2377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(598), + [2379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), + [2381] = {.entry = {.count = 1, .reusable = true}}, SHIFT(639), + [2383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(601), + [2385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(644), + [2387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), + [2389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(649), + [2391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), + [2393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1252), + [2395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(609), + [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), + [2399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1136), + [2401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), + [2403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), + [2405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1133), + [2407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), + [2409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(610), + [2411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), + [2413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [2415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(697), + [2417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1106), + [2419] = {.entry = {.count = 1, .reusable = false}}, SHIFT(272), + [2421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), + [2423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1235), + [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(496), + [2427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(513), + [2429] = {.entry = {.count = 1, .reusable = false}}, SHIFT(323), + [2431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), + [2433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1789), + [2435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), + [2437] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), + [2439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), + [2441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), + [2443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1127), + [2445] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), + [2447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1129), + [2449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1125), + [2451] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(160), + [2454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1134), + [2456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), + [2458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), + [2460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1143), + [2462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), + [2464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1037), + [2466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1518), + [2469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), + [2471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1123), + [2473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), + [2475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1138), + [2477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1124), + [2479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1528), + [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1451), + [2483] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1274), + [2486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), + [2488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 54), + [2490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(970), + [2492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), + [2494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(971), + [2496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 0), + [2498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 38), + [2500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), + [2502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1388), + [2504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [2506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1128), + [2508] = {.entry = {.count = 1, .reusable = false}}, SHIFT(94), + [2510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 24), + [2512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), + [2514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1469), + [2516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), + [2518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [2520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), + [2522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [2524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [2526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [2528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), + [2530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [2532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), + [2534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), + [2536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), + [2538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [2540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(732), + [2542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), + [2544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1473), + [2546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), + [2548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), + [2550] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1505), + [2553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), + [2555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(743), + [2557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 22), + [2559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [2561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(746), + [2563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [2565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), + [2567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1424), + [2569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1550), + [2571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [2573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [2575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), + [2577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), + [2579] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(59), + [2582] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), + [2584] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1469), + [2587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [2589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [2591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [2593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [2595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [2597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), + [2599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), + [2601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [2603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [2607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293), + [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [2611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), + [2613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 22), + [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298), + [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [2619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [2621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301), + [2623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), + [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304), + [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), + [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), + [2631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [2633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), + [2635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), + [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [2641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), + [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1505), + [2645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), + [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(637), + [2651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(948), + [2653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), + [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), + [2661] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(948), + [2664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), + [2666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1453), + [2668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), + [2670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), + [2672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(849), + [2674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1578), + [2676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), + [2678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1491), + [2680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), + [2682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), + [2684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), + [2686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [2688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), + [2690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [2692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(502), + [2694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), + [2696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [2698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(471), + [2700] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), + [2702] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1549), + [2705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1602), + [2709] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), + [2711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), + [2713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), + [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), + [2719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), + [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [2725] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), + [2727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [2729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), + [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [2733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), + [2735] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1473), + [2738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [2740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [2742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352), + [2744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [2746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [2748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [2750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1396), + [2752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), + [2754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), + [2756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [2758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(625), + [2760] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1343), + [2763] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), + [2765] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), + [2767] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1491), + [2770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [2772] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1396), + [2775] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), + [2777] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1278), + [2780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), + [2782] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 55), SHIFT_REPEAT(951), + [2785] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 55), + [2787] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1453), + [2790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), + [2792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [2794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [2796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(832), + [2798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(944), + [2800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), + [2802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1713), + [2804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1245), + [2806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), + [2808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [2810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1739), + [2812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(942), + [2814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1272), + [2816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [2818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [2820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1411), + [2822] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 66), + [2824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1233), + [2826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1158), + [2828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1054), + [2830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [2832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1163), + [2834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), + [2836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1168), + [2838] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 22), + [2840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1075), + [2842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), + [2844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1058), + [2846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [2848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), + [2850] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1277), + [2852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), + [2854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), + [2856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), + [2858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [2860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1080), + [2862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [2864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(955), + [2866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1187), + [2868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1081), + [2870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [2872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1169), + [2874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1217), + [2876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), + [2878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 34), + [2880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), + [2882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [2884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1246), + [2886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), + [2888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1585), + [2890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), + [2892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), + [2894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1206), + [2896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), + [2898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1099), + [2900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [2902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(965), + [2904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1182), + [2906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1092), + [2908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), + [2910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1093), + [2912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), + [2914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1666), + [2916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1062), + [2918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [2920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), + [2922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), + [2924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(963), + [2926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1146), + [2928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1214), + [2930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1189), + [2932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), + [2934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), + [2936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1446), + [2938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1221), + [2940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), + [2942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1188), + [2944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1227), + [2946] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), + [2948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(959), + [2950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1184), + [2952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1167), + [2954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1225), + [2956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), + [2958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [2960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 22), + [2962] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 38), + [2964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1485), + [2966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1244), + [2968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1161), + [2970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), + [2972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1248), + [2974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), + [2976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1250), + [2978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1367), + [2980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1150), + [2982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1195), + [2984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1257), + [2986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1196), + [2988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1260), + [2990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1171), + [2992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(960), + [2994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1177), + [2996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), + [2998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(962), + [3000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1149), + [3002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), + [3004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1534), + [3006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [3008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), + [3010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1144), + [3012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), + [3014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), + [3016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [3018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), + [3020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [3022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [3024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), + [3026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1673), + [3028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1730), + [3030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [3032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), + [3034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), + [3036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [3038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1785), + [3040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), + [3042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [3044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), + [3046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(954), + [3048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1074), + [3050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), + [3052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1275), + [3054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(612), + [3056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [3058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), + [3060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [3062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1022), + [3064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), + [3066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1044), + [3068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), + [3070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), + [3072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(470), + [3074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), + [3076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(498), + [3078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [3080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), + [3082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1497), + [3084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [3086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [3088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1786), + [3090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1776), + [3092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(731), + [3094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [3096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), + [3098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(753), + [3100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(597), + [3102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1759), + [3104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), + [3106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1447), + [3108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), + [3110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1501), + [3112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), + [3114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), + [3116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [3118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1012), + [3120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1449), + [3122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1450), + [3124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), + [3126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1454), + [3128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), + [3130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1218), + [3132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(652), + [3134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), + [3136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1057), + [3138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [3140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), + [3142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1472), + [3144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), + [3146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), + [3148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1145), + [3150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1611), + [3152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), + [3154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), + [3156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [3158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(851), + [3160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1494), + [3162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1425), + [3164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), + [3166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(615), + [3168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), + [3170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), + [3172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [3174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), + [3176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), + [3178] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [3180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(956), + [3182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1619), + [3184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1228), + [3186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1386), + [3188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), + [3190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), + [3192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1141), + [3194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), + [3196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(858), + [3198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1587), + [3200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1709), + [3202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [3204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(556), + [3206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(563), + [3208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1232), + [3210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1131), + [3212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1101), + [3214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [3216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1027), + [3218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [3220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(964), + [3222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1139), + [3224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [3226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1076), + [3228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), + [3230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [3232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [3234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [3236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1562), + [3238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(760), + [3240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), + [3242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(507), + [3244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [3246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), + [3248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [3250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1764), + [3252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [3254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1419), + [3256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(995), + [3258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1065), + [3260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), + [3262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1437), + [3264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1720), + [3266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1438), + [3268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [3270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [3272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1142), + [3274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), + [3276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1132), + [3278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [3280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1476), + [3282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1554), + [3284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1261), + [3286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(966), + [3288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(607), + [3290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(605), + [3292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), + [3294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), + [3296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), + [3298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), + [3300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [3302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1734), + [3304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(602), + [3306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [3308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(829), + [3310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1122), + [3312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1678), + [3314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1696), + [3316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1387), + [3318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [3320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), + [3322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1041), + [3324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1692), + [3326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1498), + [3328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [3330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(599), + [3332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), + [3334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1021), + [3336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(961), + [3338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1452), + [3340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(611), + [3342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), + [3344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(596), + [3346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1140), + [3348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1541), + [3350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1231), + [3352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), + [3354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1456), + [3356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1457), + [3358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1216), + [3360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [3362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), + [3364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), + [3366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), + [3368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1564), + [3370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1095), + [3372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1408), + [3374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1575), + [3376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), + [3378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1350), + [3380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1463), + [3382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1229), + [3384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), + [3386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(978), + [3388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), + [3390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), + [3392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), + [3394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(566), + [3396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1596), + [3398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(767), + [3400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), + [3402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1603), + [3404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), + [3406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351), + [3408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [3410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1251), + [3412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(969), + [3414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [3416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), + [3418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1254), + [3420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), + [3422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1471), + [3424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(957), + [3426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1024), + [3428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), + [3430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), + [3432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(958), + [3434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1265), + [3436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), + [3438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), + [3440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1654), + [3442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(997), + [3444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1458), + [3446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1204), + [3448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), + [3450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1262), + [3452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), + [3454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(719), + [3456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), + [3458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [3460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1705), + [3462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1486), + [3464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1256), + [3466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(736), + [3468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), + [3470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), + [3472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1489), + [3474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1268), + [3476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1207), + [3478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1442), + [3480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), + [3482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), + [3484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), + [3486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1205), + [3488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1727), + [3490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), + [3492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [3494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1495), + [3496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1426), + [3498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1743), + [3500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1745), + [3502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1746), + [3504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1749), + [3506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), + [3508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1758), + [3510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(707), + [3512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1135), + [3514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1763), + [3516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1622), + [3518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [3520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1508), + [3522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(943), + [3524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1043), + [3526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [3528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(931), + [3530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [3532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1777), + [3534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [3536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1781), + [3538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), + [3540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), }; #ifdef __cplusplus From 4b88ed3a3a621c85b46283d08ad31debc7ee9b35 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Sun, 12 Jul 2026 21:06:58 +1000 Subject: [PATCH 04/17] modules --- Cargo.lock | 2 + crates/osprey-ast/src/resume.rs | 12 +- crates/osprey-cli/Cargo.toml | 2 + crates/osprey-cli/src/main.rs | 260 +- crates/osprey-cli/src/project.rs | 426 + crates/osprey-cli/src/sandbox.rs | 7 +- crates/osprey-cli/src/wasm.rs | 27 +- crates/osprey-cli/tests/project_e2e.rs | 305 + crates/osprey-codegen/src/freevars.rs | 1 + crates/osprey-codegen/src/lib.rs | 5 + crates/osprey-fmt/src/lib.rs | 50 + crates/osprey-lsp/src/analysis.rs | 326 +- crates/osprey-lsp/src/features.rs | 240 +- crates/osprey-lsp/src/text.rs | 101 + crates/osprey-lsp/src/wire.rs | 24 +- crates/osprey-project/src/annotation.rs | 76 + crates/osprey-project/src/assemble.rs | 194 + crates/osprey-project/src/collect.rs | 411 + crates/osprey-project/src/collect_support.rs | 32 + crates/osprey-project/src/contract.rs | 396 + crates/osprey-project/src/contribution.rs | 25 +- crates/osprey-project/src/imports.rs | 299 + crates/osprey-project/src/lib.rs | 135 +- crates/osprey-project/src/manifest.rs | 15 +- crates/osprey-project/src/model.rs | 34 +- crates/osprey-project/src/name_resolve.rs | 146 + crates/osprey-project/src/opaque.rs | 22 + crates/osprey-project/src/purity.rs | 29 + crates/osprey-project/src/resolve.rs | 483 + crates/osprey-project/src/rewrite.rs | 476 + .../osprey-project/src/signature_collect.rs | 141 + crates/osprey-project/src/span.rs | 368 + crates/osprey-project/src/state.rs | 432 + crates/osprey-project/src/state_support.rs | 105 + crates/osprey-project/src/symbol_rewrite.rs | 77 + crates/osprey-project/src/type_rewrite.rs | 245 + crates/osprey-project/tests/modules.rs | 385 + .../osprey-project/tests/opaque_boundary.rs | 80 + crates/osprey-project/tests/state_modules.rs | 366 + crates/osprey-project/tests/support/mod.rs | 159 + crates/osprey-syntax/src/default/expr.rs | 36 +- crates/osprey-syntax/src/default/lower.rs | 67 +- crates/osprey-syntax/src/default/mod.rs | 25 + crates/osprey-syntax/src/default/modules.rs | 472 + crates/osprey-syntax/src/ml/cst.rs | 3 + crates/osprey-syntax/src/ml/lower.rs | 388 +- crates/osprey-syntax/src/ml/mod.rs | 3 + crates/osprey-syntax/src/ml/module_lower.rs | 234 + crates/osprey-syntax/src/ml/module_parse.rs | 326 + crates/osprey-syntax/src/ml/modules.rs | 143 + crates/osprey-syntax/src/ml/parser.rs | 494 +- crates/osprey-syntax/tests/ml_coverage.rs | 20 +- crates/osprey-syntax/tests/ml_modules.rs | 280 + crates/osprey-syntax/tests/module_equiv.rs | 150 + crates/osprey-types/src/check.rs | 24 + crates/osprey-types/src/expr.rs | 5 + crates/osprey-types/src/pattern.rs | 4 +- docs/plans/0014-modules-and-namespaces.md | 185 +- docs/plans/README.md | 2 +- docs/specs/0024-MLFlavorSyntax.md | 139 +- docs/specs/0025-ModulesAndNamespaces.md | 72 +- examples/projects/modules/README.md | 23 + examples/projects/modules/expectedoutput | 1 + examples/projects/modules/osprey.toml | 8 + examples/projects/modules/src/cream.ospml | 30 + .../modules/src/deep/unrelated/tax.osp | 12 + examples/projects/modules/src/main.osp | 14 + tree-sitter-osprey/grammar.js | 19 +- tree-sitter-osprey/queries/folds.scm | 2 + tree-sitter-osprey/queries/highlights.scm | 11 +- tree-sitter-osprey/queries/locals.scm | 3 + tree-sitter-osprey/src/grammar.json | 97 +- tree-sitter-osprey/src/node-types.json | 30 + tree-sitter-osprey/src/parser.c | 11163 ++++++++-------- tree-sitter-osprey/test/corpus/osprey.txt | 352 +- .../language-configuration-ml.json | 4 +- vscode-extension/package.json | 4 + vscode-extension/snippets/osprey-ml.json | 35 + vscode-extension/snippets/osprey.json | 37 + .../syntaxes/osprey-ml.tmLanguage.json | 60 +- .../syntaxes/osprey.tmGrammar.json | 68 +- website/package.json | 2 +- website/src/spec/0001-introduction.md | 2 +- website/src/spec/0002-lexicalstructure.md | 10 +- website/src/spec/0003-syntax.md | 28 +- website/src/spec/0004-typesystem.md | 106 +- website/src/spec/0005-functioncalls.md | 2 +- website/src/spec/0006-stringinterpolation.md | 2 +- website/src/spec/0007-patternmatching.md | 50 +- website/src/spec/0008-blockexpressions.md | 2 +- website/src/spec/0009-booleanoperations.md | 2 +- ...10-loopconstructsandfunctionaliterators.md | 2 +- .../0011-lightweightfibersandconcurrency.md | 2 +- website/src/spec/0012-built-infunctions.md | 2 +- website/src/spec/0013-errorhandling.md | 2 +- website/src/spec/0014-http.md | 2 +- website/src/spec/0015-websockets.md | 2 +- .../src/spec/0016-securityandsandboxing.md | 2 +- website/src/spec/0017-algebraiceffects.md | 128 +- website/src/spec/0018-memorymanagement.md | 2 +- .../src/spec/0019-foreignfunctioninterface.md | 2 +- .../src/spec/0020-languageserverandeditors.md | 27 +- website/src/spec/0021-debugger.md | 2 +- website/src/spec/0022-webassemblytarget.md | 2 +- website/src/spec/0023-languageflavors.md | 32 +- website/src/spec/0024-mlflavorsyntax.md | 210 +- website/src/spec/0025-modulesandnamespaces.md | 488 +- .../src/spec/0026-documentationcomments.md | 480 + website/src/spec/index.md | 5 +- 109 files changed, 16768 insertions(+), 6794 deletions(-) create mode 100644 crates/osprey-cli/src/project.rs create mode 100644 crates/osprey-cli/tests/project_e2e.rs create mode 100644 crates/osprey-project/src/annotation.rs create mode 100644 crates/osprey-project/src/assemble.rs create mode 100644 crates/osprey-project/src/collect.rs create mode 100644 crates/osprey-project/src/collect_support.rs create mode 100644 crates/osprey-project/src/contract.rs create mode 100644 crates/osprey-project/src/imports.rs create mode 100644 crates/osprey-project/src/name_resolve.rs create mode 100644 crates/osprey-project/src/opaque.rs create mode 100644 crates/osprey-project/src/purity.rs create mode 100644 crates/osprey-project/src/resolve.rs create mode 100644 crates/osprey-project/src/rewrite.rs create mode 100644 crates/osprey-project/src/signature_collect.rs create mode 100644 crates/osprey-project/src/span.rs create mode 100644 crates/osprey-project/src/state.rs create mode 100644 crates/osprey-project/src/state_support.rs create mode 100644 crates/osprey-project/src/symbol_rewrite.rs create mode 100644 crates/osprey-project/src/type_rewrite.rs create mode 100644 crates/osprey-project/tests/modules.rs create mode 100644 crates/osprey-project/tests/opaque_boundary.rs create mode 100644 crates/osprey-project/tests/state_modules.rs create mode 100644 crates/osprey-project/tests/support/mod.rs create mode 100644 crates/osprey-syntax/src/default/modules.rs create mode 100644 crates/osprey-syntax/src/ml/module_lower.rs create mode 100644 crates/osprey-syntax/src/ml/module_parse.rs create mode 100644 crates/osprey-syntax/src/ml/modules.rs create mode 100644 crates/osprey-syntax/tests/ml_modules.rs create mode 100644 crates/osprey-syntax/tests/module_equiv.rs create mode 100644 examples/projects/modules/README.md create mode 100644 examples/projects/modules/expectedoutput create mode 100644 examples/projects/modules/osprey.toml create mode 100644 examples/projects/modules/src/cream.ospml create mode 100644 examples/projects/modules/src/deep/unrelated/tax.osp create mode 100644 examples/projects/modules/src/main.osp create mode 100644 vscode-extension/snippets/osprey.json create mode 100644 website/src/spec/0026-documentationcomments.md diff --git a/Cargo.lock b/Cargo.lock index b1a1bb41..f79ebf98 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -379,8 +379,10 @@ dependencies = [ "osprey-debug", "osprey-fmt", "osprey-lsp", + "osprey-project", "osprey-syntax", "osprey-types", + "serde_json", "tokio", ] diff --git a/crates/osprey-ast/src/resume.rs b/crates/osprey-ast/src/resume.rs index 7bb8983b..3f8a40c3 100644 --- a/crates/osprey-ast/src/resume.rs +++ b/crates/osprey-ast/src/resume.rs @@ -206,9 +206,15 @@ mod tests { assert!(!contains_resume(&Expr::Integer(1))); assert!(!contains_resume(&Expr::Yield(None))); let import_only = Expr::Block { - statements: vec![crate::Stmt::Import { - module: vec!["m".into()], - }], + statements: vec![crate::Stmt::Import(crate::ImportDecl { + target: crate::ImportTarget { + namespace: crate::NamespaceName::Identifier("m".into()), + path: crate::SymbolPath::default(), + }, + alias: None, + selection: crate::ImportSelection::Whole, + position: None, + })], value: None, }; assert!(!contains_resume(&import_only)); diff --git a/crates/osprey-cli/Cargo.toml b/crates/osprey-cli/Cargo.toml index 9e391f0a..043370b3 100644 --- a/crates/osprey-cli/Cargo.toml +++ b/crates/osprey-cli/Cargo.toml @@ -14,10 +14,12 @@ path = "src/main.rs" osprey-ast = { workspace = true } osprey-debug = { workspace = true } osprey-syntax = { workspace = true } +osprey-project = { workspace = true } osprey-types = { workspace = true } osprey-codegen = { workspace = true } osprey-fmt = { workspace = true } osprey-lsp = { workspace = true } +serde_json = { workspace = true } tokio = { workspace = true } [lints] diff --git a/crates/osprey-cli/src/main.rs b/crates/osprey-cli/src/main.rs index a758f326..57536727 100644 --- a/crates/osprey-cli/src/main.rs +++ b/crates/osprey-cli/src/main.rs @@ -16,18 +16,25 @@ mod docs; mod fmt; +mod project; mod sandbox; mod wasm; use osprey_syntax::Flavor; +use project::CompilationInput; use sandbox::Policy; -use std::path::{Path, PathBuf}; +use std::path::Path; +#[cfg(test)] +use std::path::PathBuf; use std::process::{Command, ExitCode}; -const USAGE: &str = "usage: osprey [--check | --ast | --llvm | --compile | --run | \ +const USAGE: &str = + "usage: osprey [--check | --ast | --llvm | --compile | --run | \ --symbols] [--quiet] [--debug] [--flavor default|ml] [--memory=default|gc] \ [--target=native|wasm32] [-o ] \ [--sandbox | --no-http | --no-websocket | --no-fs | --no-ffi]\n\ + osprey build [project] [--quiet] [--debug] [--memory=default|gc] \ +[--target=native|wasm32] [-o ]\n\ osprey fmt [--check | --stdout] [--flavor default|ml] \n\ osprey --hover \n\ osprey --docs --docs-dir \n\ @@ -129,8 +136,18 @@ fn run_lsp() -> ExitCode { /// Parse the argument list: the first non-flag is the source path; mode flags /// select the action (last one wins); the rest toggle behaviour. fn parse_args(args: &[String]) -> Result { + let project_build = args.first().map(String::as_str) == Some("build"); + let args = if project_build { + args.get(1..).unwrap_or_default() + } else { + args + }; let mut path = None; - let mut mode = String::from("--check"); + let mut mode = String::from(if project_build { + "--compile" + } else { + "--check" + }); let mut quiet = false; let mut policy = Policy::allow_all(); let mut memory = String::from("default"); @@ -141,6 +158,13 @@ fn parse_args(args: &[String]) -> Result { let mut it = args.iter(); while let Some(a) = it.next() { match a.as_str() { + "--ast" | "--check" | "--llvm" | "--compile" | "--run" | "--symbols" | "--hover" + if project_build => + { + return Err(format!( + "`osprey build` does not accept mode flag {a}\n{USAGE}" + )); + } "--ast" | "--check" | "--llvm" | "--compile" | "--run" | "--symbols" | "--hover" => { mode.clone_from(a); } @@ -194,6 +218,17 @@ fn parse_args(args: &[String]) -> Result { debug, flavor, }), + None if project_build => Ok(Cli { + path: ".".to_string(), + mode, + quiet, + policy, + memory, + target, + output, + debug, + flavor, + }), None => Err(USAGE.to_string()), } } @@ -230,19 +265,44 @@ fn parse_flavor(value: &str) -> Result { /// Parse, gate (syntax → sandbox → types), and dispatch the selected mode. fn run(cli: &Cli) -> ExitCode { + let input = match load_input(cli) { + Ok(input) => input, + Err(code) => return code, + }; + let violations = sandbox::violations(input.program(), cli.policy); + if !violations.is_empty() { + for violation in &violations { + eprintln!("{}: {violation}", input.display_path()); + } + return ExitCode::FAILURE; + } + dispatch(cli, &input) +} + +fn load_input(cli: &Cli) -> Result { let path = &cli.path; + if project::is_project_path(path) { + if cli.flavor.is_some() { + eprintln!("error: --flavor applies to single files; projects select flavor per source"); + return Err(ExitCode::from(2)); + } + return project::CompilationInput::load_project(path).map_err(|errors| { + print_project_errors(&errors, path); + ExitCode::FAILURE + }); + } let source = match std::fs::read_to_string(path) { Ok(s) => s, Err(e) => { eprintln!("error: cannot read {path}: {e}"); - return ExitCode::from(2); + return Err(ExitCode::from(2)); } }; let flavor = match osprey_syntax::resolve_flavor(cli.flavor, path, &source) { Ok(flavor) => flavor, Err(msg) => { eprintln!("{msg}"); - return ExitCode::from(2); + return Err(ExitCode::from(2)); } }; let parsed = osprey_syntax::parse_program_with_flavor(&source, flavor); @@ -253,33 +313,39 @@ fn run(cli: &Cli) -> ExitCode { err.position.line, err.position.column, err.message ); } - return ExitCode::FAILURE; + return Err(ExitCode::FAILURE); } - let violations = sandbox::violations(&parsed.program, cli.policy); - if !violations.is_empty() { - for v in &violations { - eprintln!("{path}: {v}"); - } - return ExitCode::FAILURE; + if project::needs_assembly(&parsed.program) { + return CompilationInput::one_source(path, flavor, source, parsed.program).map_err( + |errors| { + print_project_errors(&errors, path); + ExitCode::FAILURE + }, + ); + } + Ok(CompilationInput::script(path, source, parsed.program)) +} + +fn print_project_errors(errors: &[osprey_project::ProjectError], fallback: &str) { + for error in errors { + eprintln!("{}", project::format_project_error(error, fallback)); } - dispatch(cli, &parsed.program, &source) } /// Route the type-gated modes: an ill-typed program never reaches codegen. -fn dispatch(cli: &Cli, program: &osprey_ast::Program, source: &str) -> ExitCode { - let path = &cli.path; +fn dispatch(cli: &Cli, input: &CompilationInput) -> ExitCode { + let path = input.display_path(); + let program = input.program(); match cli.mode.as_str() { - "--check" => run_check(cli, program), + "--check" => run_check(cli, input), // The outline must work for ill-typed (but parsable) files, so // `--symbols` deliberately skips the type gate. "--symbols" => { - println!("{}", osprey_lsp::symbols_json(program)); + println!("{}", input.symbols_json()); ExitCode::SUCCESS } - "--llvm" | "--run" | "--compile" if report_type_errors(path, program) > 0 => { - ExitCode::FAILURE - } - "--llvm" => match compile_ir(path, program, cli.debug) { + "--llvm" | "--run" | "--compile" if report_type_errors(input) > 0 => ExitCode::FAILURE, + "--llvm" => match compile_ir(input.debug_path(), program, cli.debug) { Ok(ir) => { print!("{ir}"); ExitCode::SUCCESS @@ -289,8 +355,8 @@ fn dispatch(cli: &Cli, program: &osprey_ast::Program, source: &str) -> ExitCode ExitCode::FAILURE } }, - "--run" => run_program(cli, program, source), - "--compile" => compile_program_to_disk(cli, program, source), + "--run" => run_program(cli, input), + "--compile" => compile_program_to_disk(cli, input), _ => { println!("{program:#?}"); ExitCode::SUCCESS @@ -300,21 +366,22 @@ fn dispatch(cli: &Cli, program: &osprey_ast::Program, source: &str) -> ExitCode /// Type-check `program`, print every error in `file:line:col: message` form, /// and return how many there were. The shared gate for every compiling mode. -fn report_type_errors(path: &str, program: &osprey_ast::Program) -> usize { - let errors = osprey_types::check_program(program); +fn report_type_errors(input: &CompilationInput) -> usize { + let errors = osprey_types::check_program(input.program()); for e in &errors { - match e.position { - Some(p) => eprintln!("{path}:{}:{}: {}", p.line, p.column, e.message), - None => eprintln!("{path}: {}", e.message), - } + eprintln!("{}", input.diagnostic(e.position, &e.message)); } errors.len() } -fn run_check(cli: &Cli, program: &osprey_ast::Program) -> ExitCode { - if report_type_errors(&cli.path, program) == 0 { +fn run_check(cli: &Cli, input: &CompilationInput) -> ExitCode { + if report_type_errors(input) == 0 { if !cli.quiet { - println!("{}: ok ({} statements)", cli.path, program.statements.len()); + println!( + "{}: ok ({} statements)", + input.display_path(), + input.program().statements.len() + ); } return ExitCode::SUCCESS; } @@ -331,15 +398,22 @@ fn reject_debug_wasm(debug: bool) -> Option { /// `--compile`: build the artifact at `-o` (or the source stem, `.wasm` for the /// wasm target) — a host executable via clang, or WebAssembly via wasm-ld. -fn compile_program_to_disk(cli: &Cli, program: &osprey_ast::Program, source: &str) -> ExitCode { - let out = output_path(&cli.path, cli.output.as_deref(), &cli.target); +fn compile_program_to_disk(cli: &Cli, input: &CompilationInput) -> ExitCode { + let out = input.output_path(cli.output.as_deref(), &cli.target); let result = if cli.target == "wasm32" { if let Some(code) = reject_debug_wasm(cli.debug) { return code; } - wasm::build(&cli.path, program, &out) + wasm::build(input.debug_path(), input.program(), &out) } else { - build_executable(&cli.path, program, source, &out, &cli.memory, cli.debug) + build_executable( + input.debug_path(), + input.program(), + input.source(), + &out, + &cli.memory, + cli.debug, + ) }; match result { Ok(()) => { @@ -354,6 +428,7 @@ fn compile_program_to_disk(cli: &Cli, program: &osprey_ast::Program, source: &st /// The output artifact path: the explicit `-o` value, else the source stem in /// the current directory — with a `.wasm` extension for the wasm target. +#[cfg(test)] fn output_path(src: &str, output: Option<&str>, target: &str) -> PathBuf { match output { Some(o) => PathBuf::from(o), @@ -364,15 +439,22 @@ fn output_path(src: &str, output: Option<&str>, target: &str) -> PathBuf { /// Compile to a temp artifact and run it — the `--run` end-to-end path. Native /// runs the executable directly; wasm runs it under a WASI host (`wasmtime`). -fn run_program(cli: &Cli, program: &osprey_ast::Program, source: &str) -> ExitCode { +fn run_program(cli: &Cli, input: &CompilationInput) -> ExitCode { if cli.target == "wasm32" { if let Some(code) = reject_debug_wasm(cli.debug) { return code; } - return wasm::run(cli, program); - } - let exe = std::env::temp_dir().join(format!("{}.out", stem_of(&cli.path))); - if let Err(code) = build_executable(&cli.path, program, source, &exe, &cli.memory, cli.debug) { + return wasm::run(input.debug_path(), input.program()); + } + let exe = std::env::temp_dir().join(format!("{}.out", scratch_stem(input.display_path()))); + if let Err(code) = build_executable( + input.debug_path(), + input.program(), + input.source(), + &exe, + &cli.memory, + cli.debug, + ) { return code; } match Command::new(&exe).status() { @@ -401,7 +483,7 @@ fn build_executable( return Err(ExitCode::FAILURE); } }; - let ll = std::env::temp_dir().join(format!("{}.ll", stem_of(path))); + let ll = std::env::temp_dir().join(format!("{}.ll", scratch_stem(path))); if let Err(e) = std::fs::write(&ll, ir.as_bytes()) { eprintln!("error: cannot write IR to {}: {e}", ll.display()); return Err(ExitCode::FAILURE); @@ -491,6 +573,21 @@ pub(crate) fn stem_of(path: &str) -> String { .to_string() } +/// A process-unique scratch stem, preventing concurrent CLI builds of files +/// named `main` from overwriting each other's temporary IR and executables. +pub(crate) fn scratch_stem(path: &str) -> String { + use std::hash::{Hash, Hasher}; + + let mut hasher = std::collections::hash_map::DefaultHasher::new(); + path.hash(&mut hasher); + format!( + "{}-{}-{:x}", + stem_of(path), + std::process::id(), + hasher.finish() + ) +} + /// The exit code to propagate for a finished child: its own code when it exited /// normally, else (Unix) `128 + signal` for a signal death — so a segfaulting /// program is NOT masked as success (`status.code()` is `None` for a signal). @@ -566,9 +663,19 @@ fn directive<'a>(line: &'a str, key: &str) -> Option<&'a str> { /// Search the conventional install/build locations for a runtime static lib: /// the working directory's repo layout, then next to the `osprey` executable -/// (the release-tarball layout, and `target/release` two levels under the repo -/// root), then the system lib dir. +/// and below each of its ancestors (covering arbitrary in-workspace Cargo +/// target/profile nesting and release-tarball layouts), the compile-time +/// workspace as a development fallback, then the system lib dir. pub(crate) fn find_runtime_lib(lib: &str) -> Option { + let executable_dir = std::env::current_exe() + .ok() + .and_then(|executable| executable.parent().map(Path::to_path_buf)); + runtime_lib_candidates(lib, executable_dir.as_deref()) + .into_iter() + .find(|candidate| Path::new(candidate).exists()) +} + +fn runtime_lib_candidates(lib: &str, executable_dir: Option<&Path>) -> Vec { let mut roots = vec![ format!("compiler/bin/{lib}"), format!("compiler/lib/{lib}"), @@ -576,17 +683,20 @@ pub(crate) fn find_runtime_lib(lib: &str) -> Option { format!("../bin/{lib}"), format!("../../bin/{lib}"), ]; - if let Some(dir) = std::env::current_exe() - .ok() - .and_then(|e| e.parent().map(std::path::Path::to_path_buf)) - { + if let Some(dir) = executable_dir { roots.push(dir.join(lib).display().to_string()); - for up in ["../../compiler/lib", "../../compiler/bin"] { - roots.push(dir.join(up).join(lib).display().to_string()); + for ancestor in dir.ancestors() { + for relative in ["compiler/lib", "compiler/bin", "bin"] { + roots.push(ancestor.join(relative).join(lib).display().to_string()); + } } } + let workspace = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); + for relative in ["compiler/lib", "compiler/bin"] { + roots.push(workspace.join(relative).join(lib).display().to_string()); + } roots.push(format!("/usr/local/lib/{lib}")); - roots.into_iter().find(|p| Path::new(p).exists()) + roots } /// OpenSSL link flags, searching the conventional Homebrew/system lib dirs. @@ -1725,6 +1835,18 @@ mod tests { assert!(cli.policy.http && cli.policy.websocket && cli.policy.fs && cli.policy.ffi); } + #[test] + fn parse_args_build_defaults_to_current_project_and_compile() { + let default = parse_args(&args(&["build"])).expect("build parses"); + assert_eq!(default.path, "."); + assert_eq!(default.mode, "--compile"); + let explicit = + parse_args(&args(&["build", "apps/demo", "--quiet"])).expect("explicit project parses"); + assert_eq!(explicit.path, "apps/demo"); + assert!(explicit.quiet); + assert!(parse_args(&args(&["build", ".", "--check"])).is_err()); + } + #[test] fn parse_args_accepts_flavor_flag_in_both_spellings() { // No flag ⇒ unset, so resolution falls through to marker/extension. @@ -1837,6 +1959,14 @@ mod tests { assert_eq!(stem_of("noext"), "noext"); } + #[test] + fn scratch_stems_disambiguate_equal_filenames_in_different_projects() { + let left = scratch_stem("/apps/left/src/main.osp"); + let right = scratch_stem("/apps/right/src/main.osp"); + assert_ne!(left, right); + assert!(left.starts_with("main-")); + } + #[test] fn directive_parses_both_spellings_and_ignores_others() { assert_eq!(directive("// @link: sqlite3", "link"), Some("sqlite3")); @@ -1890,6 +2020,16 @@ mod tests { assert!(find_runtime_lib("definitely_not_a_real_lib_xyz.a").is_none()); } + #[test] + fn runtime_search_walks_above_arbitrarily_nested_cargo_profiles() { + let root = PathBuf::from("workspace"); + let executable_dir = root.join("target/llvm-cov-target/ci/deps"); + let lib = "libfiber_runtime.a"; + let candidates = runtime_lib_candidates(lib, Some(&executable_dir)); + let expected = root.join("compiler/bin").join(lib).display().to_string(); + assert!(candidates.contains(&expected), "{candidates:?}"); + } + #[cfg(unix)] #[test] fn child_exit_code_maps_codes_and_signals() { @@ -1906,9 +2046,11 @@ mod tests { #[test] fn report_type_errors_counts_zero_for_valid_and_more_for_ill_typed() { let ok = osprey_syntax::parse_program("let x = 1\nprint(x)\n").program; - assert_eq!(report_type_errors("ok.osp", &ok), 0); + let ok = CompilationInput::script("ok.osp", String::new(), ok); + assert_eq!(report_type_errors(&ok), 0); let bad = osprey_syntax::parse_program("let y = 1 + \"oops\" - true\n").program; - assert!(report_type_errors("bad.osp", &bad) > 0); + let bad = CompilationInput::script("bad.osp", String::new(), bad); + assert!(report_type_errors(&bad) > 0); } fn temp_source(name: &str, body: &str) -> String { @@ -1969,7 +2111,8 @@ mod tests { // An undefined identifier yields an error carrying a source position, // exercising the `Some(position)` diagnostic arm. let bad = osprey_syntax::parse_program("print(missingVariable)\n").program; - assert!(report_type_errors("bad.osp", &bad) > 0); + let bad = CompilationInput::script("bad.osp", String::new(), bad); + assert!(report_type_errors(&bad) > 0); } #[test] @@ -2004,16 +2147,17 @@ mod tests { #[test] fn wasm_target_rejects_debug_then_dispatches_to_the_backend() { let program = osprey_syntax::parse_program("let n = 1\nprint(\"${n}\")\n").program; + let input = CompilationInput::script("p.osp", String::new(), program); let mut c = cli("p.osp", "--compile", Policy::allow_all()); c.target = "wasm32".to_string(); // --debug + --target=wasm32 is rejected before any toolchain work. c.debug = true; - let _ = compile_program_to_disk(&c, &program, ""); - let _ = run_program(&c, &program, ""); + let _ = compile_program_to_disk(&c, &input); + let _ = run_program(&c, &input); // Without --debug the wasm build/run driver is dispatched (it fails // cleanly without the wasm toolchain, but the dispatch lines execute). c.debug = false; - let _ = compile_program_to_disk(&c, &program, ""); - let _ = run_program(&c, &program, ""); + let _ = compile_program_to_disk(&c, &input); + let _ = run_program(&c, &input); } } diff --git a/crates/osprey-cli/src/project.rs b/crates/osprey-cli/src/project.rs new file mode 100644 index 00000000..b3a07bc8 --- /dev/null +++ b/crates/osprey-cli/src/project.rs @@ -0,0 +1,426 @@ +//! CLI-facing project input and source-location handling. + +use osprey_ast::{Position, Program, Stmt}; +use osprey_project::{AssembledProject, ProjectConfig, ProjectError, SourceFile}; +use osprey_syntax::Flavor; +use std::path::{Path, PathBuf}; + +/// A parsed script or an assembled multi-file project ready for dispatch. +#[derive(Debug)] +pub(crate) struct CompilationInput { + unit: CompilationUnit, + source: String, + display_path: String, + debug_path: String, + output: OutputDefault, +} + +#[derive(Debug)] +enum CompilationUnit { + Script(Program), + Project(AssembledProject), +} + +#[derive(Debug)] +enum OutputDefault { + Source(String), + Project { root: PathBuf, name: String }, +} + +impl CompilationInput { + /// Preserve the historical single-file path for an ordinary script. + pub(crate) fn script(path: &str, source: String, program: Program) -> Self { + Self { + unit: CompilationUnit::Script(program), + source, + display_path: path.to_string(), + debug_path: path.to_string(), + output: OutputDefault::Source(path.to_string()), + } + } + + /// Assemble one module-aware source without sweeping up sibling files. + pub(crate) fn one_source( + path: &str, + flavor: Flavor, + source: String, + program: Program, + ) -> Result> { + let physical_path = normalize_path(Path::new(path)); + let source_file = SourceFile { + path: physical_path.clone(), + flavor, + source: source.clone(), + program, + }; + let root = physical_path.parent().unwrap_or_else(|| Path::new(".")); + let config = ProjectConfig::for_root(root); + let assembled = osprey_project::assemble(&config, &[source_file])?; + Ok(Self::assembled( + assembled, + source, + path.to_string(), + OutputDefault::Source(path.to_string()), + )) + } + + /// Load a directory project or a path to its `osprey.toml` manifest. + pub(crate) fn load_project(path: &str) -> Result> { + let selected = Path::new(path); + if selected.file_name().and_then(|name| name.to_str()) == Some("osprey.toml") + && !selected.is_file() + { + return Err(vec![ProjectError { + message: "manifest does not exist".to_string(), + path: Some(selected.to_path_buf()), + line: None, + column: None, + }]); + } + let root = project_root(selected); + let assembled = osprey_project::load_and_assemble(&root)?; + let source = aggregate_sources(&assembled); + let name = project_name(&root); + Ok(Self::assembled( + assembled, + source, + root.display().to_string(), + OutputDefault::Project { root, name }, + )) + } + + fn assembled( + assembled: AssembledProject, + source: String, + display_path: String, + output: OutputDefault, + ) -> Self { + let debug_path = assembled.entry().map_or_else( + || display_path.clone(), + |entry| entry.path.display().to_string(), + ); + Self { + unit: CompilationUnit::Project(assembled), + source, + display_path, + debug_path, + output, + } + } + + /// The flavor-neutral program consumed by the checker and backend. + pub(crate) fn program(&self) -> &Program { + match &self.unit { + CompilationUnit::Script(program) => program, + CompilationUnit::Project(project) => &project.program, + } + } + + /// All original source text used to discover project-wide link directives. + pub(crate) fn source(&self) -> &str { + &self.source + } + + /// User-facing path label for diagnostics that have no precise source. + pub(crate) fn display_path(&self) -> &str { + &self.display_path + } + + /// Entry source used for the backend's single-file debug metadata API. + pub(crate) fn debug_path(&self) -> &str { + &self.debug_path + } + + /// Format a flattened checker location using its physical source file. + pub(crate) fn diagnostic(&self, position: Option, message: &str) -> String { + let Some(position) = position else { + return format!("{}: {message}", self.display_path); + }; + if let CompilationUnit::Project(project) = &self.unit { + if let Some((source, line)) = project.source_at_line(position.line) { + return format!( + "{}:{line}:{}: {message}", + source.path.display(), + position.column + ); + } + } + format!( + "{}:{}:{}: {message}", + self.display_path, position.line, position.column + ) + } + + /// Render symbols with source-level qualified names where assembly mangled them. + pub(crate) fn symbols_json(&self) -> String { + let json = osprey_lsp::symbols_json(self.program()); + let CompilationUnit::Project(project) = &self.unit else { + return json; + }; + project_symbols_json(json, project) + } + + /// Honor `-o`; otherwise put project artifacts beside the manifest and + /// retain the historical current-directory source stem for scripts. + pub(crate) fn output_path(&self, explicit: Option<&str>, target: &str) -> PathBuf { + if let Some(path) = explicit { + return PathBuf::from(path); + } + match &self.output { + OutputDefault::Source(path) => artifact(Path::new(path), target, false), + OutputDefault::Project { root, name } => artifact(&root.join(name), target, true), + } + } +} + +/// Whether a positional path selects project mode without a subcommand. +pub(crate) fn is_project_path(path: &str) -> bool { + let path = Path::new(path); + path.is_dir() || path.file_name().and_then(|name| name.to_str()) == Some("osprey.toml") +} + +/// Module-bearing single files need resolver/flattening; ordinary scripts must +/// bypass it so their existing IR and debugger symbol names remain exact. +pub(crate) fn needs_assembly(program: &Program) -> bool { + program.statements.iter().any(|statement| { + matches!( + statement, + Stmt::Namespace { .. } | Stmt::Module { .. } | Stmt::Import(_) | Stmt::Signature { .. } + ) + }) +} + +/// Render a loader/resolver failure in the compiler's standard diagnostic form. +pub(crate) fn format_project_error(error: &ProjectError, fallback: &str) -> String { + let path = error + .path + .as_deref() + .map_or_else(|| fallback.to_string(), |path| path.display().to_string()); + match (error.line, error.column) { + (Some(line), Some(column)) => format!("{path}:{line}:{column}: {}", error.message), + (Some(line), None) => format!("{path}:{line}: {}", error.message), + (None, _) => format!("{path}: {}", error.message), + } +} + +fn project_root(path: &Path) -> PathBuf { + let root = if path.is_dir() { + path + } else { + path.parent() + .filter(|parent| !parent.as_os_str().is_empty()) + .unwrap_or_else(|| Path::new(".")) + }; + normalize_path(root) +} + +fn normalize_path(path: &Path) -> PathBuf { + std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf()) +} + +fn aggregate_sources(project: &AssembledProject) -> String { + project + .sources + .iter() + .map(|source| source.source.as_str()) + .collect::>() + .join("\n") +} + +fn project_name(root: &Path) -> String { + let manifest = root.join("osprey.toml"); + let config = std::fs::read_to_string(&manifest) + .ok() + .and_then(|source| ProjectConfig::parse(&source, &manifest).ok()) + .unwrap_or_else(|| ProjectConfig::for_root(root)); + config.name +} + +fn project_symbols_json(json: String, project: &AssembledProject) -> String { + let Ok(mut value) = serde_json::from_str::(&json) else { + return json; + }; + let symbols = osprey_lsp::analysis::collect_symbols(&project.program); + let Some(entries) = value.as_array_mut() else { + return json; + }; + for (entry, symbol) in entries.iter_mut().zip(&symbols) { + update_project_symbol(entry, symbol, project); + } + serde_json::to_string(&value).unwrap_or(json) +} + +fn update_project_symbol( + entry: &mut serde_json::Value, + symbol: &osprey_lsp::analysis::SymbolInfo, + project: &AssembledProject, +) { + restore_mangled_values(entry, &project.source_name_by_mangled); + let Some(object) = entry.as_object_mut() else { + return; + }; + if let Some(source_name) = project.source_name_by_mangled.get(&symbol.name) { + let _ = object.insert("name".to_string(), source_name.clone().into()); + } + let Some(position) = symbol.position else { + return; + }; + let Some((source, line)) = project.source_at_line(position.line) else { + return; + }; + let _ = object.insert("line".to_string(), line.into()); + let _ = object.insert("path".to_string(), source.path.display().to_string().into()); +} + +fn restore_mangled_values( + value: &mut serde_json::Value, + source_names: &std::collections::BTreeMap, +) { + match value { + serde_json::Value::String(text) => { + for (linkage, source) in source_names { + if linkage.starts_with("__osp_") { + *text = text.replace(linkage, source); + } + } + } + serde_json::Value::Array(values) => { + for value in values { + restore_mangled_values(value, source_names); + } + } + serde_json::Value::Object(object) => { + for value in object.values_mut() { + restore_mangled_values(value, source_names); + } + } + serde_json::Value::Null | serde_json::Value::Bool(_) | serde_json::Value::Number(_) => {} + } +} + +fn artifact(base: &Path, target: &str, keep_parent: bool) -> PathBuf { + let output = if keep_parent { + base.to_path_buf() + } else { + PathBuf::from( + base.file_stem() + .and_then(|stem| stem.to_str()) + .unwrap_or("osprey_out"), + ) + }; + if target == "wasm32" { + let mut wasm = output.into_os_string(); + wasm.push(".wasm"); + return PathBuf::from(wasm); + } + output +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn recognizes_directory_and_manifest_project_inputs() { + assert!(is_project_path("osprey.toml")); + assert!(!is_project_path("main.osp")); + assert!(is_project_path( + std::env::temp_dir().to_string_lossy().as_ref() + )); + } + + #[test] + fn lexical_and_absolute_project_roots_have_one_identity() { + let lexical = project_root(Path::new(".")); + let absolute = normalize_path(Path::new(".")); + assert_eq!(lexical, absolute); + assert_eq!( + ProjectConfig::for_root(&lexical).name, + ProjectConfig::for_root(&absolute).name + ); + } + + #[test] + fn only_module_aware_programs_request_single_source_assembly() { + let script = osprey_syntax::parse_program("let answer = 42\n").program; + let module = + osprey_syntax::parse_program("module Answers {\n export let answer = 42\n}\n") + .program; + assert!(!needs_assembly(&script)); + assert!(needs_assembly(&module)); + } + + #[test] + fn source_output_defaults_match_the_existing_cli() { + let program = osprey_syntax::parse_program("let answer = 42\n").program; + let input = CompilationInput::script("nested/main.osp", String::new(), program); + assert_eq!(input.output_path(None, "native"), PathBuf::from("main")); + assert_eq!( + input.output_path(None, "wasm32"), + PathBuf::from("main.wasm") + ); + assert_eq!( + input.output_path(Some("custom/out"), "native"), + PathBuf::from("custom/out") + ); + } + + #[test] + fn aggregate_sources_keeps_link_directives_from_every_file() { + let sources = [ + ("first.osp", "// @link: sqlite3\nlet x = 1\n"), + ("second.ospml", "// @linkdir: /opt/lib\ny = 2\n"), + ]; + let sources = sources + .iter() + .enumerate() + .map(|(index, (path, source))| osprey_project::SourceMetadata { + index, + path: PathBuf::from(path), + flavor: Flavor::Default, + source: (*source).to_string(), + global_line_start: 1, + global_line_end: 2, + }) + .collect(); + let project = AssembledProject { + program: Program { + statements: Vec::new(), + }, + entry_prologue: Vec::new(), + entry_source: 0, + sources, + source_name_by_mangled: std::collections::BTreeMap::new(), + }; + let aggregated = aggregate_sources(&project); + assert!(aggregated.contains("// @link: sqlite3")); + assert!(aggregated.contains("// @linkdir: /opt/lib")); + } + + #[test] + fn project_symbol_mapping_changes_exact_names_and_localizes_positions() { + let program = osprey_syntax::parse_program("fn main() = 1\nfn remaining() = 2\n").program; + let source = osprey_project::SourceMetadata { + index: 0, + path: PathBuf::from("src/main.osp"), + flavor: Flavor::Default, + source: String::new(), + global_line_start: 1, + global_line_end: 2, + }; + let mut source_names = std::collections::BTreeMap::new(); + let _ = source_names.insert("main".to_string(), "app::main".to_string()); + let project = AssembledProject { + program, + entry_prologue: Vec::new(), + entry_source: 0, + sources: vec![source], + source_name_by_mangled: source_names, + }; + let json = project_symbols_json(osprey_lsp::symbols_json(&project.program), &project); + assert!(json.contains("\"name\":\"app::main\"")); + assert!(json.contains("\"name\":\"remaining\"")); + assert!(!json.contains("reapp::maining")); + assert!(json.contains("\"path\":\"src/main.osp\"")); + } +} diff --git a/crates/osprey-cli/src/sandbox.rs b/crates/osprey-cli/src/sandbox.rs index a76f7505..6d0df88c 100644 --- a/crates/osprey-cli/src/sandbox.rs +++ b/crates/osprey-cli/src/sandbox.rs @@ -105,7 +105,12 @@ fn extern_violations(statements: &[Stmt], out: &mut Vec) { Stmt::Extern { name, .. } => out.push(format!( "security: extern function `{name}` is disabled by --no-ffi" )), - Stmt::Module { body, .. } => extern_violations(body, out), + Stmt::Module { body, .. } => { + for item in body { + extern_violations(std::slice::from_ref(item.declaration.as_ref()), out); + } + } + Stmt::Namespace { body, .. } => extern_violations(body, out), _ => {} } } diff --git a/crates/osprey-cli/src/wasm.rs b/crates/osprey-cli/src/wasm.rs index 14d20a58..37c853bf 100644 --- a/crates/osprey-cli/src/wasm.rs +++ b/crates/osprey-cli/src/wasm.rs @@ -20,7 +20,7 @@ //! program that references those symbols fails at link with a clear undefined //! symbol, not silently. -use crate::{find_runtime_lib, stem_of, Cli}; +use crate::{find_runtime_lib, scratch_stem}; use std::path::{Path, PathBuf}; use std::process::{Command, ExitCode}; @@ -49,14 +49,14 @@ pub(crate) fn build(path: &str, program: &osprey_ast::Program, out: &Path) -> Re "{RUNTIME_LIB} not found — run `make wasm` to build it" )) })?; - let obj = compile_object(&stem_of(path), &ir)?; + let obj = compile_object(&scratch_stem(path), &ir)?; link(&obj, &archive, &libdir, out) } /// `--run` for wasm: build to a temp `.wasm`, then execute it under a WASI host. -pub(crate) fn run(cli: &Cli, program: &osprey_ast::Program) -> ExitCode { - let wasm = std::env::temp_dir().join(format!("{}.wasm", stem_of(&cli.path))); - if let Err(code) = build(&cli.path, program, &wasm) { +pub(crate) fn run(path: &str, program: &osprey_ast::Program) -> ExitCode { + let wasm = std::env::temp_dir().join(format!("{}.wasm", scratch_stem(path))); + if let Err(code) = build(path, program, &wasm) { return code; } run_host(&wasm) @@ -454,7 +454,7 @@ mod tests { let program = osprey_syntax::parse_program("let n = 1\nprint(\"${n}\")\n").program; let out = std::env::temp_dir().join("osprey_full_driver_unit.wasm"); let built = build("unit.osp", &program, &out); - let _ran = run(&stub_cli(), &program); + let _ran = run("unit.osp", &program); if let Some(a) = &archive { let _ = std::fs::remove_file(a); @@ -468,21 +468,6 @@ mod tests { assert!(built.is_ok(), "stubbed toolchain drives a clean build"); } - /// A minimal wasm-target `Cli` for driving `run` in a unit test. - fn stub_cli() -> Cli { - Cli { - path: "unit.osp".to_string(), - mode: "--run".to_string(), - quiet: true, - policy: crate::sandbox::Policy::allow_all(), - memory: "default".to_string(), - target: "wasm32".to_string(), - output: None, - debug: false, - flavor: None, - } - } - // End-to-end build+run, exercised only where the wasm toolchain is present // (the dev machine and the CI `ci` job, which installs lld + a WASI sysroot // and `make wasm` before `make test`). Skipped elsewhere so the unit suite diff --git a/crates/osprey-cli/tests/project_e2e.rs b/crates/osprey-cli/tests/project_e2e.rs new file mode 100644 index 00000000..d38e45db --- /dev/null +++ b/crates/osprey-cli/tests/project_e2e.rs @@ -0,0 +1,305 @@ +//! End-to-end coverage for mixed-flavor project CLI entry points. +#![expect( + clippy::expect_used, + reason = "subprocess and fixture setup failures must fail these end-to-end tests immediately" +)] + +use std::path::{Path, PathBuf}; +use std::process::Command; + +fn repo_root() -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")).join("..").join("..") +} + +fn fixture() -> PathBuf { + repo_root().join("examples/projects/modules") +} + +fn osprey() -> Command { + let mut command = Command::new(env!("CARGO_BIN_EXE_osprey")); + let _ = command.current_dir(repo_root()); + command +} + +struct Output { + code: Option, + stdout: String, + stderr: String, +} + +fn run(args: &[String]) -> Output { + finish(osprey().args(args)) +} + +fn run_in(directory: &Path, args: &[&str]) -> Output { + let mut command = osprey(); + let _ = command.current_dir(directory).args(args); + finish(&mut command) +} + +fn finish(command: &mut Command) -> Output { + let result = command.output().expect("run osprey"); + Output { + code: result.status.code(), + stdout: String::from_utf8_lossy(&result.stdout).into_owned(), + stderr: String::from_utf8_lossy(&result.stderr).into_owned(), + } +} + +fn arg(path: &Path) -> String { + path.to_string_lossy().into_owned() +} + +fn copy_fixture(name: &str) -> PathBuf { + let root = + std::env::temp_dir().join(format!("osprey_project_e2e_{name}_{}", std::process::id())); + let _ = std::fs::remove_dir_all(&root); + let deep = root.join("src/deep/unrelated"); + std::fs::create_dir_all(&deep).expect("create project directories"); + copy("osprey.toml", &root.join("osprey.toml")); + copy("src/main.osp", &root.join("src/main.osp")); + copy("src/cream.ospml", &root.join("src/cream.ospml")); + copy("src/deep/unrelated/tax.osp", &deep.join("tax.osp")); + root +} + +fn copy(relative: &str, destination: &Path) { + let _ = std::fs::copy(fixture().join(relative), destination).expect("copy project fixture"); +} + +#[test] +fn directory_and_manifest_inputs_share_the_flat_project_pipeline() { + let project = fixture(); + let manifest = project.join("osprey.toml"); + for path in [&project, &manifest] { + let output = run(&[arg(path), "--check".to_string(), "--quiet".to_string()]); + assert_eq!(output.code, Some(0), "stderr={}", output.stderr); + } + + let ast = run(&[arg(&project), "--ast".to_string()]); + assert_eq!(ast.code, Some(0), "stderr={}", ast.stderr); + assert!(!ast.stdout.contains("Import("), "{}", ast.stdout); + assert!(!ast.stdout.contains("Namespace {"), "{}", ast.stdout); + assert!(!ast.stdout.contains("Module {"), "{}", ast.stdout); + + let llvm = run(&[arg(&project), "--llvm".to_string()]); + assert_eq!(llvm.code, Some(0), "stderr={}", llvm.stderr); + assert!(llvm.stdout.contains("define"), "{}", llvm.stdout); + + let symbols = run(&[arg(&project), "--symbols".to_string()]); + assert_eq!(symbols.code, Some(0), "stderr={}", symbols.stderr); + assert!( + symbols.stdout.contains("billing/api::Tax::addTax"), + "{}", + symbols.stdout + ); + assert!(!symbols.stdout.contains("__osp_"), "{}", symbols.stdout); + assert_project_main_symbol_is_local(&symbols.stdout, &project.join("src/main.osp")); +} + +fn assert_project_main_symbol_is_local(json: &str, source: &Path) { + let value = serde_json::from_str::(json).expect("valid symbols JSON"); + let main = value.as_array().and_then(|entries| { + entries.iter().find(|entry| { + entry.get("name").and_then(serde_json::Value::as_str) == Some("app::main") + }) + }); + let expected_line = std::fs::read_to_string(source) + .expect("read entry source") + .lines() + .position(|line| line.trim_start().starts_with("fn main")) + .and_then(|line| u64::try_from(line.saturating_add(1)).ok()); + assert_eq!( + main.and_then(|entry| entry.get("line")) + .and_then(serde_json::Value::as_u64), + expected_line + ); + assert_eq!( + main.and_then(|entry| entry.get("path")) + .and_then(serde_json::Value::as_str), + std::fs::canonicalize(source) + .ok() + .as_deref() + .and_then(Path::to_str) + ); +} + +#[test] +fn mixed_flavor_path_independent_project_runs() { + let project = fixture(); + let output = run(&[arg(&project), "--run".to_string()]); + assert_eq!(output.code, Some(0), "stderr={}", output.stderr); + assert_eq!(output.stdout, "tax=110 counter=1/2\n"); +} + +#[test] +fn module_aware_single_file_uses_assembly_without_loading_siblings() { + let directory = + std::env::temp_dir().join(format!("osprey_single_module_e2e_{}", std::process::id())); + let _ = std::fs::remove_dir_all(&directory); + std::fs::create_dir_all(&directory).expect("create single-source directory"); + let source = directory.join("main.osp"); + let namespace = directory + .file_name() + .and_then(|name| name.to_str()) + .expect("temporary directory has an identifier name"); + std::fs::write( + &source, + format!( + concat!( + "module Answers {{\n", + " export fn answer() -> int = 42\n", + "}}\n", + "import {}::Answers::{{answer}}\n", + "fn main() = print(\"answer=${{answer()}}\")\n", + ), + namespace + ), + ) + .expect("write single module source"); + std::fs::write(directory.join("broken.osp"), "fn = = =\n").expect("write ignored sibling"); + + let output = run(&[arg(&source), "--run".to_string()]); + assert_eq!(output.code, Some(0), "stderr={}", output.stderr); + assert_eq!(output.stdout, "answer=42\n"); + let relative = run_in(&directory, &["main.osp", "--check", "--quiet"]); + assert_eq!(relative.code, Some(0), "stderr={}", relative.stderr); + let _ = std::fs::remove_dir_all(directory); +} + +#[test] +fn manifest_free_project_identity_is_path_spelling_independent() { + let directory = + std::env::temp_dir().join(format!("osprey_manifest_free_e2e_{}", std::process::id())); + let _ = std::fs::remove_dir_all(&directory); + let sources = directory.join("src"); + std::fs::create_dir_all(&sources).expect("create manifest-free source root"); + let namespace = directory + .file_name() + .and_then(|name| name.to_str()) + .expect("temporary directory has an identifier name"); + std::fs::write( + sources.join("values.osp"), + "module Answers {\n export fn answer() -> int = 42\n}\n", + ) + .expect("write module source"); + std::fs::write( + sources.join("main.osp"), + format!("import {namespace}::Answers::{{answer}}\nfn main() = print(\"${{answer()}}\")\n"), + ) + .expect("write entry source"); + + let absolute = run(&[ + arg(&directory), + "--check".to_string(), + "--quiet".to_string(), + ]); + assert_eq!(absolute.code, Some(0), "stderr={}", absolute.stderr); + let relative = run_in(&directory, &[".", "--check", "--quiet"]); + assert_eq!(relative.code, Some(0), "stderr={}", relative.stderr); + let _ = std::fs::remove_dir_all(directory); +} + +#[test] +fn ordinary_script_bypasses_project_name_mangling() { + let source = std::env::temp_dir().join(format!( + "osprey_plain_script_e2e_{}.osp", + std::process::id() + )); + std::fs::write( + &source, + "fn historicalName(value: int) -> int = value\nprint(historicalName(7))\n", + ) + .expect("write ordinary script"); + let output = run(&[arg(&source), "--llvm".to_string()]); + assert_eq!(output.code, Some(0), "stderr={}", output.stderr); + assert!( + output.stdout.contains("@historicalName("), + "{}", + output.stdout + ); + assert!(!output.stdout.contains("__osp_"), "{}", output.stdout); + let _ = std::fs::remove_file(source); +} + +#[cfg(unix)] +#[test] +fn link_directives_from_a_non_entry_source_reach_the_native_driver() { + use std::os::unix::fs::PermissionsExt; + + let project = copy_fixture("link_directives"); + let module = project.join("src/deep/unrelated/tax.osp"); + let source = std::fs::read_to_string(&module).expect("read non-entry source"); + std::fs::write( + &module, + format!("// @link: proof_from_non_entry\n// @linkdir: /proof/non-entry\n{source}"), + ) + .expect("write link directives"); + let driver = project.join("record-cc.sh"); + std::fs::write( + &driver, + "#!/bin/sh\nprintf '%s\\n' \"$@\" > \"$OSPREY_CC_LOG\"\n", + ) + .expect("write recording compiler"); + let mut permissions = std::fs::metadata(&driver) + .expect("read driver metadata") + .permissions(); + permissions.set_mode(0o755); + std::fs::set_permissions(&driver, permissions).expect("make driver executable"); + let log = project.join("cc-args.txt"); + let output_path = project.join("ignored-output"); + let mut command = osprey(); + let _ = command + .arg(&project) + .arg("--compile") + .arg("-o") + .arg(&output_path) + .env("OSPREY_CC", &driver) + .env("OSPREY_CC_LOG", &log); + let output = finish(&mut command); + assert_eq!(output.code, Some(0), "stderr={}", output.stderr); + let arguments = std::fs::read_to_string(log).expect("read recorded compiler args"); + assert!(arguments.lines().any(|arg| arg == "-lproof_from_non_entry")); + assert!(arguments.lines().any(|arg| arg == "-L/proof/non-entry")); + let _ = std::fs::remove_dir_all(project); +} + +#[test] +fn build_subcommand_uses_project_name_inside_project_directory() { + let project = copy_fixture("build"); + let artifact = project.join("modules"); + let output = run_in(&project, &["build", "--quiet"]); + assert_eq!(output.code, Some(0), "stderr={}", output.stderr); + assert!(artifact.is_file(), "missing {}", artifact.display()); + + let executed = Command::new(&artifact).output().expect("run built project"); + assert!(executed.status.success()); + assert_eq!( + String::from_utf8_lossy(&executed.stdout), + "tax=110 counter=1/2\n" + ); + let _ = std::fs::remove_dir_all(project); +} + +#[test] +fn flattened_type_errors_map_back_to_physical_local_lines() { + let project = copy_fixture("diagnostic"); + let cream = project.join("src/cream.ospml"); + let source = std::fs::read_to_string(&cream).expect("read ML source"); + let broken = source.replace( + "export label cents = \"tax=${taxApi::Tax::addTax cents}\"", + "export label : int -> int\n label cents = \"tax=${taxApi::Tax::addTax cents}\"", + ); + assert_ne!(broken, source, "fixture mutation must change the ML source"); + let line = broken + .lines() + .position(|line| line.contains("label cents =")) + .map_or(0, |line| line.saturating_add(1)); + std::fs::write(&cream, broken).expect("write broken ML source"); + + let output = run(&[arg(&project), "--check".to_string()]); + assert_ne!(output.code, Some(0)); + let expected = format!("{}:{line}:", cream.display()); + assert!(output.stderr.contains(&expected), "{}", output.stderr); + let _ = std::fs::remove_dir_all(project); +} diff --git a/crates/osprey-codegen/src/freevars.rs b/crates/osprey-codegen/src/freevars.rs index 377deebb..73d4567b 100644 --- a/crates/osprey-codegen/src/freevars.rs +++ b/crates/osprey-codegen/src/freevars.rs @@ -37,6 +37,7 @@ fn walk(e: &Expr, bound: &mut Vec, out: &mut BTreeSet) { match e { Expr::Integer(_) | Expr::Float(_) | Expr::Str(_) | Expr::Bool(_) => {} Expr::Identifier(n) => note(n, bound, out), + Expr::Path(path) => note(&path.to_string(), bound, out), Expr::InterpolatedStr(parts) => { for p in parts { if let InterpolatedPart::Expr(inner) = p { diff --git a/crates/osprey-codegen/src/lib.rs b/crates/osprey-codegen/src/lib.rs index c1b722bb..8d1fb3f8 100644 --- a/crates/osprey-codegen/src/lib.rs +++ b/crates/osprey-codegen/src/lib.rs @@ -64,6 +64,11 @@ fn stmt_idents(s: &osprey_ast::Stmt, out: &mut std::collections::BTreeSet { + for item in body { + stmt_idents(&item.declaration, out); + } + } + Stmt::Namespace { body, .. } => { for inner in body { stmt_idents(inner, out); } diff --git a/crates/osprey-fmt/src/lib.rs b/crates/osprey-fmt/src/lib.rs index 116061f9..b86edb1a 100644 --- a/crates/osprey-fmt/src/lib.rs +++ b/crates/osprey-fmt/src/lib.rs @@ -167,4 +167,54 @@ mod tests { assert_eq!(indent_to(2), " "); assert_eq!(indent_to(-3), ""); } + + #[test] + fn default_modules_preserve_file_namespace_paths_and_signature_blocks() { + // [MODULES-FILE-SCOPED-NAMESPACE] Formatting changes indentation only; + // the semicolon namespace and `::` qualification survive verbatim. + let src = concat!( + "namespace \"com.example/reports\";\n", + "signature TaxApi {\n", + " fn rate() -> int\n", + "}\n", + "module Tax : TaxApi {\n", + " export fn rate() -> int = 10\n", + "}\n", + "import \"com.example/reports\" as reports\n", + "let gross = reports::Tax::rate()\n", + ); + let once = format_source(src, Flavor::Default).expect("formats modules"); + assert_eq!(once, src, "canonical module source is preserved"); + assert!( + once.starts_with("namespace \"com.example/reports\";\n"), + "{once}" + ); + assert!(once.contains(" fn rate() -> int\n"), "{once}"); + assert!(once.contains("reports::Tax::rate()"), "{once}"); + assert_eq!( + format_source(&once, Flavor::Default).expect("idempotent"), + once + ); + } + + #[test] + fn ml_layout_import_members_and_modules_are_preserved_idempotently() { + // [MODULES-IMPORT] The creamy ML surface keeps layout member imports; + // `::` remains qualification and no Default braces/semicolons appear. + let src = concat!( + "namespace billing\n", + "import billing::Tax\n", + " addTax\n", + " zero as noTax\n", + "module Invoice\n", + " export total = addTax 100\n", + ); + let once = format_source(src, Flavor::Ml).expect("formats ML modules"); + assert_eq!(once, src, "canonical ML module source is preserved"); + assert!(once.contains("import billing::Tax\n"), "{once}"); + assert!(once.contains(" addTax\n zero as noTax\n"), "{once}"); + assert!(once.contains("module Invoice\n export total"), "{once}"); + assert!(!once.contains('{') && !once.contains(';'), "{once}"); + assert_eq!(format_source(&once, Flavor::Ml).expect("idempotent"), once); + } } diff --git a/crates/osprey-lsp/src/analysis.rs b/crates/osprey-lsp/src/analysis.rs index b824775c..64058b7b 100644 --- a/crates/osprey-lsp/src/analysis.rs +++ b/crates/osprey-lsp/src/analysis.rs @@ -6,14 +6,20 @@ //! `osprey --hover` CLI modes render from here. use osprey_ast::{ - walk_each, Expr, ExternParameter, InterpolatedPart, Parameter, Position, Program, Stmt, - TypeExpr, + walk_each, Expr, ExternParameter, InterpolatedPart, NamedArgument, Parameter, Position, + Program, Stmt, TypeExpr, }; use std::fmt::Write as _; /// What kind of declaration a [`SymbolInfo`] describes. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum SymbolKind { + /// A logical namespace contribution. + Namespace, + /// A closed plain/state module boundary. + Module, + /// An explicit module interface. + Signature, /// A function or `extern fn`. Function, /// A `let` binding. @@ -27,6 +33,9 @@ impl SymbolKind { #[must_use] pub const fn as_str(self) -> &'static str { match self { + Self::Namespace => "namespace", + Self::Module => "module", + Self::Signature => "signature", Self::Function => "function", Self::Variable => "variable", Self::Type => "type", @@ -37,8 +46,10 @@ impl SymbolKind { /// One outline entry derived from a top-level declaration. #[derive(Debug, Clone)] pub struct SymbolInfo { - /// Declared name. + /// Collision-safe qualified source name (`billing::Tax::addTax`). pub name: String, + /// Name as written on the declaration line (`addTax` / `Tax`). + pub source_name: String, /// What sort of declaration this is. pub kind: SymbolKind, /// Rendered type/category text (signature for functions, annotation for @@ -62,19 +73,101 @@ pub struct SymbolInfo { #[must_use] pub fn collect_symbols(program: &Program) -> Vec { let mut out = Vec::new(); - collect(&program.statements, &mut out); + collect(&program.statements, &[], &mut out); out } -fn collect(stmts: &[Stmt], out: &mut Vec) { +fn collect(stmts: &[Stmt], prefix: &[String], out: &mut Vec) { for stmt in stmts { match stmt { - Stmt::Module { body, .. } => collect(body, out), - other => out.extend(sym_of(other)), + Stmt::Namespace { + name, + body, + position, + .. + } => { + let label = name.label(); + out.push(container_sym( + prefix, + label, + SymbolKind::Namespace, + *position, + )); + let child_prefix = extended(prefix, std::slice::from_ref(&label.to_owned())); + collect(body, &child_prefix, out); + } + Stmt::Module { + path, + body, + position, + .. + } => { + out.push(container_sym( + prefix, + &path.to_string(), + SymbolKind::Module, + *position, + )); + let child_prefix = extended(prefix, &path.segments); + for item in body { + collect( + std::slice::from_ref(item.declaration.as_ref()), + &child_prefix, + out, + ); + } + } + Stmt::Signature { name, position, .. } => out.push(container_sym( + prefix, + name, + SymbolKind::Signature, + *position, + )), + other => { + if let Some(mut symbol) = sym_of(other) { + qualify_symbol(&mut symbol, prefix); + out.push(symbol); + } + } } } } +fn extended(prefix: &[String], segments: &[String]) -> Vec { + prefix.iter().chain(segments).cloned().collect() +} + +fn qualified(prefix: &[String], source_name: &str) -> String { + if prefix.is_empty() { + source_name.to_owned() + } else { + format!("{}::{source_name}", prefix.join("::")) + } +} + +fn qualify_symbol(symbol: &mut SymbolInfo, prefix: &[String]) { + symbol.name = qualified(prefix, &symbol.source_name); +} + +fn container_sym( + prefix: &[String], + source_name: &str, + kind: SymbolKind, + position: Option, +) -> SymbolInfo { + SymbolInfo { + name: qualified(prefix, source_name), + source_name: source_name.to_owned(), + kind, + ty: kind.as_str().to_owned(), + position, + signature: None, + parameters: Vec::new(), + return_type: None, + doc: None, + } +} + /// Collect every binding in the program — top-level declarations *and* `let`s /// nested in expression bodies (function/handler/match/block bodies) — so hover /// resolves local variables, not only top-level names. Source order. @@ -82,62 +175,116 @@ fn collect(stmts: &[Stmt], out: &mut Vec) { #[must_use] pub fn collect_all_symbols(program: &Program) -> Vec { let mut out = Vec::new(); - walk_stmts(&program.statements, &mut out); + walk_stmts(&program.statements, &[], &mut out); out } -fn walk_stmts(stmts: &[Stmt], out: &mut Vec) { +fn walk_stmts(stmts: &[Stmt], prefix: &[String], out: &mut Vec) { for stmt in stmts { - out.extend(sym_of(stmt)); - walk_stmt_body(stmt, out); + match stmt { + Stmt::Namespace { + name, + body, + position, + .. + } => { + let label = name.label().to_owned(); + out.push(container_sym( + prefix, + &label, + SymbolKind::Namespace, + *position, + )); + walk_stmts(body, &extended(prefix, &[label]), out); + } + Stmt::Module { + path, + body, + position, + .. + } => { + out.push(container_sym( + prefix, + &path.to_string(), + SymbolKind::Module, + *position, + )); + let child_prefix = extended(prefix, &path.segments); + for item in body { + walk_stmts( + std::slice::from_ref(item.declaration.as_ref()), + &child_prefix, + out, + ); + } + } + Stmt::Signature { name, position, .. } => out.push(container_sym( + prefix, + name, + SymbolKind::Signature, + *position, + )), + other => { + if let Some(mut symbol) = sym_of(other) { + qualify_symbol(&mut symbol, prefix); + out.push(symbol); + } + walk_stmt_body(other, prefix, out); + } + } } } -fn walk_stmt_body(stmt: &Stmt, out: &mut Vec) { +fn walk_stmt_body(stmt: &Stmt, prefix: &[String], out: &mut Vec) { match stmt { - Stmt::Module { body, .. } => walk_stmts(body, out), - Stmt::Function { body, .. } => walk_expr(body, out), + Stmt::Function { body, .. } => walk_expr(body, prefix, out), Stmt::Let { value, .. } | Stmt::Assignment { value, .. } | Stmt::Expr { value, .. } => { - walk_expr(value, out); + walk_expr(value, prefix, out); } _ => {} } } /// Descend an expression collecting nested `let` bindings (first third). -fn walk_expr(e: &Expr, out: &mut Vec) { +fn walk_expr(e: &Expr, prefix: &[String], out: &mut Vec) { match e { Expr::InterpolatedStr(parts) => parts.iter().for_each(|p| { if let InterpolatedPart::Expr(x) = p { - walk_expr(x, out); + walk_expr(x, prefix, out); } }), - Expr::List(xs) => walk_each(xs, out, |x| x, walk_expr), + Expr::List(xs) => walk_each(xs, out, |x| x, |x, out| walk_expr(x, prefix, out)), Expr::Map(entries) => entries.iter().for_each(|en| { - walk_expr(&en.key, out); - walk_expr(&en.value, out); + walk_expr(&en.key, prefix, out); + walk_expr(&en.value, prefix, out); }), - Expr::Object(fields) => walk_each(fields, out, |f| &f.value, walk_expr), + Expr::Object(fields) => walk_each( + fields, + out, + |f| &f.value, + |x, out| { + walk_expr(x, prefix, out); + }, + ), Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { - walk_expr(left, out); - walk_expr(right, out); + walk_expr(left, prefix, out); + walk_expr(right, prefix, out); } - Expr::Unary { operand, .. } => walk_expr(operand, out), - other => walk_expr_rest(other, out), + Expr::Unary { operand, .. } => walk_expr(operand, prefix, out), + other => walk_expr_rest(other, prefix, out), } } /// Continuation of [`walk_expr`] — call/navigation/block forms (second third). -fn walk_expr_rest(e: &Expr, out: &mut Vec) { +fn walk_expr_rest(e: &Expr, prefix: &[String], out: &mut Vec) { match e { Expr::Call { function, arguments, named_arguments, } => { - walk_expr(function, out); - walk_each(arguments, out, |x| x, walk_expr); - walk_each(named_arguments, out, |n| &n.value, walk_expr); + walk_expr(function, prefix, out); + walk_arguments(arguments, named_arguments, prefix, out); } Expr::MethodCall { target, @@ -145,60 +292,95 @@ fn walk_expr_rest(e: &Expr, out: &mut Vec) { named_arguments, .. } => { - walk_expr(target, out); - walk_each(arguments, out, |x| x, walk_expr); - walk_each(named_arguments, out, |n| &n.value, walk_expr); + walk_expr(target, prefix, out); + walk_arguments(arguments, named_arguments, prefix, out); } - Expr::FieldAccess { target, .. } => walk_expr(target, out), + Expr::FieldAccess { target, .. } => walk_expr(target, prefix, out), Expr::Index { target, index } => { - walk_expr(target, out); - walk_expr(index, out); + walk_expr(target, prefix, out); + walk_expr(index, prefix, out); } - Expr::Lambda { body, .. } => walk_expr(body, out), + Expr::Lambda { body, .. } => walk_expr(body, prefix, out), Expr::Match { value, arms } => { - walk_expr(value, out); - walk_each(arms, out, |arm| &arm.body, walk_expr); + walk_expr(value, prefix, out); + walk_each( + arms, + out, + |arm| &arm.body, + |x, out| { + walk_expr(x, prefix, out); + }, + ); } Expr::Block { statements, value } => { - walk_stmts(statements, out); + walk_stmts(statements, prefix, out); if let Some(v) = value { - walk_expr(v, out); + walk_expr(v, prefix, out); } } Expr::TypeConstructor { fields, .. } | Expr::Update { fields, .. } => { - walk_each(fields, out, |f| &f.value, walk_expr); + walk_each( + fields, + out, + |f| &f.value, + |x, out| { + walk_expr(x, prefix, out); + }, + ); } - other => walk_expr_fiber(other, out), + other => walk_expr_fiber(other, prefix, out), } } /// Final third of [`walk_expr`]: fiber/effect forms; leaves fall through. -fn walk_expr_fiber(e: &Expr, out: &mut Vec) { +fn walk_expr_fiber(e: &Expr, prefix: &[String], out: &mut Vec) { match e { - Expr::Spawn(i) | Expr::Await(i) | Expr::Recv(i) | Expr::Yield(Some(i)) => walk_expr(i, out), + Expr::Spawn(i) | Expr::Await(i) | Expr::Recv(i) | Expr::Yield(Some(i)) => { + walk_expr(i, prefix, out); + } Expr::Send { channel, value } => { - walk_expr(channel, out); - walk_expr(value, out); + walk_expr(channel, prefix, out); + walk_expr(value, prefix, out); } - Expr::Select { arms } => walk_each(arms, out, |arm| &arm.body, walk_expr), + Expr::Select { arms } => walk_each( + arms, + out, + |arm| &arm.body, + |x, out| { + walk_expr(x, prefix, out); + }, + ), Expr::Perform { arguments, named_arguments, .. } => { - walk_each(arguments, out, |x| x, walk_expr); - walk_each(named_arguments, out, |n| &n.value, walk_expr); + walk_arguments(arguments, named_arguments, prefix, out); } Expr::Handler { arms, body, .. } => { for arm in arms { - walk_expr(&arm.body, out); + walk_expr(&arm.body, prefix, out); } - walk_expr(body, out); + walk_expr(body, prefix, out); } _ => {} } } +fn walk_arguments( + arguments: &[Expr], + named_arguments: &[NamedArgument], + prefix: &[String], + out: &mut Vec, +) { + for argument in arguments { + walk_expr(argument, prefix, out); + } + for argument in named_arguments { + walk_expr(&argument.value, prefix, out); + } +} + fn sym_of(stmt: &Stmt) -> Option { match stmt { Stmt::Function { @@ -336,6 +518,7 @@ fn fn_sym( let signature = format!("fn {name}({}) -> {ret}", shown.join(", ")); SymbolInfo { name: name.into(), + source_name: name.into(), kind: SymbolKind::Function, ty: signature.clone(), position, @@ -362,6 +545,7 @@ fn let_sym( ) -> SymbolInfo { SymbolInfo { name: name.into(), + source_name: name.into(), kind: SymbolKind::Variable, ty: ty.map(render_type).unwrap_or_default(), position, @@ -375,6 +559,7 @@ fn let_sym( fn decl_sym(name: &str, ty: &str, position: Option) -> SymbolInfo { SymbolInfo { name: name.into(), + source_name: name.into(), kind: SymbolKind::Type, ty: ty.into(), position, @@ -656,24 +841,48 @@ mod tests { } #[test] - fn collect_symbols_recurses_into_modules_and_skips_non_declarations() { - // A module body's declarations surface in the flat outline, while - // statements that are not declarations (the bare expression) are dropped. + fn collect_symbols_qualifies_module_members_and_skips_non_declarations() { + // [MODULES-ABI] A flat wire outline keeps collision-safe source names: + // the module itself plus qualified members, never flattened leaves. let parsed = osprey_syntax::parse_program( "module Inner {\n fn helper() -> int = 1\n let seed = 2\n}\n", ); assert!(parsed.errors.is_empty(), "{:?}", parsed.errors); let syms = collect_symbols(&parsed.program); let names: Vec<&str> = syms.iter().map(|s| s.name.as_str()).collect(); - assert!(names.contains(&"helper"), "{names:?}"); - assert!(names.contains(&"seed"), "{names:?}"); + assert_eq!(names, ["Inner", "Inner::helper", "Inner::seed"]); // The `let` carries no annotation, so its rendered type is empty and its // kind is `Variable`. - let seed = syms.iter().find(|s| s.name == "seed").expect("seed symbol"); + let seed = syms + .iter() + .find(|s| s.name == "Inner::seed") + .expect("seed symbol"); assert_eq!(seed.kind, SymbolKind::Variable); assert_eq!(seed.ty, ""); } + #[test] + fn namespace_module_and_signature_symbols_never_flatten_collisions() { + // [MODULES-NAMESPACE] Two modules may export the same leaf name. The + // outline preserves both ownership paths and the container kinds. + let parsed = osprey_syntax::parse_program( + "namespace sales { module Tax { export fn rate() = 10 } }\n\ + namespace payroll { module Tax { export fn rate() = 20 } }\n\ + signature TaxSig { fn rate() -> int }\n", + ); + assert!(parsed.errors.is_empty(), "{:?}", parsed.errors); + let symbols = collect_symbols(&parsed.program); + let named = |name: &str| symbols.iter().find(|symbol| symbol.name == name); + assert_eq!(named("sales").map(|s| s.kind), Some(SymbolKind::Namespace)); + assert_eq!( + named("sales::Tax").map(|s| s.kind), + Some(SymbolKind::Module) + ); + assert!(named("sales::Tax::rate").is_some()); + assert!(named("payroll::Tax::rate").is_some()); + assert_eq!(named("TaxSig").map(|s| s.kind), Some(SymbolKind::Signature)); + } + /// One of every container `Expr` variant, each holding a block whose single /// `let` is named for the slot it sits in — the fixture for the deep-walker /// test below. Implements [LSP-HOVER-VARIABLES] @@ -860,6 +1069,9 @@ mod tests { #[test] fn symbol_kind_as_str_round_trips_each_variant() { + assert_eq!(SymbolKind::Namespace.as_str(), "namespace"); + assert_eq!(SymbolKind::Module.as_str(), "module"); + assert_eq!(SymbolKind::Signature.as_str(), "signature"); assert_eq!(SymbolKind::Function.as_str(), "function"); assert_eq!(SymbolKind::Variable.as_str(), "variable"); assert_eq!(SymbolKind::Type.as_str(), "type"); diff --git a/crates/osprey-lsp/src/features.rs b/crates/osprey-lsp/src/features.rs index d02c55e1..8a344e5d 100644 --- a/crates/osprey-lsp/src/features.rs +++ b/crates/osprey-lsp/src/features.rs @@ -13,7 +13,7 @@ use crate::analysis::{ builtin_hover, collect_all_symbols, collect_symbols, SymbolInfo, SymbolKind, }; use crate::model::{CompletionItem, CompletionKind, Location, SignatureInfo, Span}; -use crate::text::{occurrences, prefix_to, word_at, Occurrence}; +use crate::text::{occurrences, path_at, prefix_to, Occurrence}; /// Hover markdown for the identifier at `(line, character)`: the symbol's /// signature, or `name: type` for a binding — inferring an unannotated `let`'s @@ -41,7 +41,7 @@ pub fn hover( } match best_match(&symbols, &word, line) { Some(sym) => Some(symbol_hover(sym, &parsed.program)), - None => builtin_hover(&word), + None => builtin_hover(word.rsplit("::").next().unwrap_or(&word)), } } @@ -64,7 +64,7 @@ fn doc_link_target(text: &str, line: u32, character: u32) -> Option { && !inner.contains(char::is_whitespace) && inner .chars() - .all(|c| c.is_alphanumeric() || c == '_' || c == '.') + .all(|c| c.is_alphanumeric() || c == '_' || c == '.' || c == ':') && inner.chars().next().is_some_and(char::is_alphabetic); (dotted && !followed_by_paren).then(|| inner.to_string()) } @@ -73,10 +73,13 @@ fn doc_link_target(text: &str, line: u32, character: u32) -> Option { /// declaration or a builtin; a dotted `Effect.op` / `Type.variant` resolves to /// the owner declaration's hover. Implements [DOC-LINK]. fn resolve_link(symbols: &[SymbolInfo], target: &str, program: &Program) -> Option { - let head = target.split('.').next().unwrap_or(target); + let head = target + .split(['.', ':']) + .find(|segment| !segment.is_empty()) + .unwrap_or(target); symbols .iter() - .find(|s| s.name == head) + .find(|symbol| symbol_matches(symbol, head)) .map(|s| symbol_hover(s, program)) .or_else(|| builtin_hover(head)) } @@ -86,18 +89,31 @@ fn resolve_link(symbols: &[SymbolInfo], target: &str, program: &Program) -> Opti /// first match — resolving local shadowing without a full scope walk. fn best_match<'a>(symbols: &'a [SymbolInfo], word: &str, line: u32) -> Option<&'a SymbolInfo> { let cursor = line.saturating_add(1); // AST positions are 1-based lines. - let matches = || symbols.iter().filter(|s| s.name == word); + let matches = || symbols.iter().filter(|symbol| symbol_matches(symbol, word)); matches() .filter(|s| s.position.is_some_and(|p| p.line <= cursor)) .max_by_key(|s| s.position.map_or(0, |p| p.line)) .or_else(|| matches().next()) } +fn symbol_matches(symbol: &SymbolInfo, query: &str) -> bool { + symbol.name == query + || symbol.source_name == query + || (query.contains("::") + && symbol + .name + .strip_suffix(query) + .is_some_and(|prefix| prefix.is_empty() || prefix.ends_with("::"))) +} + /// Render `s` as hover markdown: a code-fenced signature/type, then its docs. fn symbol_hover(s: &SymbolInfo, program: &Program) -> String { - let code = match &s.signature { - Some(sig) => sig.clone(), - None => format!("{}: {}", s.name, displayed_type(s, program)), + let code = match (s.kind, &s.signature) { + (_, Some(sig)) => sig.clone(), + (SymbolKind::Namespace | SymbolKind::Module | SymbolKind::Signature, None) => { + format!("{} {}", s.kind.as_str(), s.name) + } + (_, None) => format!("{}: {}", s.name, displayed_type(s, program)), }; let mut out = format!("```osprey\n{code}\n```"); if let Some(doc) = &s.doc { @@ -150,15 +166,30 @@ pub fn references( let Some(word) = word_under(text, line, character, enc) else { return Vec::new(); }; - let decls: Vec<(u32, u32)> = declarations(text, uri, &word, enc) - .iter() - .map(|o| (o.line, o.start)) - .collect(); - occurrences(text, &word, enc) + let declarations = declarations(text, uri, &word, enc); + let decls: Vec<(u32, u32)> = declarations.iter().map(|o| (o.line, o.start)).collect(); + let mut found: Vec = occurrences(text, &word, enc) .into_iter() .filter(|o| include_declaration || !decls.contains(&(o.line, o.start))) .map(|o| located(uri, (o.line, o.start, o.line, o.end))) - .collect() + .collect(); + if include_declaration { + for declaration in declarations { + let location = located( + uri, + ( + declaration.line, + declaration.start, + declaration.line, + declaration.end, + ), + ); + if !found.contains(&location) { + found.push(location); + } + } + } + found } /// Signature help for the call enclosing `(line, character)`. @@ -175,7 +206,7 @@ pub fn signature_help( let parsed = osprey_syntax::parse_program_for_path(path, text); let sym = collect_symbols(&parsed.program) .into_iter() - .find(|s| s.name == name && s.kind == SymbolKind::Function)?; + .find(|s| symbol_matches(s, &name) && s.kind == SymbolKind::Function)?; let params: Vec = sym.parameters.iter().map(param_label).collect(); let last = u32::try_from(params.len().saturating_sub(1)).unwrap_or(0); Some(SignatureInfo { @@ -189,14 +220,14 @@ pub fn signature_help( #[must_use] pub fn completion(text: &str, path: &str) -> Vec { let parsed = osprey_syntax::parse_program_for_path(path, text); - keyword_items() + keyword_items(path) .into_iter() .chain(collect_symbols(&parsed.program).iter().map(symbol_item)) .collect() } fn word_under(text: &str, line: u32, character: u32, enc: PositionEncoding) -> Option { - word_at(nth_line(text, line)?, character, enc).map(|w| w.word) + path_at(nth_line(text, line)?, character, enc).map(|word| word.word) } fn nth_line(text: &str, line: u32) -> Option<&str> { @@ -217,15 +248,35 @@ fn located(uri: &str, span: Span) -> Location { /// declaration line — the location editors expect for go-to-definition. fn declarations(text: &str, path: &str, name: &str, enc: PositionEncoding) -> Vec { let parsed = osprey_syntax::parse_program_for_path(path, text); - let occs = occurrences(text, name, enc); collect_symbols(&parsed.program) .iter() - .filter(|s| s.name == name) - .filter_map(|s| s.position.map(|p| p.line.saturating_sub(1))) - .filter_map(|line| occs.iter().find(|o| o.line == line).cloned()) + .filter(|symbol| symbol_matches(symbol, name)) + .filter_map(|symbol| declaration_occurrence(text, symbol, enc)) .collect() } +fn declaration_occurrence( + text: &str, + symbol: &SymbolInfo, + enc: PositionEncoding, +) -> Option { + let position = symbol.position?; + let line = position.line.saturating_sub(1); + occurrences(text, &symbol.source_name, enc) + .into_iter() + .find(|occurrence| occurrence.line == line) + .or_else(|| { + let end = position + .column + .saturating_add(crate::text::measure(&symbol.source_name, enc)); + Some(Occurrence { + line, + start: position.column, + end, + }) + }) +} + fn param_label((name, ty): &(String, String)) -> String { if ty.is_empty() { name.clone() @@ -238,7 +289,9 @@ fn symbol_item(s: &SymbolInfo) -> CompletionItem { let kind = match s.kind { SymbolKind::Function => CompletionKind::Function, SymbolKind::Variable => CompletionKind::Variable, - SymbolKind::Type => CompletionKind::Type, + SymbolKind::Type | SymbolKind::Namespace | SymbolKind::Module | SymbolKind::Signature => { + CompletionKind::Type + } }; CompletionItem { label: s.name.clone(), @@ -249,8 +302,8 @@ fn symbol_item(s: &SymbolInfo) -> CompletionItem { } /// The fixed keyword/snippet completions (superset of the old TS server's six). -fn keyword_items() -> Vec { - const KEYWORDS: [(&str, &str, &str); 7] = [ +fn keyword_items(path: &str) -> Vec { + const BASE: [(&str, &str, &str); 7] = [ ( "if", "Conditional expression [GRAMMAR-IF-ELSE]", @@ -283,8 +336,12 @@ fn keyword_items() -> Vec { "effect ${1:Name} {\n\t${2:op}: ${3:fn() -> Unit}\n}", ), ]; - KEYWORDS - .iter() + let ml = std::path::Path::new(path) + .extension() + .is_some_and(|extension| extension.eq_ignore_ascii_case("ospml")); + let modules = module_keyword_specs(ml); + BASE.iter() + .chain(modules.iter()) .map(|(label, detail, snippet)| CompletionItem { label: (*label).to_owned(), kind: CompletionKind::Keyword, @@ -294,6 +351,67 @@ fn keyword_items() -> Vec { .collect() } +fn module_keyword_specs(ml: bool) -> [(&'static str, &'static str, &'static str); 8] { + [ + ( + "namespace", + "Logical namespace [MODULES-NAMESPACE]", + if ml { + "namespace ${1:name}" + } else { + "namespace ${1:name};" + }, + ), + ( + "import", + "Namespace/module import [MODULES-IMPORT]", + "import ${1:namespace}::${2:Module}", + ), + ( + "module", + "Closed module boundary [MODULES-MODULE]", + if ml { + "module ${1:Name}\n\t${0}" + } else { + "module ${1:Name} {\n\t${0}\n}" + }, + ), + ( + "signature", + "Explicit module interface [MODULES-SIGNATURE]", + if ml { + "signature ${1:Name}\n\t${0}" + } else { + "signature ${1:Name} {\n\t${0}\n}" + }, + ), + ( + "export", + "Export a module declaration [MODULES-EXPORTS]", + if ml { + "export ${1:name} = ${2:value}" + } else { + "export fn ${1:name}(${2:params}) = ${3:body}" + }, + ), + ( + "state", + "Durable state owner [MODULES-STATE-MODULE]", + if ml { + "state ${1:Name}\n\t${0}" + } else { + "state module ${1:Name} {\n\t${0}\n}" + }, + ), + ( + "opaque", + "Opaque exported type [MODULES-OPAQUE-TYPES]", + "opaque type ${1:Name}", + ), + ("as", "Import alias [MODULES-IMPORT]", "as ${1:Alias}"), + ] +} + /// Parse `before` (the line text up to the cursor) and return the name of the /// innermost still-open call and the active (comma-separated) argument index. /// @@ -412,6 +530,74 @@ mod tests { .any(|i| i.label == "add" && i.kind == CompletionKind::Function)); } + #[test] + fn qualified_hover_definition_and_references_resolve_one_module_member() { + // [MODULES-ABI] `::` is scanned as one symbol. Two colliding leaf names + // remain independently navigable through their qualified paths. + let src = "namespace sales {\n\ + module Tax { export fn rate() -> int = 10 }\n\ + }\n\ + namespace payroll {\n\ + module Tax { export fn rate() -> int = 20 }\n\ + }\n\ + let chosen = sales::Tax::rate()\n"; + let column = col_of(src, 6, "sales::Tax::rate"); + let hover = hover(src, "file:///modules.osp", 6, column, U16).expect("hover"); + assert!(hover.contains("fn rate() -> int"), "{hover}"); + + let definitions = definition(src, "file:///modules.osp", 6, column, U16); + assert_eq!(definitions.len(), 1, "{definitions:?}"); + assert_eq!( + definitions.first().map(|location| location.span.0), + Some(1), + "sales declaration line" + ); + + let references = references(src, "file:///modules.osp", 6, column, U16, true); + assert_eq!(references.len(), 2, "use plus declaration: {references:?}"); + assert!(!references.iter().any(|location| location.span.0 == 4)); + } + + #[test] + fn completion_includes_qualified_symbols_and_flavor_specific_module_snippets() { + // [MODULES-FLAVOR-PROJECTION] Both flavors expose the same concepts, + // while insertion text stays idiomatic for the active surface. + let src = "namespace billing { module Tax { export fn addTax(x) = x } }\n"; + let default = completion(src, "file:///billing.osp"); + assert!(default + .iter() + .any(|item| item.label == "billing::Tax::addTax")); + assert!(default.iter().any(|item| { + item.label == "state" + && item + .insert_text + .as_deref() + .is_some_and(|text| text.starts_with("state module")) + })); + for keyword in [ + "namespace", + "import", + "module", + "signature", + "export", + "opaque", + "as", + ] { + assert!( + default.iter().any(|item| item.label == keyword), + "{keyword}" + ); + } + + let ml = completion("module Tax\n x = 1\n", "file:///billing.ospml"); + assert!(ml.iter().any(|item| { + item.label == "state" + && item.insert_text.as_deref().is_some_and(|text| { + text.starts_with("state ") && !text.starts_with("state module") + }) + })); + } + #[test] fn hover_on_a_let_binding_uses_the_name_and_type_form() { // A `let` has no signature, so hover renders the `name: type` fallback. diff --git a/crates/osprey-lsp/src/text.rs b/crates/osprey-lsp/src/text.rs index d2d12e0c..3c40d636 100644 --- a/crates/osprey-lsp/src/text.rs +++ b/crates/osprey-lsp/src/text.rs @@ -92,6 +92,61 @@ pub fn word_at(line: &str, character: u32, encoding: PositionEncoding) -> Option found.or_else(|| take_if_covers(&run, run_start, offset, character)) } +/// The identifier or `::`-qualified symbol path under `character`. +/// +/// A single `:` remains punctuation (type annotation / named argument); only +/// paired separators join path segments, so `.` continues to mean value field +/// access. [MODULES-FLAVOR-PROJECTION] +#[must_use] +pub fn path_at(line: &str, character: u32, encoding: PositionEncoding) -> Option { + line_paths(line, encoding) + .into_iter() + .find(|span| character >= span.start && character <= span.end) +} + +fn line_paths(line: &str, encoding: PositionEncoding) -> Vec { + let chars: Vec = line.chars().collect(); + let mut offsets = Vec::with_capacity(chars.len().saturating_add(1)); + let mut offset = 0u32; + offsets.push(offset); + for character in &chars { + offset = offset.saturating_add(char_width(*character, encoding)); + offsets.push(offset); + } + let mut paths = Vec::new(); + let mut index = 0; + while index < chars.len() { + if !chars.get(index).is_some_and(|c| is_ident(*c)) { + index += 1; + continue; + } + let start = index; + index = consume_ident(&chars, index); + while chars.get(index) == Some(&':') + && chars.get(index + 1) == Some(&':') + && chars.get(index + 2).is_some_and(|c| is_ident(*c)) + { + index = consume_ident(&chars, index + 2); + } + let Some(word) = chars.get(start..index) else { + continue; + }; + paths.push(WordSpan { + word: word.iter().collect(), + start: offsets.get(start).copied().unwrap_or(0), + end: offsets.get(index).copied().unwrap_or(offset), + }); + } + paths +} + +fn consume_ident(chars: &[char], mut index: usize) -> usize { + while chars.get(index).is_some_and(|c| is_ident(*c)) { + index += 1; + } + index +} + /// Promote an accumulated identifier run to a [`WordSpan`] when `character` /// falls within `[start, end]` (inclusive of the trailing edge so a cursor /// resting just after the word still resolves it). @@ -109,6 +164,23 @@ fn take_if_covers(run: &str, start: u32, end: u32, character: u32) -> Option Vec { + if name.contains("::") { + return text + .lines() + .enumerate() + .flat_map(|(line, source)| { + let line = u32::try_from(line).unwrap_or(u32::MAX); + line_paths(source, encoding) + .into_iter() + .filter(move |span| span.word == name) + .map(move |span| Occurrence { + line, + start: span.start, + end: span.end, + }) + }) + .collect(); + } text.lines() .enumerate() .flat_map(|(idx, line)| line_occurrences(line, idx, name, encoding)) @@ -217,4 +289,33 @@ mod tests { assert_eq!(span.word, "total"); assert_eq!(span.start, 3); } + + #[test] + fn path_at_keeps_double_colons_and_stops_at_field_dots() { + // [MODULES-FLAVOR-PROJECTION] `::` is qualification; `.` remains value + // field access and a single `:` remains an annotation separator. + let line = "billing::Tax::addTax(invoice.total)"; + let path = path_at(line, 10, U16).expect("qualified path"); + assert_eq!(path.word, "billing::Tax::addTax"); + assert_eq!(path.start, 0); + assert_eq!(path.end, 20); + assert_eq!( + path_at(line, 29, U16).map(|span| span.word), + Some("total".into()) + ); + assert_eq!( + path_at("x: int", 3, U16).map(|span| span.word), + Some("int".into()) + ); + } + + #[test] + fn occurrences_match_a_qualified_path_as_one_symbol() { + // [MODULES-ABI] Qualified navigation must not degrade into three + // unrelated whole-word hits. + let text = "billing::Tax::addTax(1)\nTax::addTax(2)\nbilling::Tax::addTax(3)\n"; + let hits = occurrences(text, "billing::Tax::addTax", U16); + assert_eq!(hits.len(), 2, "{hits:?}"); + assert_eq!(hits.get(1).map(|hit| hit.line), Some(2)); + } } diff --git a/crates/osprey-lsp/src/wire.rs b/crates/osprey-lsp/src/wire.rs index 5488fc76..ab618479 100644 --- a/crates/osprey-lsp/src/wire.rs +++ b/crates/osprey-lsp/src/wire.rs @@ -14,7 +14,10 @@ use crate::model::{CompletionItem, CompletionKind, Location, SignatureInfo, Span use crate::text::{measure, occurrences}; // LSP `SymbolKind` numeric codes. +const SYMBOL_MODULE: u8 = 2; +const SYMBOL_NAMESPACE: u8 = 3; const SYMBOL_CLASS: u8 = 5; +const SYMBOL_INTERFACE: u8 = 11; const SYMBOL_FUNCTION: u8 = 12; const SYMBOL_VARIABLE: u8 = 13; // LSP `CompletionItemKind` numeric codes. @@ -193,6 +196,9 @@ pub fn symbols_result(symbols: &[SymbolInfo], text: &str, encoding: PositionEnco fn symbol_json(s: &SymbolInfo, text: &str, encoding: PositionEncoding) -> Value { let span = identifier_span(s, text, encoding); let kind = match s.kind { + crate::analysis::SymbolKind::Namespace => SYMBOL_NAMESPACE, + crate::analysis::SymbolKind::Module => SYMBOL_MODULE, + crate::analysis::SymbolKind::Signature => SYMBOL_INTERFACE, crate::analysis::SymbolKind::Function => SYMBOL_FUNCTION, crate::analysis::SymbolKind::Variable => SYMBOL_VARIABLE, crate::analysis::SymbolKind::Type => SYMBOL_CLASS, @@ -211,7 +217,7 @@ fn symbol_json(s: &SymbolInfo, text: &str, encoding: PositionEncoding) -> Value /// whole-word occurrence of the name; fall back to the keyword column. fn identifier_span(s: &SymbolInfo, text: &str, encoding: PositionEncoding) -> Span { let line = s.position.map_or(0, |p| p.line.saturating_sub(1)); - occurrences(text, &s.name, encoding) + occurrences(text, &s.source_name, encoding) .into_iter() .find(|o| o.line == line) .map_or_else( @@ -221,7 +227,7 @@ fn identifier_span(s: &SymbolInfo, text: &str, encoding: PositionEncoding) -> Sp line, col, line, - col.saturating_add(measure(&s.name, encoding)), + col.saturating_add(measure(&s.source_name, encoding)), ) }, |o| (o.line, o.start, o.line, o.end), @@ -371,8 +377,12 @@ mod tests { #[test] fn symbols_result_maps_every_symbol_kind_to_its_lsp_code() { - // A type, a function, and a `let` exercise all three `SymbolKind` arms. - let value = symbols_value("type Shade = Light | Dark\nfn f() -> Unit = 1\nlet x = 2\n"); + // [MODULES-NAMESPACE] Container kinds use their dedicated LSP codes. + let value = symbols_value( + "namespace app { module M { export fn f() -> Unit = 1 } }\n\ + signature Api { fn f() -> Unit }\n\ + type Shade = Light | Dark\nlet x = 2\n", + ); let by_name = |name: &str| { value .as_array() @@ -384,8 +394,11 @@ mod tests { .and_then(|s| s.pointer("/kind")) .cloned() }; + assert_eq!(by_name("app"), Some(Value::from(SYMBOL_NAMESPACE))); + assert_eq!(by_name("app::M"), Some(Value::from(SYMBOL_MODULE))); + assert_eq!(by_name("Api"), Some(Value::from(SYMBOL_INTERFACE))); assert_eq!(by_name("Shade"), Some(Value::from(SYMBOL_CLASS))); - assert_eq!(by_name("f"), Some(Value::from(SYMBOL_FUNCTION))); + assert_eq!(by_name("app::M::f"), Some(Value::from(SYMBOL_FUNCTION))); assert_eq!(by_name("x"), Some(Value::from(SYMBOL_VARIABLE))); } @@ -397,6 +410,7 @@ mod tests { // occurrence scan misses and the keyword-column fallback is used. let sym = SymbolInfo { name: "ghost".to_owned(), + source_name: "ghost".to_owned(), kind: SymbolKind::Variable, ty: "int".to_owned(), position: Some(Position { line: 1, column: 4 }), diff --git a/crates/osprey-project/src/annotation.rs b/crates/osprey-project/src/annotation.rs new file mode 100644 index 00000000..3e02f25a --- /dev/null +++ b/crates/osprey-project/src/annotation.rs @@ -0,0 +1,76 @@ +//! Signature annotation application before shared type checking. + +use crate::resolve::{Context, Locals, Resolver}; +use osprey_ast::{Expr, SignatureItem, Stmt}; + +impl Resolver<'_> { + pub(crate) fn rewrite_exprs( + &mut self, + expressions: &mut [Expr], + context: &Context, + locals: &mut Locals, + ) { + for expression in expressions { + self.rewrite_expr(expression, context, locals); + } + } + + pub(crate) fn apply_annotation( + &mut self, + statement: &mut Stmt, + annotation: &SignatureItem, + context: &Context, + ) { + match (statement, annotation) { + (Stmt::Let { ty, .. }, SignatureItem::Value { ty: contract, .. }) if ty.is_none() => { + *ty = Some(contract.clone()); + } + ( + Stmt::Function { + parameters, + return_type, + effects, + position, + .. + }, + SignatureItem::Function { + parameters: contracts, + return_type: contract_return, + effects: contract_effects, + .. + }, + ) => { + if parameters.len() != contracts.len() { + self.error( + context.source, + *position, + "function implementation arity does not match its signature", + ); + } + for (parameter, contract) in parameters.iter_mut().zip(contracts) { + if parameter.ty.is_none() { + parameter.ty = Some(contract.clone()); + } + } + if return_type.is_none() { + *return_type = Some(contract_return.clone()); + } + if effects.is_empty() { + effects.clone_from(contract_effects); + } + } + _ => {} + } + } +} + +pub(crate) fn declaration_name(statement: &Stmt) -> Option<&str> { + match statement { + Stmt::Let { name, .. } + | Stmt::Function { name, .. } + | Stmt::Extern { name, .. } + | Stmt::Type { name, .. } + | Stmt::Effect { name, .. } => Some(name), + _ => None, + } +} diff --git a/crates/osprey-project/src/assemble.rs b/crates/osprey-project/src/assemble.rs new file mode 100644 index 00000000..e71ab07e --- /dev/null +++ b/crates/osprey-project/src/assemble.rs @@ -0,0 +1,194 @@ +//! Deterministic project assembly orchestration. + +use crate::contribution; +use crate::{collect, imports, resolve, span}; +use crate::{AssembledProject, ProjectConfig, ProjectError, SourceFile, SourceMetadata}; +use osprey_ast::{Position, Stmt}; +use std::path::Path; + +pub(crate) fn assemble( + config: &ProjectConfig, + sources: &[SourceFile], +) -> Result> { + if sources.is_empty() { + return Err(vec![ProjectError { + message: "the project contains no Osprey source files".to_string(), + path: None, + line: None, + column: None, + }]); + } + let (rebased, metadata, mut errors) = rebase(sources); + let entry_source = choose_entry(config, &rebased, &metadata, &mut errors); + let contributions = contribution::extract(config, &rebased); + let (graph, mut collection_errors) = collect::collect(&contributions, &metadata); + errors.append(&mut collection_errors); + let (scopes, mut import_errors) = imports::build(config, &contributions, &graph, &metadata); + errors.append(&mut import_errors); + let Some(entry_source) = entry_source else { + return Err(errors); + }; + let mut resolution = resolve::flatten(&contributions, &scopes, &graph, entry_source, &metadata); + errors.append(&mut resolution.errors); + if errors.is_empty() { + Ok(AssembledProject { + program: resolution.program, + entry_prologue: resolution.entry_prologue, + entry_source, + sources: metadata, + source_name_by_mangled: resolution.source_names, + }) + } else { + Err(errors) + } +} + +fn rebase(sources: &[SourceFile]) -> (Vec, Vec, Vec) { + let mut sorted = sources.to_vec(); + sorted.sort_by(|left, right| left.path.cmp(&right.path)); + let mut offset = 0_u32; + let mut metadata = Vec::with_capacity(sorted.len()); + let mut errors = Vec::new(); + for (index, source) in sorted.iter_mut().enumerate() { + let line_count = source.source.lines().count().max(1); + let Ok(line_count) = u32::try_from(line_count) else { + errors.push(range_error(&source.path)); + continue; + }; + let Some(start) = offset.checked_add(1) else { + errors.push(range_error(&source.path)); + continue; + }; + let Some(end) = offset.checked_add(line_count) else { + errors.push(range_error(&source.path)); + continue; + }; + span::offset_program(&mut source.program, offset); + metadata.push(SourceMetadata { + index, + path: source.path.clone(), + flavor: source.flavor, + source: source.source.clone(), + global_line_start: start, + global_line_end: end, + }); + offset = end; + } + (sorted, metadata, errors) +} + +fn range_error(path: &Path) -> ProjectError { + ProjectError { + message: "source line range exceeds the compiler position space".to_string(), + path: Some(path.to_path_buf()), + line: None, + column: None, + } +} + +fn choose_entry( + config: &ProjectConfig, + sources: &[SourceFile], + metadata: &[SourceMetadata], + errors: &mut Vec, +) -> Option { + if let Some(configured) = &config.entry { + let candidates = metadata + .iter() + .filter(|source| source.path == *configured || source.path.ends_with(configured)) + .map(|source| source.index) + .collect::>(); + return unique_entry(&candidates, configured.to_string_lossy().as_ref(), errors); + } + let mains = sources + .iter() + .enumerate() + .filter(|(_, source)| has_namespace_main(&source.program.statements)) + .map(|(index, _)| index) + .collect::>(); + if !mains.is_empty() { + return unique_entry(&mains, "a namespace-level `main`", errors); + } + let executable = sources + .iter() + .enumerate() + .filter(|(_, source)| has_executable(&source.program.statements)) + .map(|(index, _)| index) + .collect::>(); + if !executable.is_empty() { + return unique_entry(&executable, "top-level executable statements", errors); + } + if sources.len() == 1 { + return Some(0); + } + errors.push(ProjectError { + message: "cannot infer an entry source; configure `[project].entry`".to_string(), + path: None, + line: None, + column: None, + }); + None +} + +fn unique_entry( + candidates: &[usize], + description: &str, + errors: &mut Vec, +) -> Option { + match candidates { + [entry] => Some(*entry), + [] => { + errors.push(ProjectError { + message: format!("entry source `{description}` was not found"), + path: None, + line: None, + column: None, + }); + None + } + _ => { + errors.push(ProjectError { + message: format!("entry source `{description}` is ambiguous"), + path: None, + line: None, + column: None, + }); + None + } + } +} + +fn has_namespace_main(statements: &[Stmt]) -> bool { + statements.iter().any(|statement| match statement { + Stmt::Function { name, .. } => name == "main", + Stmt::Namespace { body, .. } => has_namespace_main(body), + _ => false, + }) +} + +fn has_executable(statements: &[Stmt]) -> bool { + statements.iter().any(|statement| match statement { + Stmt::Expr { .. } | Stmt::Assignment { .. } | Stmt::Let { mutable: true, .. } => true, + Stmt::Namespace { body, .. } => has_executable(body), + _ => false, + }) +} + +pub(crate) fn source_error( + sources: &[SourceMetadata], + source: usize, + position: Option, + message: impl Into, +) -> ProjectError { + let message = message.into(); + if let Some(metadata) = sources.get(source) { + ProjectError::source(metadata, position, message) + } else { + ProjectError { + message, + path: None, + line: None, + column: None, + } + } +} diff --git a/crates/osprey-project/src/collect.rs b/crates/osprey-project/src/collect.rs new file mode 100644 index 00000000..304c5ff7 --- /dev/null +++ b/crates/osprey-project/src/collect.rs @@ -0,0 +1,411 @@ +//! Declaration and signature collection for the logical project graph. +//! Implements [MODULES-EXPORTS], [MODULES-SIGNATURE], and +//! [MODULES-STATE-TOPLEVEL]. + +use crate::collect_support::primary_name; +use crate::contribution::Contribution; +use crate::model::{ConstantInfo, DeclInfo, DeclKind, ModuleInfo, ProjectGraph, SymbolKey}; +use crate::{ProjectError, SourceMetadata}; +use osprey_ast::{ModuleItem, ModuleKind, Position, SignatureItem, Stmt, Visibility}; +use std::collections::BTreeSet; + +pub(crate) fn collect( + contributions: &[Contribution], + sources: &[SourceMetadata], +) -> (ProjectGraph, Vec) { + let mut collector = Collector { + graph: ProjectGraph::default(), + errors: Vec::new(), + sources, + }; + for (index, contribution) in contributions.iter().enumerate() { + let namespace = contribution.namespace.label(); + let _ = collector.graph.namespaces.insert(namespace.to_string()); + for statement in &contribution.statements { + collector.statement( + statement, + namespace, + &[], + Visibility::Exported, + false, + contribution.source, + index, + ); + } + } + collector.finish_signatures(); + (collector.graph, collector.errors) +} + +pub(crate) struct Collector<'a> { + pub(crate) graph: ProjectGraph, + pub(crate) errors: Vec, + pub(crate) sources: &'a [SourceMetadata], +} + +impl Collector<'_> { + #[expect( + clippy::too_many_arguments, + clippy::too_many_lines, + reason = "exhaustive declaration collection keeps AST cases visibly adjacent" + )] + fn statement( + &mut self, + statement: &Stmt, + namespace: &str, + owner: &[String], + visibility: Visibility, + opaque: bool, + source: usize, + contribution: usize, + ) { + match statement { + Stmt::Module { + path, + kind, + signature, + body, + position, + .. + } => self.module( + namespace, + owner, + path.segments.as_slice(), + *kind, + signature.clone(), + body, + visibility, + source, + contribution, + *position, + ), + Stmt::Signature { + name, + items, + position, + .. + } => self.signature(namespace, owner, name, items, source, *position), + Stmt::Let { + name, + mutable, + value, + position, + .. + } => { + if *mutable && owner.is_empty() { + self.error(source, *position, "namespace-level `mut` is forbidden"); + } + let key = key(namespace, owner, name); + self.declare( + key.clone(), + DeclKind::Value, + visibility, + owner, + source, + *position, + *mutable, + opaque, + ); + let _ = self + .graph + .implementations + .entry(key.clone()) + .or_insert_with(|| statement.clone()); + if !mutable { + let _ = self.graph.constants.insert( + key, + ConstantInfo { + value: value.clone(), + source, + contribution, + module: owner.to_vec(), + position: *position, + }, + ); + } + } + Stmt::Function { name, position, .. } => { + let key = key(namespace, owner, name); + self.declare( + key.clone(), + DeclKind::Function, + visibility, + owner, + source, + *position, + false, + opaque, + ); + let _ = self + .graph + .implementations + .entry(key) + .or_insert_with(|| statement.clone()); + } + Stmt::Extern { name, position, .. } => { + let key = key(namespace, owner, name); + self.declare( + key.clone(), + DeclKind::Extern, + visibility, + owner, + source, + *position, + false, + opaque, + ); + let _ = self + .graph + .implementations + .entry(key) + .or_insert_with(|| statement.clone()); + } + Stmt::Type { + name, + variants, + position, + .. + } => { + let type_key = key(namespace, owner, name); + self.declare( + type_key.clone(), + DeclKind::Type, + visibility, + owner, + source, + *position, + false, + opaque, + ); + let _ = self + .graph + .implementations + .entry(type_key) + .or_insert_with(|| statement.clone()); + for variant in variants.iter().filter(|variant| variant.name != *name) { + self.declare( + key(namespace, owner, &variant.name), + DeclKind::Constructor, + if opaque { + Visibility::Private + } else { + visibility + }, + owner, + source, + *position, + false, + opaque, + ); + } + } + Stmt::Effect { name, position, .. } => { + let key = key(namespace, owner, name); + self.declare( + key.clone(), + DeclKind::Effect, + visibility, + owner, + source, + *position, + false, + opaque, + ); + let _ = self + .graph + .implementations + .entry(key) + .or_insert_with(|| statement.clone()); + } + Stmt::Import(_) + | Stmt::Namespace { .. } + | Stmt::Assignment { .. } + | Stmt::Expr { .. } => {} + } + } + + #[expect( + clippy::too_many_arguments, + clippy::too_many_lines, + reason = "module metadata is supplied directly from the canonical AST node" + )] + fn module( + &mut self, + namespace: &str, + owner: &[String], + path: &[String], + kind: ModuleKind, + signature: Option, + body: &[ModuleItem], + visibility: Visibility, + source: usize, + contribution: usize, + position: Option, + ) { + let mut full = owner.to_vec(); + full.extend_from_slice(path); + let module_key = SymbolKey::new(namespace, full.clone()); + if kind == ModuleKind::State + && self.graph.modules.iter().any(|(existing, info)| { + existing.namespace == namespace && info.kind == ModuleKind::State + }) + { + self.error( + source, + position, + format!("namespace `{namespace}` may contain at most one state module"), + ); + } + self.declare( + module_key.clone(), + DeclKind::Module, + visibility, + owner, + source, + position, + kind == ModuleKind::State, + false, + ); + let _ = self + .graph + .implementations + .entry(module_key.clone()) + .or_insert_with(|| Stmt::Module { + path: osprey_ast::SymbolPath::new(path.iter().cloned()), + kind, + signature: signature.clone(), + body: body.to_vec(), + doc: None, + position, + }); + let explicit_exports = body + .iter() + .filter(|item| item.visibility == Visibility::Exported) + .filter_map(|item| primary_name(&item.declaration)) + .collect::>(); + let mut state_cells = BTreeSet::new(); + let mut effects = BTreeSet::new(); + for item in body { + if let Stmt::Let { + name, + mutable: true, + position, + .. + } = item.declaration.as_ref() + { + if kind == ModuleKind::Plain { + self.error( + source, + *position, + "plain modules cannot declare module-level `mut`", + ); + } else { + let _ = state_cells.insert(name.clone()); + if item.visibility == Visibility::Exported { + self.error( + source, + *position, + "`export mut` is forbidden in a state module", + ); + } + } + } + if let Stmt::Effect { name, .. } = item.declaration.as_ref() { + let _ = effects.insert(name.clone()); + } + self.statement( + &item.declaration, + namespace, + &full, + item.visibility, + item.opaque, + source, + contribution, + ); + } + let info = ModuleInfo { + kind, + signature, + exports: explicit_exports.clone(), + explicit_exports, + state_cells, + effects, + source, + position, + }; + if self + .graph + .modules + .insert(module_key.clone(), info) + .is_some() + { + self.error( + source, + position, + format!("duplicate module `{}`", module_key.source_name()), + ); + } + } + + fn signature( + &mut self, + namespace: &str, + owner: &[String], + name: &str, + items: &[SignatureItem], + source: usize, + position: Option, + ) { + let signature = key(namespace, owner, name); + if self + .graph + .signatures + .insert(signature.clone(), items.to_vec()) + .is_some() + { + self.error( + source, + position, + format!("duplicate signature `{}`", signature.source_name()), + ); + } + } + + #[expect( + clippy::too_many_arguments, + clippy::needless_pass_by_value, + reason = "declaration registration owns its stable graph key and source metadata" + )] + fn declare( + &mut self, + key: SymbolKey, + kind: DeclKind, + visibility: Visibility, + owner: &[String], + source: usize, + position: Option, + state_owner: bool, + opaque: bool, + ) { + let info = DeclInfo { + kind, + visibility, + owner: owner.to_vec(), + state_owner, + opaque, + }; + if self.graph.declarations.insert(key.clone(), info).is_some() { + self.error( + source, + position, + format!("duplicate declaration `{}`", key.source_name()), + ); + } + } +} + +fn key(namespace: &str, owner: &[String], name: &str) -> SymbolKey { + let mut path = owner.to_vec(); + path.push(name.to_string()); + SymbolKey::new(namespace, path) +} diff --git a/crates/osprey-project/src/collect_support.rs b/crates/osprey-project/src/collect_support.rs new file mode 100644 index 00000000..091dfc62 --- /dev/null +++ b/crates/osprey-project/src/collect_support.rs @@ -0,0 +1,32 @@ +//! Small declaration helpers shared by graph collection. + +use crate::model::DeclKind; +use osprey_ast::{SignatureItem, Stmt}; + +pub(crate) fn primary_name(statement: &Stmt) -> Option { + match statement { + Stmt::Let { name, .. } + | Stmt::Function { name, .. } + | Stmt::Extern { name, .. } + | Stmt::Type { name, .. } + | Stmt::Effect { name, .. } + | Stmt::Signature { name, .. } => Some(name.clone()), + Stmt::Module { path, .. } => path.last().map(str::to_string), + _ => None, + } +} + +pub(crate) fn signature_name_kind(item: &SignatureItem) -> (&str, DeclKind) { + match item { + SignatureItem::Value { name, .. } => (name, DeclKind::Value), + SignatureItem::Function { name, .. } => (name, DeclKind::Function), + SignatureItem::Type { name, .. } => (name, DeclKind::Type), + SignatureItem::Effect { name, .. } => (name, DeclKind::Effect), + SignatureItem::Module { path, .. } => (path.last().unwrap_or_default(), DeclKind::Module), + } +} + +pub(crate) fn kind_matches(actual: DeclKind, expected: DeclKind) -> bool { + actual == expected + || (matches!(expected, DeclKind::Function) && matches!(actual, DeclKind::Extern)) +} diff --git a/crates/osprey-project/src/contract.rs b/crates/osprey-project/src/contract.rs new file mode 100644 index 00000000..9f46c9d3 --- /dev/null +++ b/crates/osprey-project/src/contract.rs @@ -0,0 +1,396 @@ +//! Structural module-signature conformance checks. +//! Implements [MODULES-SIGNATURE] and [MODULES-EFFECTS]. + +use osprey_ast::{ + EffectOperation, EffectRef, SignatureAscription, SignatureItem, SignatureType, Stmt, TypeExpr, + TypeParam, +}; + +pub(crate) fn hides_type(item: &SignatureItem) -> bool { + matches!( + item, + SignatureItem::Type { + definition: SignatureType::Abstract, + .. + } | SignatureItem::Type { opaque: true, .. } + ) +} + +#[expect( + clippy::too_many_lines, + reason = "structural conformance is an exhaustive canonical AST pair match" +)] +pub(crate) fn errors(implementation: &Stmt, contract: &SignatureItem) -> Vec { + match (implementation, contract) { + ( + Stmt::Let { + ty: Some(actual), .. + }, + SignatureItem::Value { name, ty, .. }, + ) if !same_type(actual, ty) => { + vec![format!("value `{name}` type does not match its signature")] + } + ( + Stmt::Function { + type_params, + parameters, + return_type, + effects, + .. + }, + SignatureItem::Function { + name, + type_params: expected_binders, + parameters: expected_parameters, + return_type: expected_return, + effects: expected_effects, + .. + }, + ) => function_errors( + name, + FunctionShape { + binders: type_params, + parameters: parameters.iter().map(|parameter| parameter.ty.as_ref()), + return_type: return_type.as_ref(), + effects, + }, + &ExpectedFunction { + binders: expected_binders, + parameters: expected_parameters, + return_type: expected_return, + effects: expected_effects, + }, + ), + ( + Stmt::Extern { + parameters, + return_type, + .. + }, + SignatureItem::Function { + name, + type_params, + parameters: expected_parameters, + return_type: expected_return, + effects: expected_effects, + .. + }, + ) => function_errors( + name, + FunctionShape { + binders: &[], + parameters: parameters.iter().map(|parameter| Some(¶meter.ty)), + return_type: return_type.as_ref(), + effects: &[], + }, + &ExpectedFunction { + binders: type_params, + parameters: expected_parameters, + return_type: expected_return, + effects: expected_effects, + }, + ), + ( + Stmt::Type { + type_params, alias, .. + }, + SignatureItem::Type { + name, + type_params: expected_binders, + definition, + .. + }, + ) => type_errors( + name, + type_params, + alias.as_ref(), + expected_binders, + definition, + ), + ( + Stmt::Effect { + type_params, + operations, + .. + }, + SignatureItem::Effect { + name, + type_params: expected_binders, + operations: expected, + .. + }, + ) => effect_errors(name, type_params, operations, expected_binders, expected), + ( + Stmt::Module { signature, .. }, + SignatureItem::Module { + path, + signature: expected, + .. + }, + ) if signature + .as_ref() + .is_none_or(|actual| !same_ascription(actual, expected)) => + { + vec![format!( + "nested module `{path}` does not match its signature ascription" + )] + } + _ => Vec::new(), + } +} + +struct FunctionShape<'a, I> { + binders: &'a [TypeParam], + parameters: I, + return_type: Option<&'a TypeExpr>, + effects: &'a [EffectRef], +} + +struct ExpectedFunction<'a> { + binders: &'a [TypeParam], + parameters: &'a [TypeExpr], + return_type: &'a TypeExpr, + effects: &'a [EffectRef], +} + +fn function_errors<'a>( + name: &str, + actual: FunctionShape<'a, impl Iterator>>, + expected: &ExpectedFunction<'a>, +) -> Vec { + let actual_parameters = actual.parameters.collect::>(); + let mut errors = Vec::new(); + if actual.binders.len() != expected.binders.len() { + errors.push(format!( + "function `{name}` generic arity does not match its signature" + )); + } + if actual_parameters.len() != expected.parameters.len() { + errors.push(format!( + "function `{name}` parameter count does not match its signature" + )); + } + if actual_parameters + .iter() + .zip(expected.parameters) + .any(|(found, contract)| { + found.is_some_and(|found| { + !same_bound_type(found, contract, actual.binders, expected.binders) + }) + }) + { + errors.push(format!( + "function `{name}` parameter types do not match its signature" + )); + } + if actual.return_type.is_some_and(|found| { + !same_bound_type( + found, + expected.return_type, + actual.binders, + expected.binders, + ) + }) { + errors.push(format!( + "function `{name}` return type does not match its signature" + )); + } + if !actual.effects.is_empty() + && !same_effects( + actual.effects, + expected.effects, + actual.binders, + expected.binders, + ) + { + errors.push(format!( + "function `{name}` effect row does not match its signature" + )); + } + errors +} + +fn type_errors( + name: &str, + binders: &[TypeParam], + actual: Option<&TypeExpr>, + expected_binders: &[TypeParam], + definition: &SignatureType, +) -> Vec { + let mut errors = Vec::new(); + if binders.len() != expected_binders.len() { + errors.push(format!( + "type `{name}` generic arity does not match its signature" + )); + } + if let SignatureType::Manifest(expected) = definition { + if actual.is_none_or(|actual| !same_bound_type(actual, expected, binders, expected_binders)) + { + errors.push(format!( + "manifest type `{name}` does not match its signature" + )); + } + } + errors +} + +fn effect_errors( + name: &str, + binders: &[TypeParam], + actual: &[EffectOperation], + expected_binders: &[TypeParam], + expected: &[EffectOperation], +) -> Vec { + let matches = binders.len() == expected_binders.len() + && actual.len() == expected.len() + && expected.iter().all(|contract| { + actual + .iter() + .find(|operation| operation.name == contract.name) + .is_some_and(|operation| { + same_operation(operation, contract, binders, expected_binders) + }) + }); + if matches { + Vec::new() + } else { + vec![format!( + "effect `{name}` operations do not match its signature" + )] + } +} + +fn same_operation( + left: &EffectOperation, + right: &EffectOperation, + left_binders: &[TypeParam], + right_binders: &[TypeParam], +) -> bool { + left.parameters.len() == right.parameters.len() + && left + .parameters + .iter() + .zip(&right.parameters) + .all(|(left, right)| match (&left.ty, &right.ty) { + (Some(left), Some(right)) => { + same_bound_type(left, right, left_binders, right_binders) + } + (None, None) => true, + _ => false, + }) + && normalize_written_type(&left.return_type, left_binders) + == normalize_written_type(&right.return_type, right_binders) +} + +fn same_effects( + left: &[EffectRef], + right: &[EffectRef], + left_binders: &[TypeParam], + right_binders: &[TypeParam], +) -> bool { + left.len() == right.len() + && left.iter().zip(right).all(|(left, right)| { + left.name == right.name + && left.type_args.len() == right.type_args.len() + && left + .type_args + .iter() + .zip(&right.type_args) + .all(|(left, right)| same_bound_type(left, right, left_binders, right_binders)) + }) +} + +fn same_type(left: &TypeExpr, right: &TypeExpr) -> bool { + same_bound_type(left, right, &[], &[]) +} + +fn same_bound_type( + left: &TypeExpr, + right: &TypeExpr, + left_binders: &[TypeParam], + right_binders: &[TypeParam], +) -> bool { + same_type_name(&left.name, &right.name, left_binders, right_binders) + && left.is_array == right.is_array + && left.is_function == right.is_function + && same_types( + &left.generic_params, + &right.generic_params, + left_binders, + right_binders, + ) + && option_type_eq( + left.array_element.as_deref(), + right.array_element.as_deref(), + left_binders, + right_binders, + ) + && same_types( + &left.parameter_types, + &right.parameter_types, + left_binders, + right_binders, + ) + && option_type_eq( + left.return_type.as_deref(), + right.return_type.as_deref(), + left_binders, + right_binders, + ) +} + +fn same_types( + left: &[TypeExpr], + right: &[TypeExpr], + left_binders: &[TypeParam], + right_binders: &[TypeParam], +) -> bool { + left.len() == right.len() + && left + .iter() + .zip(right) + .all(|(left, right)| same_bound_type(left, right, left_binders, right_binders)) +} + +fn option_type_eq( + left: Option<&TypeExpr>, + right: Option<&TypeExpr>, + left_binders: &[TypeParam], + right_binders: &[TypeParam], +) -> bool { + match (left, right) { + (Some(left), Some(right)) => same_bound_type(left, right, left_binders, right_binders), + (None, None) => true, + _ => false, + } +} + +fn same_type_name( + left: &str, + right: &str, + left_binders: &[TypeParam], + right_binders: &[TypeParam], +) -> bool { + let left_index = left_binders.iter().position(|binder| binder.name == left); + let right_index = right_binders.iter().position(|binder| binder.name == right); + match (left_index, right_index) { + (Some(left), Some(right)) => left == right, + (None, None) => left == right, + _ => false, + } +} + +fn same_ascription(left: &SignatureAscription, right: &SignatureAscription) -> bool { + left.path == right.path && left.allow_extra == right.allow_extra +} + +fn normalize_written_type(value: &str, binders: &[TypeParam]) -> String { + let mut normalized = value.to_string(); + for (index, binder) in binders.iter().enumerate() { + normalized = normalized.replace(&binder.name, &format!("${index}")); + } + normalized + .chars() + .filter(|character| !character.is_whitespace()) + .collect() +} diff --git a/crates/osprey-project/src/contribution.rs b/crates/osprey-project/src/contribution.rs index 3483aa52..35311fef 100644 --- a/crates/osprey-project/src/contribution.rs +++ b/crates/osprey-project/src/contribution.rs @@ -23,22 +23,35 @@ pub(crate) fn extract(config: &ProjectConfig, sources: &[SourceFile]) -> Vec Vec { let mut out = Vec::new(); let mut unscoped = Vec::new(); + let file_imports: Vec = statements + .iter() + .filter_map(|statement| match statement { + Stmt::Import(import) => Some(import.clone()), + _ => None, + }) + .collect(); for statement in statements { match statement { Stmt::Namespace { name, body, .. } => { - out.push(build(source, name.clone(), body.clone())); + out.push(build(source, name.clone(), body.clone(), &file_imports)); } + Stmt::Import(_) => {} other => unscoped.push(other.clone()), } } if !unscoped.is_empty() { - out.push(build(source, default_name(config), unscoped)); + out.push(build(source, default_name(config), unscoped, &file_imports)); } out } -fn build(source: usize, namespace: NamespaceName, statements: Vec) -> Contribution { - let mut imports = Vec::new(); +fn build( + source: usize, + namespace: NamespaceName, + statements: Vec, + file_imports: &[ImportDecl], +) -> Contribution { + let mut imports = file_imports.to_vec(); let mut declarations = Vec::new(); for statement in statements { match statement { @@ -87,6 +100,8 @@ mod tests { }, }; let found = extract(&ProjectConfig::for_root(Path::new("app")), &[source]); - assert_eq!(found[0].namespace.label(), "billing/api"); + assert!(found + .first() + .is_some_and(|item| item.namespace.label() == "billing/api")); } } diff --git a/crates/osprey-project/src/imports.rs b/crates/osprey-project/src/imports.rs new file mode 100644 index 00000000..0330eee2 --- /dev/null +++ b/crates/osprey-project/src/imports.rs @@ -0,0 +1,299 @@ +//! Import validation and contribution-local lookup scopes. +//! Implements [MODULES-IMPORT] and its wildcard/ambiguity policy. + +use crate::contribution::Contribution; +use crate::model::{ProjectGraph, SymbolKey}; +use crate::{ProjectConfig, ProjectError, SourceMetadata}; +use osprey_ast::{ImportDecl, ImportMember, ImportSelection, ModuleKind, Position}; +use std::collections::{BTreeMap, BTreeSet}; + +#[derive(Debug, Clone, Default)] +pub(crate) struct ImportScope { + aliases: BTreeMap, + members: BTreeMap, + ambiguous: BTreeSet, +} + +impl ImportScope { + pub fn alias(&self, name: &str) -> Option<&SymbolKey> { + self.aliases.get(name) + } + + pub fn member(&self, name: &str) -> Option<&SymbolKey> { + self.members.get(name) + } + + pub fn is_ambiguous(&self, name: &str) -> bool { + self.ambiguous.contains(name) + } + + pub fn aliases_for(&self, target: &SymbolKey) -> Vec { + self.aliases + .iter() + .filter(|(_, candidate)| *candidate == target) + .map(|(name, _)| name.clone()) + .collect() + } +} + +pub(crate) fn build( + config: &ProjectConfig, + contributions: &[Contribution], + graph: &ProjectGraph, + sources: &[SourceMetadata], +) -> (Vec, Vec) { + let mut builder = Builder { + config, + graph, + sources, + errors: Vec::new(), + }; + let scopes = contributions + .iter() + .map(|contribution| builder.scope(contribution)) + .collect(); + (scopes, builder.errors) +} + +struct Builder<'a> { + config: &'a ProjectConfig, + graph: &'a ProjectGraph, + sources: &'a [SourceMetadata], + errors: Vec, +} + +impl Builder<'_> { + fn scope(&mut self, contribution: &Contribution) -> ImportScope { + let mut scope = ImportScope::default(); + for import in &contribution.imports { + self.import(contribution, import, &mut scope); + } + for name in scope + .aliases + .keys() + .filter(|name| scope.members.contains_key(*name)) + .cloned() + .collect::>() + { + let _ = scope.ambiguous.insert(name); + } + for name in &scope.ambiguous { + self.error( + contribution.source, + None, + format!("ambiguous import binding `{name}`; add an explicit alias"), + ); + } + scope + } + + fn import( + &mut self, + contribution: &Contribution, + import: &ImportDecl, + scope: &mut ImportScope, + ) { + let target = SymbolKey::new( + import.target.namespace.label(), + import.target.path.segments.clone(), + ); + if !self.target_exists(&target) { + self.error( + contribution.source, + import.position, + format!("unknown import target `{}`", target.source_name()), + ); + return; + } + if !self.target_visible(&target) { + self.error( + contribution.source, + import.position, + format!("module `{}` is private", target.source_name()), + ); + return; + } + match &import.selection { + ImportSelection::Whole => { + let Some(alias) = whole_alias(import) else { + self.error( + contribution.source, + import.position, + "a quoted namespace import requires `as Alias`", + ); + return; + }; + insert_binding(&mut scope.aliases, &mut scope.ambiguous, alias, target); + } + ImportSelection::Members(members) => { + for member in members { + self.member(contribution, import, &target, member, scope); + } + } + ImportSelection::Wildcard => self.wildcard(contribution, import, &target, scope), + } + } + + fn member( + &mut self, + contribution: &Contribution, + import: &ImportDecl, + target: &SymbolKey, + member: &ImportMember, + scope: &mut ImportScope, + ) { + let key = target.child(&member.name); + if !self.member_visible(target, &key) { + let description = if self.graph.declarations.contains_key(&key) { + "private" + } else { + "unknown" + }; + self.error( + contribution.source, + import.position, + format!("{description} imported member `{}`", key.source_name()), + ); + return; + } + insert_binding( + &mut scope.members, + &mut scope.ambiguous, + member.alias.clone().unwrap_or_else(|| member.name.clone()), + key, + ); + } + + fn wildcard( + &mut self, + contribution: &Contribution, + import: &ImportDecl, + target: &SymbolKey, + scope: &mut ImportScope, + ) { + if !self.config.allow_wildcard_imports { + self.error( + contribution.source, + import.position, + "wildcard imports are disabled by `[modules].allow_wildcard_imports`", + ); + return; + } + let target_is_state = self + .graph + .modules + .get(target) + .is_some_and(|module| module.kind == ModuleKind::State); + let includes_state = self.direct_visible_members(target).iter().any(|member| { + self.graph + .modules + .get(member) + .is_some_and(|module| module.kind == ModuleKind::State) + }); + if target_is_state || includes_state { + self.error( + contribution.source, + import.position, + "wildcard imports from state modules are forbidden", + ); + return; + } + for key in self.direct_visible_members(target) { + let Some(name) = key.path.last().cloned() else { + continue; + }; + insert_binding(&mut scope.members, &mut scope.ambiguous, name, key); + } + } + + fn target_exists(&self, target: &SymbolKey) -> bool { + if target.path.is_empty() { + self.graph.namespaces.contains(&target.namespace) + } else { + self.graph.modules.contains_key(target) + } + } + + fn target_visible(&self, target: &SymbolKey) -> bool { + target.path.is_empty() + || (1..=target.path.len()).all(|length| { + let prefix = target.path.get(..length).unwrap_or_default().to_vec(); + let key = SymbolKey::new(target.namespace.clone(), prefix); + self.graph + .declarations + .get(&key) + .is_some_and(|declaration| { + declaration.visibility == osprey_ast::Visibility::Exported + }) + }) + } + + fn member_visible(&self, target: &SymbolKey, member: &SymbolKey) -> bool { + let Some(declaration) = self.graph.declarations.get(member) else { + return false; + }; + if target.path.is_empty() { + return declaration.owner.is_empty(); + } + self.graph.modules.get(target).is_some_and(|module| { + member + .path + .last() + .is_some_and(|name| module.exports.contains(name)) + }) + } + + fn direct_visible_members(&self, target: &SymbolKey) -> Vec { + self.graph + .declarations + .keys() + .filter(|key| key.namespace == target.namespace) + .filter(|key| key.parent_path() == target.path) + .filter(|key| self.member_visible(target, key)) + .cloned() + .collect() + } + + fn error(&mut self, source: usize, position: Option, message: impl Into) { + if let Some(metadata) = self.sources.get(source) { + self.errors + .push(ProjectError::source(metadata, position, message)); + } else { + self.errors.push(ProjectError { + message: message.into(), + path: None, + line: None, + column: None, + }); + } + } +} + +fn whole_alias(import: &ImportDecl) -> Option { + if let Some(alias) = &import.alias { + return Some(alias.clone()); + } + if let Some(last) = import.target.path.last() { + return Some(last.to_string()); + } + if import.target.namespace.is_quoted() { + None + } else { + Some(import.target.namespace.label().to_string()) + } +} + +fn insert_binding( + bindings: &mut BTreeMap, + ambiguous: &mut BTreeSet, + name: String, + target: SymbolKey, +) { + if let Some(previous) = bindings.get(&name) { + if previous != &target { + let _ = ambiguous.insert(name); + } + } else { + let _ = bindings.insert(name, target); + } +} diff --git a/crates/osprey-project/src/lib.rs b/crates/osprey-project/src/lib.rs index 20df5071..7d3cd7ed 100644 --- a/crates/osprey-project/src/lib.rs +++ b/crates/osprey-project/src/lib.rs @@ -6,13 +6,31 @@ //! canonical program for checking and code generation. Implements //! [MODULES-MODEL], [MODULES-PATH-INDEPENDENCE], and [MODULES-PROJECT]. +mod annotation; +mod assemble; +mod collect; +mod collect_support; +mod contract; mod contribution; +mod imports; mod manifest; mod model; +mod name_resolve; +mod opaque; +mod purity; +mod resolve; +mod rewrite; +mod signature_collect; mod source; +mod span; +mod state; +mod state_support; +mod symbol_rewrite; +mod type_rewrite; pub use manifest::ProjectConfig; use osprey_syntax::Flavor; +use std::collections::BTreeMap; use std::path::{Path, PathBuf}; /// One source file selected for project assembly. @@ -37,6 +55,8 @@ pub struct ProjectError { pub path: Option, /// One-based source line, when applicable. pub line: Option, + /// Zero-based source column, when applicable. + pub column: Option, } impl ProjectError { @@ -45,6 +65,7 @@ impl ProjectError { message: message.into(), path: None, line: Some(line), + column: None, } } @@ -53,11 +74,92 @@ impl ProjectError { message: error.to_string(), path: Some(path.to_path_buf()), line: None, + column: None, } } + + fn source( + source: &SourceMetadata, + position: Option, + message: impl Into, + ) -> Self { + let local = position.and_then(|position| source.local_line(position.line)); + Self { + message: message.into(), + path: Some(source.path.clone()), + line: local.and_then(|line| usize::try_from(line).ok()), + column: position.and_then(|position| usize::try_from(position.column).ok()), + } + } +} + +/// Source identity and global-line mapping retained after project flattening. +#[derive(Debug, Clone)] +pub struct SourceMetadata { + /// Source index used by project diagnostics and [`AssembledProject::entry_source`]. + pub index: usize, + /// Physical source path. + pub path: PathBuf, + /// Flavor selected for this file. + pub flavor: Flavor, + /// Original source text, retained for FFI link directives and tooling. + pub source: String, + /// First one-based line assigned to this source in the flattened position space. + pub global_line_start: u32, + /// Last one-based line assigned to this source in the flattened position space. + pub global_line_end: u32, +} + +impl SourceMetadata { + /// Map a flattened global line back to this source's one-based local line. + #[must_use] + pub fn local_line(&self, global: u32) -> Option { + (self.global_line_start..=self.global_line_end) + .contains(&global) + .then(|| { + global + .saturating_sub(self.global_line_start) + .saturating_add(1) + }) + } +} + +/// One fully assembled project ready for the shared checker and backend. +#[derive(Debug, Clone)] +pub struct AssembledProject { + /// Flavor-neutral flat program with imports/modules removed and names resolved. + pub program: osprey_ast::Program, + /// Ordered executable statements contributed by the entry source. + pub entry_prologue: Vec, + /// Index into [`Self::sources`] for the configured or inferred entry source. + pub entry_source: usize, + /// Source metadata and disjoint position ranges in deterministic path order. + pub sources: Vec, + /// Source-level qualified name for each deterministic internal linkage name. + pub source_name_by_mangled: BTreeMap, +} + +impl AssembledProject { + /// Metadata for the selected entry source, or `None` for a malformed value. + #[must_use] + pub fn entry(&self) -> Option<&SourceMetadata> { + self.sources.get(self.entry_source) + } + + /// Find the physical source and local line for a flattened position. + #[must_use] + pub fn source_at_line(&self, global: u32) -> Option<(&SourceMetadata, u32)> { + self.sources + .iter() + .find_map(|source| source.local_line(global).map(|line| (source, line))) + } } /// Read a directory project and parse every configured source file. +/// +/// # Errors +/// +/// Returns discovery, I/O, flavor-selection, and syntax diagnostics. pub fn load(root: &Path) -> Result<(ProjectConfig, Vec), Vec> { let manifest_path = root.join("osprey.toml"); let config = load_config(root, &manifest_path)?; @@ -65,6 +167,28 @@ pub fn load(root: &Path) -> Result<(ProjectConfig, Vec), Vec Result> { + assemble::assemble(config, sources) +} + +/// Load and assemble a directory project in one operation. +/// +/// # Errors +/// +/// Returns all loading, parsing, and project-assembly diagnostics. +pub fn load_and_assemble(root: &Path) -> Result> { + let (config, sources) = load(root)?; + assemble(&config, &sources) +} + fn load_config(root: &Path, manifest_path: &Path) -> Result> { if !manifest_path.is_file() { return Ok(ProjectConfig::for_root(root)); @@ -98,15 +222,19 @@ fn parse_sources( } } -fn parse_source(path: PathBuf, configured: Option) -> Result> { - let source = std::fs::read_to_string(&path) - .map_err(|error| vec![ProjectError::io(&path, &error)])?; +fn parse_source( + path: PathBuf, + configured: Option, +) -> Result> { + let source = + std::fs::read_to_string(&path).map_err(|error| vec![ProjectError::io(&path, &error)])?; let label = path.to_string_lossy(); let flavor = osprey_syntax::resolve_flavor(configured, &label, &source).map_err(|message| { vec![ProjectError { message, path: Some(path.clone()), line: None, + column: None, }] })?; let parsed = osprey_syntax::parse_program_with_flavor(&source, flavor); @@ -118,6 +246,7 @@ fn parse_source(path: PathBuf, configured: Option) -> Result Result> { let root = path.parent().unwrap_or_else(|| Path::new(".")); let mut config = Self::for_root(root); @@ -127,7 +135,10 @@ fn parse_list(value: &str) -> Result, String> { if inner.trim().is_empty() { return Ok(Vec::new()); } - inner.split(',').map(|item| parse_string(item.trim())).collect() + inner + .split(',') + .map(|item| parse_string(item.trim())) + .collect() } fn parse_bool(value: &str) -> Result { diff --git a/crates/osprey-project/src/model.rs b/crates/osprey-project/src/model.rs index ee0595e2..31b65952 100644 --- a/crates/osprey-project/src/model.rs +++ b/crates/osprey-project/src/model.rs @@ -1,6 +1,8 @@ //! Canonical names and declaration metadata used while assembling a project. -use osprey_ast::{ModuleKind, Position, SignatureAscription, SignatureItem, Visibility}; +use osprey_ast::{ + Expr, ModuleKind, Position, SignatureAscription, SignatureItem, Stmt, Visibility, +}; use std::collections::{BTreeMap, BTreeSet}; /// Stable logical identity of a declaration. @@ -60,6 +62,7 @@ fn push_hex_segment(out: &mut String, segment: &str) { #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(crate) enum DeclKind { Function, + Extern, Value, Type, Constructor, @@ -73,14 +76,14 @@ pub(crate) struct DeclInfo { pub kind: DeclKind, pub visibility: Visibility, pub owner: Vec, - pub source: usize, - pub position: Option, pub state_owner: bool, + pub opaque: bool, } impl DeclInfo { - pub fn visible_from(&self, module: &[String]) -> bool { - self.visibility == Visibility::Exported || module.starts_with(&self.owner) + pub fn visible_from(&self, same_namespace: bool, module: &[String]) -> bool { + self.visibility == Visibility::Exported + || (same_namespace && module.starts_with(&self.owner)) } } @@ -90,19 +93,33 @@ pub(crate) struct ModuleInfo { pub kind: ModuleKind, pub signature: Option, pub exports: BTreeSet, + pub explicit_exports: BTreeSet, pub state_cells: BTreeSet, pub effects: BTreeSet, - pub handler_functions: BTreeSet, pub source: usize, pub position: Option, } +/// One immutable declaration eligible for compile-time inlining. +#[derive(Debug, Clone)] +pub(crate) struct ConstantInfo { + pub value: Expr, + pub source: usize, + pub contribution: usize, + pub module: Vec, + pub position: Option, +} + /// Collected declarations and explicit signatures for a project. #[derive(Debug, Default)] pub(crate) struct ProjectGraph { pub declarations: BTreeMap, pub modules: BTreeMap, pub signatures: BTreeMap>, + pub constants: BTreeMap, + pub annotations: BTreeMap, + pub namespaces: BTreeSet, + pub implementations: BTreeMap, } #[cfg(test)] @@ -115,7 +132,10 @@ mod tests { let one = SymbolKey::new("billing/api", vec!["Tax".into(), "add".into()]); let two = SymbolKey::new("billing", vec!["api".into(), "Tax".into(), "add".into()]); assert_ne!(one.mangled(), two.mangled()); - assert!(one.mangled().chars().all(|c| c.is_ascii_alphanumeric() || c == '_')); + assert!(one + .mangled() + .chars() + .all(|c| c.is_ascii_alphanumeric() || c == '_')); assert_eq!(one.source_name(), "billing/api::Tax::add"); } } diff --git a/crates/osprey-project/src/name_resolve.rs b/crates/osprey-project/src/name_resolve.rs new file mode 100644 index 00000000..9b7d5db8 --- /dev/null +++ b/crates/osprey-project/src/name_resolve.rs @@ -0,0 +1,146 @@ +//! Logical path lookup with lexical precedence and boundary checks. +//! Implements [MODULES-RESOLUTION] and [MODULES-EXPORTS]. + +use crate::model::SymbolKey; +use crate::resolve::{Context, Resolver}; +use osprey_ast::Position; + +impl Resolver<'_> { + pub fn resolve_bare( + &mut self, + name: &str, + context: &Context, + position: Option, + ) -> Option { + let scope = self.scopes.get(context.contribution); + for depth in (0..=context.module.len()).rev() { + let mut path = context.module.get(..depth).unwrap_or_default().to_vec(); + path.push(name.to_string()); + let key = SymbolKey::new(context.namespace.clone(), path); + if self.symbol_visible(&key, context) { + return Some(key); + } + } + if scope.is_some_and(|scope| scope.is_ambiguous(name)) { + self.error( + context.source, + position, + format!("ambiguous imported name `{name}`"), + ); + return None; + } + scope.and_then(|scope| scope.member(name)).cloned() + } + + pub fn resolve_path( + &mut self, + segments: &[String], + context: &Context, + position: Option, + ) -> Option { + let Some(first) = segments.first() else { + self.error(context.source, position, "empty symbol path"); + return None; + }; + for key in self.path_candidates(first, segments, context) { + if !self.graph.declarations.contains_key(&key) { + continue; + } + if let Some(hidden) = self.hidden_boundary(&key, context) { + self.error( + context.source, + position, + format!("module `{}` is private", hidden.source_name()), + ); + return None; + } + if self.symbol_visible(&key, context) { + return Some(key); + } + self.error( + context.source, + position, + format!("declaration `{}` is private", key.source_name()), + ); + return None; + } + self.error( + context.source, + position, + format!("unknown symbol path `{}`", segments.join("::")), + ); + None + } + + pub fn rewrite_value_name(&mut self, name: &mut String, context: &Context, required: bool) { + let key = if name.contains("::") { + let segments = name.split("::").map(str::to_string).collect::>(); + self.resolve_path(&segments, context, None) + } else { + self.resolve_bare(name, context, None) + }; + if let Some(key) = key { + *name = self.link_name(&key, false); + } else if required && name.contains("::") { + self.error( + context.source, + None, + format!("unknown constructor `{name}`"), + ); + } + } + + pub(crate) fn rewrite_effect_name(&mut self, name: &mut String, context: &Context) { + let qualified = name.contains("::"); + self.rewrite_value_name(name, context, qualified); + } + + fn path_candidates( + &self, + first: &str, + segments: &[String], + context: &Context, + ) -> Vec { + let tail = segments.get(1..).unwrap_or_default(); + let scope = self.scopes.get(context.contribution); + let mut candidates = Vec::new(); + for depth in (0..=context.module.len()).rev() { + let mut path = context.module.get(..depth).unwrap_or_default().to_vec(); + path.extend_from_slice(segments); + candidates.push(SymbolKey::new(context.namespace.clone(), path)); + } + if let Some(base) = scope.and_then(|scope| scope.alias(first)) { + candidates.push(extend_key(base, tail)); + } + if let Some(base) = scope.and_then(|scope| scope.member(first)) { + candidates.push(extend_key(base, tail)); + } + if self.graph.namespaces.contains(first) { + candidates.push(SymbolKey::new(first, tail.to_vec())); + } + candidates + } + + fn symbol_visible(&self, key: &SymbolKey, context: &Context) -> bool { + self.graph.declarations.get(key).is_some_and(|declaration| { + declaration.visible_from(key.namespace == context.namespace, &context.module) + }) + } + + fn hidden_boundary(&self, key: &SymbolKey, context: &Context) -> Option { + (1..key.path.len()).find_map(|length| { + let path = key.path.get(..length).unwrap_or_default().to_vec(); + let boundary = SymbolKey::new(key.namespace.clone(), path); + self.graph + .modules + .get(&boundary) + .and_then(|_| (!self.symbol_visible(&boundary, context)).then_some(boundary)) + }) + } +} + +fn extend_key(base: &SymbolKey, tail: &[String]) -> SymbolKey { + let mut path = base.path.clone(); + path.extend_from_slice(tail); + SymbolKey::new(base.namespace.clone(), path) +} diff --git a/crates/osprey-project/src/opaque.rs b/crates/osprey-project/src/opaque.rs new file mode 100644 index 00000000..30649116 --- /dev/null +++ b/crates/osprey-project/src/opaque.rs @@ -0,0 +1,22 @@ +//! Explicit flat-backend boundary for opaque manifest aliases. + +use crate::resolve::{Context, Resolver}; +use osprey_ast::Stmt; + +impl Resolver<'_> { + pub(crate) fn reject_opaque_alias(&mut self, statement: &Stmt, context: &Context) { + let Stmt::Type { name, position, .. } = statement else { + return; + }; + self.error( + context.source, + *position, + format!( + "opaque alias `{name}` is unsupported by the flat checker; representation would leak" + ), + ); + let mut rewritten = statement.clone(); + self.rewrite_declaration(&mut rewritten, context, true, false); + self.program.push(rewritten); + } +} diff --git a/crates/osprey-project/src/purity.rs b/crates/osprey-project/src/purity.rs new file mode 100644 index 00000000..062f66d1 --- /dev/null +++ b/crates/osprey-project/src/purity.rs @@ -0,0 +1,29 @@ +//! Conservative compile-time initializer purity classification. + +use osprey_ast::{Expr, InterpolatedPart}; + +pub(crate) fn is_pure(expression: &Expr) -> bool { + match expression { + Expr::Integer(_) | Expr::Float(_) | Expr::Str(_) | Expr::Bool(_) => true, + Expr::InterpolatedStr(parts) => parts.iter().all(|part| match part { + InterpolatedPart::Text(_) => true, + InterpolatedPart::Expr(value) => is_pure(value), + }), + Expr::List(items) => items.iter().all(is_pure), + Expr::Map(entries) => entries + .iter() + .all(|entry| is_pure(&entry.key) && is_pure(&entry.value)), + Expr::Object(fields) | Expr::TypeConstructor { fields, .. } => { + fields.iter().all(|field| is_pure(&field.value)) + } + Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { + is_pure(left) && is_pure(right) + } + Expr::Unary { operand, .. } + | Expr::FieldAccess { + target: operand, .. + } => is_pure(operand), + Expr::Index { target, index } => is_pure(target) && is_pure(index), + _ => false, + } +} diff --git a/crates/osprey-project/src/resolve.rs b/crates/osprey-project/src/resolve.rs new file mode 100644 index 00000000..f8485531 --- /dev/null +++ b/crates/osprey-project/src/resolve.rs @@ -0,0 +1,483 @@ +//! Project flattening and logical-name resolution. +//! Implements [MODULES-ABI], [MODULES-ENTRYPOINT], and [MODULES-INIT]. + +use crate::assemble::source_error; +use crate::contribution::Contribution; +use crate::imports::ImportScope; +use crate::model::{DeclKind, ProjectGraph, SymbolKey}; +use crate::purity::is_pure; +use crate::{state, ProjectError, SourceMetadata}; +use osprey_ast::{Expr, ModuleItem, ModuleKind, Position, Program, Stmt, TypeExpr}; +use std::collections::{BTreeMap, BTreeSet}; + +pub(crate) struct Resolution { + pub program: Program, + pub entry_prologue: Vec, + pub source_names: BTreeMap, + pub errors: Vec, +} + +#[derive(Debug, Clone)] +pub(crate) struct Context { + pub contribution: usize, + pub source: usize, + pub namespace: String, + pub module: Vec, +} + +#[derive(Debug, Clone)] +pub(crate) struct AliasInfo { + pub type_params: Vec, + pub value: TypeExpr, + pub opaque: bool, + pub owner: Vec, + pub source: usize, + pub contribution: usize, +} + +#[derive(Debug, Clone, Default)] +pub(crate) struct Locals { + pub values: BTreeSet, + pub types: BTreeSet, +} + +pub(crate) struct Resolver<'a> { + pub graph: &'a ProjectGraph, + pub scopes: &'a [ImportScope], + pub sources: &'a [SourceMetadata], + pub entry_source: usize, + pub errors: Vec, + pub source_names: BTreeMap, + pub aliases: BTreeMap, + pub alias_active: BTreeSet, + pub constant_cache: BTreeMap, + pub constant_active: BTreeSet, + pub invalid_constants: BTreeSet, + pub runtime_constants: BTreeSet, + pub entry_runtime_names: BTreeSet, + pub(crate) program: Vec, + entry_prologue: Vec, + entry_locals: Locals, + entry_main_count: usize, + extern_names: BTreeMap, +} + +pub(crate) fn flatten( + contributions: &[Contribution], + scopes: &[ImportScope], + graph: &ProjectGraph, + entry_source: usize, + sources: &[SourceMetadata], +) -> Resolution { + let aliases = collect_aliases(contributions, graph); + let mut resolver = Resolver { + graph, + scopes, + sources, + entry_source, + errors: Vec::new(), + source_names: BTreeMap::new(), + aliases, + alias_active: BTreeSet::new(), + constant_cache: BTreeMap::new(), + constant_active: BTreeSet::new(), + invalid_constants: BTreeSet::new(), + runtime_constants: BTreeSet::new(), + entry_runtime_names: BTreeSet::new(), + program: Vec::new(), + entry_prologue: Vec::new(), + entry_locals: Locals::default(), + entry_main_count: 0, + extern_names: BTreeMap::new(), + }; + resolver.classify_constants(); + for (index, contribution) in contributions.iter().enumerate() { + let context = Context { + contribution: index, + source: contribution.source, + namespace: contribution.namespace.label().to_string(), + module: Vec::new(), + }; + for statement in &contribution.statements { + resolver.flatten_statement(statement, &context, false); + } + } + resolver.finish() +} + +impl Resolver<'_> { + fn finish(mut self) -> Resolution { + if self.entry_main_count == 0 { + self.program.extend(self.entry_prologue.clone()); + } else if self.entry_main_count == 1 { + for statement in &mut self.program { + if let Stmt::Function { name, body, .. } = statement { + if name == "main" { + inject_prologue(body, &self.entry_prologue); + break; + } + } + } + } + Resolution { + program: Program { + statements: self.program, + }, + entry_prologue: self.entry_prologue, + source_names: self.source_names, + errors: self.errors, + } + } + + fn classify_constants(&mut self) { + let keys = self.graph.constants.keys().cloned().collect::>(); + for key in keys { + if self.constant_value(&key).is_some() { + continue; + } + let Some(info) = self.graph.constants.get(&key) else { + continue; + }; + if info.source == self.entry_source + && info.module.is_empty() + && !self.invalid_constants.contains(&key) + { + let _ = self.runtime_constants.insert(key.clone()); + if let Some(name) = key.path.last() { + let _ = self.entry_runtime_names.insert(name.clone()); + } + } else if !self.invalid_constants.contains(&key) { + self.error( + info.source, + info.position, + format!( + "initializer for `{}` must be a compile-time constant", + key.source_name() + ), + ); + let _ = self.invalid_constants.insert(key); + } + } + } + + fn flatten_statement(&mut self, statement: &Stmt, context: &Context, opaque: bool) { + match statement { + Stmt::Module { + path, kind, body, .. + } => self.flatten_module(path.segments.as_slice(), *kind, body, context), + Stmt::Let { name, .. } => self.flatten_let(statement, name, context), + Stmt::Function { + name, + parameters, + position, + .. + } => { + let entry_main = context.source == self.entry_source + && context.module.is_empty() + && name == "main"; + if name == "main" + && context.module.is_empty() + && context.source != self.entry_source + { + self.error( + context.source, + *position, + "namespace-level `main` is only allowed in the selected entry source", + ); + } + if entry_main { + self.entry_main_count = self.entry_main_count.saturating_add(1); + if self.entry_main_count > 1 { + self.error( + context.source, + *position, + "the entry source declares more than one namespace-level `main`", + ); + } + if !parameters.is_empty() { + self.error( + context.source, + *position, + "project entry function `main` cannot have parameters", + ); + } + } + let mut rewritten = statement.clone(); + self.rewrite_declaration(&mut rewritten, context, opaque, entry_main); + self.program.push(rewritten); + } + Stmt::Extern { name, position, .. } => { + let key = symbol_key(context, name); + if let Some(previous) = self.extern_names.get(name) { + if previous != &key { + self.error( + context.source, + *position, + format!("external symbol `{name}` is declared by multiple modules"), + ); + } + return; + } + let _ = self.extern_names.insert(name.clone(), key); + let mut rewritten = statement.clone(); + self.rewrite_declaration(&mut rewritten, context, opaque, false); + self.program.push(rewritten); + } + Stmt::Type { alias: Some(_), .. } if !opaque => { + let mut declaration = statement.clone(); + self.rewrite_declaration(&mut declaration, context, false, false); + } + Stmt::Type { alias: Some(_), .. } if opaque => { + self.reject_opaque_alias(statement, context); + } + Stmt::Type { .. } | Stmt::Effect { .. } => { + let mut rewritten = statement.clone(); + self.rewrite_declaration(&mut rewritten, context, opaque, false); + self.program.push(rewritten); + } + Stmt::Assignment { position, .. } | Stmt::Expr { position, .. } => { + if context.source == self.entry_source && context.module.is_empty() { + let mut rewritten = statement.clone(); + self.rewrite_entry_statement(&mut rewritten, context); + self.entry_prologue.push(rewritten); + } else { + self.error( + context.source, + *position, + "executable top-level statements are only allowed in the entry source", + ); + } + } + Stmt::Import(_) | Stmt::Namespace { .. } | Stmt::Signature { .. } => {} + } + } + + fn flatten_module( + &mut self, + path: &[String], + kind: ModuleKind, + items: &[ModuleItem], + context: &Context, + ) { + let mut module_path = context.module.clone(); + module_path.extend_from_slice(path); + let key = SymbolKey::new(context.namespace.clone(), module_path.clone()); + let mut body = items.to_vec(); + if kind == ModuleKind::State { + self.validate_state_initializers(&body, context, &module_path); + } + state::prepare( + &key, + &mut body, + self.graph, + self.scopes.get(context.contribution), + self.sources, + &mut self.errors, + ); + let nested = Context { + contribution: context.contribution, + source: context.source, + namespace: context.namespace.clone(), + module: module_path, + }; + for item in &body { + let graph_opaque = match item.declaration.as_ref() { + Stmt::Type { name, .. } => self + .graph + .declarations + .get(&symbol_key(&nested, name)) + .is_some_and(|declaration| declaration.opaque), + _ => false, + }; + self.flatten_statement(&item.declaration, &nested, item.opaque || graph_opaque); + } + } + + fn validate_state_initializers( + &mut self, + body: &[ModuleItem], + context: &Context, + module: &[String], + ) { + let nested = Context { + contribution: context.contribution, + source: context.source, + namespace: context.namespace.clone(), + module: module.to_vec(), + }; + for item in body { + if let Stmt::Let { + name, + mutable: true, + value, + position, + .. + } = item.declaration.as_ref() + { + let mut value = value.clone(); + self.rewrite_expr(&mut value, &nested, &mut Locals::default()); + if !is_pure(&value) { + self.error( + context.source, + *position, + format!( + "state initializer `{name}` must be pure and cannot depend on another state cell" + ), + ); + } + } + } + } + + fn flatten_let(&mut self, statement: &Stmt, name: &str, context: &Context) { + let key = symbol_key(context, name); + if self.constant_cache.contains_key(&key) { + return; + } + if self.runtime_constants.contains(&key) { + let mut rewritten = statement.clone(); + self.rewrite_entry_statement(&mut rewritten, context); + self.entry_prologue.push(rewritten); + return; + } + if matches!(statement, Stmt::Let { mutable: true, .. }) + && context.source == self.entry_source + && context.module.is_empty() + { + let mut rewritten = statement.clone(); + self.rewrite_entry_statement(&mut rewritten, context); + self.entry_prologue.push(rewritten); + } + } + + fn rewrite_entry_statement(&mut self, statement: &mut Stmt, context: &Context) { + let mut locals = std::mem::take(&mut self.entry_locals); + self.rewrite_local_statement(statement, context, &mut locals); + self.entry_locals = locals; + } + + pub fn link_name(&mut self, key: &SymbolKey, entry_main: bool) -> String { + let name = if entry_main { + "main".to_string() + } else if self + .graph + .declarations + .get(key) + .is_some_and(|declaration| declaration.kind == DeclKind::Extern) + { + key.path.last().cloned().unwrap_or_else(|| key.mangled()) + } else { + key.mangled() + }; + let _ = self.source_names.insert(name.clone(), key.source_name()); + name + } + + pub fn error(&mut self, source: usize, position: Option, message: impl Into) { + self.errors + .push(source_error(self.sources, source, position, message)); + } +} + +fn collect_aliases( + contributions: &[Contribution], + graph: &ProjectGraph, +) -> BTreeMap { + let mut aliases = BTreeMap::new(); + for (index, contribution) in contributions.iter().enumerate() { + collect_alias_statements( + &contribution.statements, + contribution.namespace.label(), + &[], + contribution.source, + index, + graph, + &mut aliases, + ); + } + aliases +} + +pub(crate) fn symbol_key(context: &Context, name: &str) -> SymbolKey { + let mut path = context.module.clone(); + path.push(name.to_string()); + SymbolKey::new(context.namespace.clone(), path) +} + +fn collect_alias_statements( + statements: &[Stmt], + namespace: &str, + module: &[String], + source: usize, + contribution: usize, + graph: &ProjectGraph, + aliases: &mut BTreeMap, +) { + for statement in statements { + match statement { + Stmt::Type { + name, + type_params, + alias: Some(value), + .. + } => { + let mut path = module.to_vec(); + path.push(name.clone()); + let key = SymbolKey::new(namespace, path); + let opaque = graph + .declarations + .get(&key) + .is_some_and(|declaration| declaration.opaque); + let _ = aliases.insert( + key, + AliasInfo { + type_params: type_params + .iter() + .map(|parameter| parameter.name.clone()) + .collect(), + value: value.clone(), + opaque, + owner: module.to_vec(), + source, + contribution, + }, + ); + } + Stmt::Module { path, body, .. } => { + let mut nested = module.to_vec(); + nested.extend_from_slice(&path.segments); + let declarations = body + .iter() + .map(|item| item.declaration.as_ref().clone()) + .collect::>(); + collect_alias_statements( + &declarations, + namespace, + &nested, + source, + contribution, + graph, + aliases, + ); + } + _ => {} + } + } +} + +fn inject_prologue(body: &mut Expr, prologue: &[Stmt]) { + if prologue.is_empty() { + return; + } + if let Expr::Block { statements, .. } = body { + let mut combined = prologue.to_vec(); + combined.append(statements); + *statements = combined; + } else { + let original = std::mem::replace(body, Expr::Bool(false)); + *body = Expr::Block { + statements: prologue.to_vec(), + value: Some(Box::new(original)), + }; + } +} diff --git a/crates/osprey-project/src/rewrite.rs b/crates/osprey-project/src/rewrite.rs new file mode 100644 index 00000000..32fec63a --- /dev/null +++ b/crates/osprey-project/src/rewrite.rs @@ -0,0 +1,476 @@ +//! Lexically aware value, declaration, and constructor rewriting. + +use crate::model::SymbolKey; +use crate::purity::is_pure; +use crate::resolve::{symbol_key, Context, Locals, Resolver}; +use osprey_ast::{Expr, MatchArm, Pattern, Stmt, TypeParam}; + +fn locals_with_type_parameters(type_params: &[TypeParam]) -> Locals { + Locals { + types: type_params + .iter() + .map(|parameter| parameter.name.clone()) + .collect(), + ..Locals::default() + } +} + +impl Resolver<'_> { + pub fn constant_value(&mut self, key: &SymbolKey) -> Option { + if let Some(value) = self.constant_cache.get(key) { + return Some(value.clone()); + } + if self.invalid_constants.contains(key) { + return None; + } + if !self.constant_active.insert(key.clone()) { + let source = self + .graph + .constants + .get(key) + .map_or(0, |constant| constant.source); + let position = self + .graph + .constants + .get(key) + .and_then(|constant| constant.position); + self.error( + source, + position, + format!( + "constant initializer cycle involving `{}`", + key.source_name() + ), + ); + let _ = self.invalid_constants.insert(key.clone()); + return None; + } + let Some(constant) = self.graph.constants.get(key).cloned() else { + let _ = self.constant_active.remove(key); + return None; + }; + let context = Context { + contribution: constant.contribution, + source: constant.source, + namespace: key.namespace.clone(), + module: constant.module, + }; + let mut value = constant.value; + self.rewrite_expr(&mut value, &context, &mut Locals::default()); + let _ = self.constant_active.remove(key); + if is_pure(&value) && !self.invalid_constants.contains(key) { + let _ = self.constant_cache.insert(key.clone(), value.clone()); + Some(value) + } else { + None + } + } + + #[expect( + clippy::too_many_lines, + reason = "declaration rewriting is an exhaustive canonical AST match" + )] + pub fn rewrite_declaration( + &mut self, + statement: &mut Stmt, + context: &Context, + opaque: bool, + entry_main: bool, + ) { + let original_name = crate::annotation::declaration_name(statement).map(str::to_string); + let annotation = original_name + .as_deref() + .and_then(|name| self.graph.annotations.get(&symbol_key(context, name))) + .cloned(); + if let Some(annotation) = &annotation { + self.apply_annotation(statement, annotation, context); + } + match statement { + Stmt::Function { + name, + type_params, + parameters, + return_type, + effects, + body, + .. + } => { + let key = symbol_key(context, name); + let mut locals = locals_with_type_parameters(type_params); + locals + .values + .extend(parameters.iter().map(|parameter| parameter.name.clone())); + if entry_main { + locals + .values + .extend(self.entry_runtime_names.iter().cloned()); + } + for parameter in parameters { + if let Some(ty) = &mut parameter.ty { + self.rewrite_type(ty, context, &mut locals); + } + } + if let Some(ty) = return_type { + self.rewrite_type(ty, context, &mut locals); + } + self.rewrite_effect_refs(effects, context, &mut locals); + self.rewrite_expr(body, context, &mut locals); + *name = self.link_name(&key, entry_main); + } + Stmt::Extern { + name, + parameters, + return_type, + .. + } => { + let key = symbol_key(context, name); + let mut locals = Locals::default(); + for parameter in parameters { + self.rewrite_type(&mut parameter.ty, context, &mut locals); + } + if let Some(ty) = return_type { + self.rewrite_type(ty, context, &mut locals); + } + *name = self.link_name(&key, false); + } + Stmt::Type { + name, + type_params, + variants, + alias, + validation_func, + .. + } => { + let source_name = name.clone(); + let key = symbol_key(context, &source_name); + let type_link = self.link_name(&key, false); + let mut locals = locals_with_type_parameters(type_params); + if let Some(representation) = alias { + self.rewrite_type(representation, context, &mut locals); + if opaque { + *alias = None; + } + } + for variant in variants { + let variant_name = variant.name.clone(); + if variant_name == source_name { + variant.name.clone_from(&type_link); + } else { + let constructor = symbol_key(context, &variant_name); + variant.name = self.link_name(&constructor, false); + } + let saved = locals.values.clone(); + locals + .values + .extend(variant.fields.iter().map(|field| field.name.clone())); + for field in &mut variant.fields { + field.ty = self.rewrite_type_text(&field.ty, context, &mut locals); + if let Some(constraint) = &mut field.constraint { + self.rewrite_expr(constraint, context, &mut locals); + } + } + locals.values = saved; + } + if let Some(validation) = validation_func { + self.rewrite_value_name(validation, context, false); + } + *name = type_link; + } + Stmt::Effect { + name, + type_params, + operations, + .. + } => { + let key = symbol_key(context, name); + let mut locals = locals_with_type_parameters(type_params); + for operation in operations { + operation.ty = self.rewrite_type_text(&operation.ty, context, &mut locals); + for parameter in &mut operation.parameters { + if let Some(ty) = &mut parameter.ty { + self.rewrite_type(ty, context, &mut locals); + } + } + operation.return_type = + self.rewrite_type_text(&operation.return_type, context, &mut locals); + } + *name = self.link_name(&key, false); + } + _ => {} + } + } + + pub fn rewrite_local_statement( + &mut self, + statement: &mut Stmt, + context: &Context, + locals: &mut Locals, + ) { + match statement { + Stmt::Let { + name, ty, value, .. + } => { + if let Some(ty) = ty { + self.rewrite_type(ty, context, locals); + } + self.rewrite_expr(value, context, locals); + let _ = locals.values.insert(name.clone()); + } + Stmt::Assignment { + name, + value, + position, + } => { + if !locals.values.contains(name) + && self.resolve_bare(name, context, *position).is_some() + { + self.error( + context.source, + *position, + format!("cannot assign to module declaration `{name}`"), + ); + } + self.rewrite_expr(value, context, locals); + } + Stmt::Expr { value, .. } => self.rewrite_expr(value, context, locals), + _ => {} + } + } + + #[expect( + clippy::too_many_lines, + reason = "expression rewriting is an exhaustive canonical AST walk" + )] + pub fn rewrite_expr(&mut self, expression: &mut Expr, context: &Context, locals: &mut Locals) { + if let Expr::Identifier(name) = expression { + let name = name.clone(); + let mut rewritten = Expr::Identifier(name.clone()); + self.rewrite_identifier(&mut rewritten, &name, context, locals); + *expression = rewritten; + return; + } + match expression { + Expr::Path(path) => { + let segments = path.segments.clone(); + self.rewrite_path_expression(expression, &segments, context, locals); + } + Expr::InterpolatedStr(parts) => { + for part in parts { + if let osprey_ast::InterpolatedPart::Expr(value) = part { + self.rewrite_expr(value, context, locals); + } + } + } + Expr::List(items) => self.rewrite_exprs(items, context, locals), + Expr::Map(entries) => { + for entry in entries { + self.rewrite_expr(&mut entry.key, context, locals); + self.rewrite_expr(&mut entry.value, context, locals); + } + } + Expr::Object(fields) | Expr::TypeConstructor { fields, .. } => { + for field in fields { + self.rewrite_expr(&mut field.value, context, locals); + } + if let Expr::TypeConstructor { + name, type_args, .. + } = expression + { + self.rewrite_value_name(name, context, true); + for argument in type_args { + self.rewrite_type(argument, context, locals); + } + } + } + Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { + self.rewrite_expr(left, context, locals); + self.rewrite_expr(right, context, locals); + } + Expr::Unary { operand, .. } + | Expr::Spawn(operand) + | Expr::Await(operand) + | Expr::Recv(operand) => self.rewrite_expr(operand, context, locals), + Expr::Call { + function, + arguments, + named_arguments, + } => { + self.rewrite_expr(function, context, locals); + self.rewrite_exprs(arguments, context, locals); + for argument in named_arguments { + self.rewrite_expr(&mut argument.value, context, locals); + } + } + Expr::MethodCall { + target, + method, + arguments, + named_arguments, + } => { + self.rewrite_expr(target, context, locals); + self.rewrite_value_name(method, context, false); + self.rewrite_exprs(arguments, context, locals); + for argument in named_arguments { + self.rewrite_expr(&mut argument.value, context, locals); + } + } + Expr::FieldAccess { target, .. } => self.rewrite_expr(target, context, locals), + Expr::Index { target, index } => { + self.rewrite_expr(target, context, locals); + self.rewrite_expr(index, context, locals); + } + Expr::Lambda { + parameters, + return_type, + body, + .. + } => { + let saved = locals.clone(); + for parameter in parameters { + if let Some(ty) = &mut parameter.ty { + self.rewrite_type(ty, context, locals); + } + let _ = locals.values.insert(parameter.name.clone()); + } + if let Some(ty) = return_type { + self.rewrite_type(ty, context, locals); + } + self.rewrite_expr(body, context, locals); + *locals = saved; + } + Expr::Match { value, arms } => { + self.rewrite_expr(value, context, locals); + self.rewrite_pattern_arms(arms, context, locals); + } + Expr::Block { statements, value } => { + let saved = locals.clone(); + for statement in statements { + self.rewrite_local_statement(statement, context, locals); + } + if let Some(value) = value { + self.rewrite_expr(value, context, locals); + } + *locals = saved; + } + Expr::Update { record, fields } => { + if !locals.values.contains(record) { + self.rewrite_value_name(record, context, false); + } + for field in fields { + self.rewrite_expr(&mut field.value, context, locals); + } + } + Expr::Yield(value) | Expr::Resume(value) => { + if let Some(value) = value { + self.rewrite_expr(value, context, locals); + } + } + Expr::Send { channel, value } => { + self.rewrite_expr(channel, context, locals); + self.rewrite_expr(value, context, locals); + } + Expr::Select { arms } => self.rewrite_pattern_arms(arms, context, locals), + Expr::Perform { + effect, + arguments, + named_arguments, + .. + } => { + self.rewrite_effect_name(effect, context); + self.rewrite_exprs(arguments, context, locals); + for argument in named_arguments { + self.rewrite_expr(&mut argument.value, context, locals); + } + } + Expr::Handler { + effect, arms, body, .. + } => { + self.rewrite_effect_name(effect, context); + self.rewrite_expr(body, context, locals); + for arm in arms { + let saved = locals.clone(); + locals.values.extend(arm.params.iter().cloned()); + self.rewrite_expr(&mut arm.body, context, locals); + *locals = saved; + } + } + Expr::Identifier(_) + | Expr::Integer(_) + | Expr::Float(_) + | Expr::Str(_) + | Expr::Bool(_) => {} + } + } + + fn rewrite_identifier( + &mut self, + expression: &mut Expr, + name: &str, + context: &Context, + locals: &Locals, + ) { + if locals.values.contains(name) { + return; + } + let Some(key) = self.resolve_bare(name, context, None) else { + return; + }; + self.replace_symbol_expression(expression, &key, context); + } + + fn rewrite_path_expression( + &mut self, + expression: &mut Expr, + segments: &[String], + context: &Context, + _locals: &Locals, + ) { + if let Some(key) = self.resolve_path(segments, context, None) { + self.replace_symbol_expression(expression, &key, context); + } + } + + fn rewrite_pattern_arms( + &mut self, + arms: &mut [MatchArm], + context: &Context, + locals: &mut Locals, + ) { + for arm in arms { + let saved = locals.clone(); + self.rewrite_pattern(&mut arm.pattern, context, locals); + self.rewrite_expr(&mut arm.body, context, locals); + *locals = saved; + } + } + + fn rewrite_pattern(&mut self, pattern: &mut Pattern, context: &Context, locals: &mut Locals) { + match pattern { + Pattern::Wildcard => {} + Pattern::Literal(value) => self.rewrite_expr(value, context, locals), + Pattern::Constructor { + name, + fields, + sub_patterns, + } => { + self.rewrite_value_name(name, context, true); + locals.values.extend(fields.iter().cloned()); + for nested in sub_patterns { + self.rewrite_pattern(nested, context, locals); + } + } + Pattern::TypeAnnotated { name, ty } => { + self.rewrite_type(ty, context, locals); + let _ = locals.values.insert(name.clone()); + } + Pattern::Structural { fields } => locals.values.extend(fields.iter().cloned()), + Pattern::List { elements, rest } => { + for nested in elements { + self.rewrite_pattern(nested, context, locals); + } + locals.values.extend(rest.iter().cloned()); + } + Pattern::Binding(name) => locals.values.extend(std::iter::once(name.clone())), + } + } +} diff --git a/crates/osprey-project/src/signature_collect.rs b/crates/osprey-project/src/signature_collect.rs new file mode 100644 index 00000000..93099529 --- /dev/null +++ b/crates/osprey-project/src/signature_collect.rs @@ -0,0 +1,141 @@ +//! Signature lookup, conformance, export, and opacity finalization. + +use crate::collect::Collector; +use crate::collect_support::{kind_matches, signature_name_kind}; +use crate::model::{ModuleInfo, SymbolKey}; +use crate::ProjectError; +use osprey_ast::{Position, SignatureItem, Visibility}; +use std::collections::BTreeSet; + +impl Collector<'_> { + pub(crate) fn finish_signatures(&mut self) { + let module_keys = self.graph.modules.keys().cloned().collect::>(); + for module_key in module_keys { + let Some(module) = self.graph.modules.get(&module_key).cloned() else { + continue; + }; + let Some(ascription) = &module.signature else { + continue; + }; + let Some(items) = self.find_signature(&module_key, &ascription.path.segments) else { + self.error( + module.source, + module.position, + format!("unknown signature `{}`", ascription.path), + ); + continue; + }; + self.apply_signature(&module_key, &module, &items, ascription.allow_extra); + } + } + + fn find_signature(&self, module: &SymbolKey, path: &[String]) -> Option> { + let direct = SymbolKey::new(module.namespace.clone(), path.to_vec()); + if let Some(items) = self.graph.signatures.get(&direct) { + return Some(items.clone()); + } + let mut relative = module.parent_path().to_vec(); + relative.extend_from_slice(path); + self.graph + .signatures + .get(&SymbolKey::new(module.namespace.clone(), relative)) + .cloned() + } + + fn apply_signature( + &mut self, + module_key: &SymbolKey, + module: &ModuleInfo, + items: &[SignatureItem], + allow_extra: bool, + ) { + let mut exports = BTreeSet::new(); + for item in items { + self.apply_item(module_key, module, item, &mut exports); + } + let extras = module + .explicit_exports + .difference(&exports) + .cloned() + .collect::>(); + for extra in extras { + if allow_extra { + let _ = exports.insert(extra); + } else { + self.error( + module.source, + module.position, + format!("extra export `{extra}` requires `+ extra`"), + ); + } + } + if let Some(info) = self.graph.modules.get_mut(module_key) { + info.exports = exports; + } + } + + fn apply_item( + &mut self, + module_key: &SymbolKey, + module: &ModuleInfo, + item: &SignatureItem, + exports: &mut BTreeSet, + ) { + let (name, expected) = signature_name_kind(item); + let declaration = module_key.child(name); + let Some(info) = self.graph.declarations.get(&declaration).cloned() else { + self.error( + module.source, + module.position, + format!("signature item `{name}` has no implementation"), + ); + return; + }; + if !kind_matches(info.kind, expected) { + self.error( + module.source, + module.position, + format!("signature item `{name}` has the wrong declaration kind"), + ); + return; + } + if info.state_owner { + self.error( + module.source, + module.position, + format!("state cell `{name}` cannot be exported by a signature"), + ); + return; + } + if let Some(implementation) = self.graph.implementations.get(&declaration) { + for message in crate::contract::errors(implementation, item) { + self.error(module.source, module.position, message); + } + } + if let Some(info) = self.graph.declarations.get_mut(&declaration) { + info.visibility = Visibility::Exported; + info.opaque |= crate::contract::hides_type(item); + } + let _ = exports.insert(name.to_string()); + let _ = self.graph.annotations.insert(declaration, item.clone()); + } + + pub(crate) fn error( + &mut self, + source: usize, + position: Option, + message: impl Into, + ) { + if let Some(metadata) = self.sources.get(source) { + self.errors + .push(ProjectError::source(metadata, position, message)); + } else { + self.errors.push(ProjectError { + message: message.into(), + path: None, + line: None, + column: None, + }); + } + } +} diff --git a/crates/osprey-project/src/span.rs b/crates/osprey-project/src/span.rs new file mode 100644 index 00000000..3a8ee76e --- /dev/null +++ b/crates/osprey-project/src/span.rs @@ -0,0 +1,368 @@ +//! Position rebasing for collision-free multi-file inference metadata. + +use osprey_ast::{ + EffectOperation, EffectRef, Expr, FieldAssignment, InterpolatedPart, MatchArm, NamedArgument, + Parameter, Pattern, Position, Program, SignatureItem, SignatureType, Stmt, TypeExpr, +}; + +pub(crate) fn offset_program(program: &mut Program, line_offset: u32) { + for statement in &mut program.statements { + offset_stmt(statement, line_offset); + } +} + +fn offset_stmt(statement: &mut Stmt, offset: u32) { + match statement { + Stmt::Import(import) => shift(&mut import.position, offset), + Stmt::Namespace { body, position, .. } => { + shift(position, offset); + offset_stmts(body, offset); + } + Stmt::Let { + ty, + value, + position, + .. + } => { + shift(position, offset); + optional_type(ty, offset); + offset_expr(value, offset); + } + Stmt::Assignment { + value, position, .. + } + | Stmt::Expr { + value, position, .. + } => { + shift(position, offset); + offset_expr(value, offset); + } + Stmt::Function { + parameters, + return_type, + effects, + body, + position, + .. + } => { + shift(position, offset); + offset_params(parameters, offset); + optional_type(return_type, offset); + offset_effect_refs(effects, offset); + offset_expr(body, offset); + } + Stmt::Extern { + parameters, + return_type, + position, + .. + } => { + shift(position, offset); + for parameter in parameters { + offset_type(&mut parameter.ty, offset); + } + optional_type(return_type, offset); + } + Stmt::Type { + variants, + alias, + position, + .. + } => { + shift(position, offset); + optional_type(alias, offset); + for variant in variants { + for field in &mut variant.fields { + if let Some(constraint) = &mut field.constraint { + offset_expr(constraint, offset); + } + } + } + } + Stmt::Effect { + operations, + position, + .. + } => { + shift(position, offset); + offset_operations(operations, offset); + } + Stmt::Module { body, position, .. } => { + shift(position, offset); + for item in body { + offset_stmt(&mut item.declaration, offset); + } + } + Stmt::Signature { + items, position, .. + } => { + shift(position, offset); + for item in items { + offset_signature_item(item, offset); + } + } + } +} + +fn offset_stmts(statements: &mut [Stmt], offset: u32) { + for statement in statements { + offset_stmt(statement, offset); + } +} + +fn offset_signature_item(item: &mut SignatureItem, offset: u32) { + match item { + SignatureItem::Value { ty, position, .. } => { + shift(position, offset); + offset_type(ty, offset); + } + SignatureItem::Function { + parameters, + return_type, + effects, + position, + .. + } => { + shift(position, offset); + for parameter in parameters { + offset_type(parameter, offset); + } + offset_type(return_type, offset); + offset_effect_refs(effects, offset); + } + SignatureItem::Type { + definition, + position, + .. + } => { + shift(position, offset); + if let SignatureType::Manifest(ty) = definition { + offset_type(ty, offset); + } + } + SignatureItem::Effect { + operations, + position, + .. + } => { + shift(position, offset); + offset_operations(operations, offset); + } + SignatureItem::Module { position, .. } => shift(position, offset), + } +} + +fn offset_operations(operations: &mut [EffectOperation], offset: u32) { + for operation in operations { + offset_params(&mut operation.parameters, offset); + } +} + +fn offset_params(parameters: &mut [Parameter], offset: u32) { + for parameter in parameters { + optional_type(&mut parameter.ty, offset); + } +} + +fn offset_effect_refs(effects: &mut [EffectRef], offset: u32) { + for effect in effects { + shift(&mut effect.position, offset); + for argument in &mut effect.type_args { + offset_type(argument, offset); + } + } +} + +fn optional_type(ty: &mut Option, offset: u32) { + if let Some(ty) = ty { + offset_type(ty, offset); + } +} + +fn offset_type(ty: &mut TypeExpr, offset: u32) { + shift(&mut ty.position, offset); + for parameter in &mut ty.generic_params { + offset_type(parameter, offset); + } + if let Some(element) = &mut ty.array_element { + offset_type(element, offset); + } + for parameter in &mut ty.parameter_types { + offset_type(parameter, offset); + } + if let Some(result) = &mut ty.return_type { + offset_type(result, offset); + } +} + +#[expect( + clippy::too_many_lines, + reason = "position rebasing exhaustively visits every canonical expression form" +)] +fn offset_expr(expr: &mut Expr, offset: u32) { + match expr { + Expr::InterpolatedStr(parts) => { + for part in parts { + if let InterpolatedPart::Expr(value) = part { + offset_expr(value, offset); + } + } + } + Expr::List(items) => offset_exprs(items, offset), + Expr::Map(entries) => { + for entry in entries { + offset_expr(&mut entry.key, offset); + offset_expr(&mut entry.value, offset); + } + } + Expr::Object(fields) | Expr::Update { fields, .. } => offset_fields(fields, offset), + Expr::TypeConstructor { + type_args, fields, .. + } => { + for argument in type_args { + offset_type(argument, offset); + } + offset_fields(fields, offset); + } + Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { + offset_expr(left, offset); + offset_expr(right, offset); + } + Expr::Unary { operand, .. } + | Expr::Spawn(operand) + | Expr::Await(operand) + | Expr::Recv(operand) => offset_expr(operand, offset), + Expr::Call { + function, + arguments, + named_arguments, + } => { + offset_expr(function, offset); + offset_exprs(arguments, offset); + offset_named(named_arguments, offset); + } + Expr::FieldAccess { target, .. } => offset_expr(target, offset), + Expr::MethodCall { + target, + arguments, + named_arguments, + .. + } => { + offset_expr(target, offset); + offset_exprs(arguments, offset); + offset_named(named_arguments, offset); + } + Expr::Index { target, index } => { + offset_expr(target, offset); + offset_expr(index, offset); + } + Expr::Lambda { + parameters, + return_type, + body, + position, + } => { + shift(position, offset); + offset_params(parameters, offset); + optional_type(return_type, offset); + offset_expr(body, offset); + } + Expr::Match { value, arms } => { + offset_expr(value, offset); + offset_arms(arms, offset); + } + Expr::Block { statements, value } => { + offset_stmts(statements, offset); + if let Some(value) = value { + offset_expr(value, offset); + } + } + Expr::Yield(value) | Expr::Resume(value) => { + if let Some(value) = value { + offset_expr(value, offset); + } + } + Expr::Send { channel, value } => { + offset_expr(channel, offset); + offset_expr(value, offset); + } + Expr::Select { arms } => offset_arms(arms, offset), + Expr::Perform { + arguments, + named_arguments, + position, + .. + } => { + shift(position, offset); + offset_exprs(arguments, offset); + offset_named(named_arguments, offset); + } + Expr::Handler { + arms, + body, + position, + .. + } => { + shift(position, offset); + for arm in arms { + offset_expr(&mut arm.body, offset); + } + offset_expr(body, offset); + } + Expr::Integer(_) + | Expr::Float(_) + | Expr::Str(_) + | Expr::Bool(_) + | Expr::Identifier(_) + | Expr::Path(_) => {} + } +} + +fn offset_exprs(expressions: &mut [Expr], offset: u32) { + for expression in expressions { + offset_expr(expression, offset); + } +} + +fn offset_fields(fields: &mut [FieldAssignment], offset: u32) { + for field in fields { + offset_expr(&mut field.value, offset); + } +} + +fn offset_named(arguments: &mut [NamedArgument], offset: u32) { + for argument in arguments { + offset_expr(&mut argument.value, offset); + } +} + +fn offset_arms(arms: &mut [MatchArm], offset: u32) { + for arm in arms { + offset_pattern(&mut arm.pattern, offset); + offset_expr(&mut arm.body, offset); + } +} + +fn offset_pattern(pattern: &mut Pattern, offset: u32) { + match pattern { + Pattern::Literal(value) => offset_expr(value, offset), + Pattern::Constructor { sub_patterns, .. } => { + for sub_pattern in sub_patterns { + offset_pattern(sub_pattern, offset); + } + } + Pattern::TypeAnnotated { ty, .. } => offset_type(ty, offset), + Pattern::List { elements, .. } => { + for element in elements { + offset_pattern(element, offset); + } + } + Pattern::Wildcard | Pattern::Structural { .. } | Pattern::Binding(_) => {} + } +} + +fn shift(position: &mut Option, offset: u32) { + if let Some(position) = position { + position.line = position.line.saturating_add(offset); + } +} diff --git a/crates/osprey-project/src/state.rs b/crates/osprey-project/src/state.rs new file mode 100644 index 00000000..cd43a4db --- /dev/null +++ b/crates/osprey-project/src/state.rs @@ -0,0 +1,432 @@ +//! State-module ownership checks and per-installer cell materialization. +//! Implements [MODULES-STATE], [MODULES-STATE-MODULE], and +//! [MODULES-STATE-SOURCE-OF-TRUTH]. + +use crate::imports::ImportScope; +use crate::model::{ProjectGraph, SymbolKey}; +use crate::state_support::{ + inject, owned_cell_names, owned_effect_names, pattern_names, push_error, +}; +use crate::{ProjectError, SourceMetadata}; +use osprey_ast::{Expr, HandlerArm, MatchArm, ModuleItem, ModuleKind, Position, Stmt}; +use std::collections::BTreeSet; + +pub(crate) fn prepare( + module_key: &SymbolKey, + body: &mut Vec, + graph: &ProjectGraph, + scope: Option<&ImportScope>, + sources: &[SourceMetadata], + errors: &mut Vec, +) { + let Some(module) = graph.modules.get(module_key) else { + return; + }; + if module.kind != ModuleKind::State { + return; + } + let cells: Vec = body + .iter() + .filter_map(|item| match item.declaration.as_ref() { + statement @ Stmt::Let { mutable: true, .. } => Some(statement.clone()), + _ => None, + }) + .collect(); + if cells.is_empty() { + return; + } + let cell_names = module.state_cells.clone(); + let aliases = scope.map_or_else(Vec::new, |scope| scope.aliases_for(module_key)); + let cell_paths = owned_cell_names(module_key, &cell_names, &aliases); + let owned_effects = owned_effect_names(module_key, &module.effects, &aliases); + if module + .effects + .intersection(&module.exports) + .next() + .is_none() + { + push_error( + errors, + sources, + module.source, + module.position, + "a state module with cells needs an exported owned effect", + ); + } + let mut installers = BTreeSet::new(); + for item in body.iter() { + inspect_item( + item, + &cell_names, + &cell_paths, + &owned_effects, + module.source, + sources, + errors, + &mut installers, + false, + ); + } + let exported_installers = installers.intersection(&module.exports).next().is_some(); + if !exported_installers { + push_error( + errors, + sources, + module.source, + module.position, + "a state module with cells needs an exported handler installer", + ); + } + body.retain(|item| !matches!(item.declaration.as_ref(), Stmt::Let { mutable: true, .. })); + for item in body { + if let Stmt::Function { name, body, .. } = item.declaration.as_mut() { + if installers.contains(name) { + inject(body, &cells); + } + } + } +} + +#[expect( + clippy::too_many_arguments, + reason = "state inspection carries explicit owner and diagnostic context" +)] +fn inspect_item( + item: &ModuleItem, + cells: &BTreeSet, + cell_paths: &BTreeSet, + effects: &BTreeSet, + source: usize, + sources: &[SourceMetadata], + errors: &mut Vec, + installers: &mut BTreeSet, + nested_boundary: bool, +) { + match item.declaration.as_ref() { + Stmt::Function { + name, + parameters, + body, + position, + .. + } => { + let mut inspector = Inspector::new(cells, cell_paths, effects, source, sources, errors); + inspector.allow_owner_handlers = !nested_boundary; + inspector + .locals + .extend(parameters.iter().map(|parameter| parameter.name.clone())); + inspector.expr(body, false, *position); + if inspector.found_owner_handler && !nested_boundary { + let _ = installers.insert(name.clone()); + } + } + Stmt::Let { + mutable: false, + value, + position, + .. + } + | Stmt::Expr { value, position } => { + Inspector::new(cells, cell_paths, effects, source, sources, errors) + .expr(value, false, *position); + } + Stmt::Type { + variants, position, .. + } => { + let mut inspector = Inspector::new(cells, cell_paths, effects, source, sources, errors); + for field in variants.iter().flat_map(|variant| &variant.fields) { + if let Some(constraint) = &field.constraint { + inspector.expr(constraint, false, *position); + } + } + } + Stmt::Module { body, .. } => { + for nested in body { + inspect_item( + nested, cells, cell_paths, effects, source, sources, errors, installers, true, + ); + } + } + _ => {} + } +} + +struct Inspector<'a> { + cells: &'a BTreeSet, + cell_paths: &'a BTreeSet, + effects: &'a BTreeSet, + source: usize, + sources: &'a [SourceMetadata], + errors: &'a mut Vec, + locals: BTreeSet, + found_owner_handler: bool, + allow_owner_handlers: bool, +} + +impl<'a> Inspector<'a> { + fn new( + cells: &'a BTreeSet, + cell_paths: &'a BTreeSet, + effects: &'a BTreeSet, + source: usize, + sources: &'a [SourceMetadata], + errors: &'a mut Vec, + ) -> Self { + Self { + cells, + cell_paths, + effects, + source, + sources, + errors, + locals: BTreeSet::new(), + found_owner_handler: false, + allow_owner_handlers: true, + } + } + + #[expect( + clippy::too_many_lines, + reason = "state lifetime validation exhaustively walks every expression form" + )] + fn expr(&mut self, expression: &Expr, in_owner_arm: bool, position: Option) { + match expression { + Expr::Identifier(name) if self.is_cell(name) => { + self.access(name, in_owner_arm, position); + } + Expr::Path(path) => { + let name = path.segments.join("::"); + if self.cell_paths.contains(&name) { + self.access(&name, in_owner_arm, position); + } + } + Expr::InterpolatedStr(parts) => { + for part in parts { + if let osprey_ast::InterpolatedPart::Expr(value) = part { + self.expr(value, in_owner_arm, position); + } + } + } + Expr::List(items) => self.exprs(items, in_owner_arm, position), + Expr::Map(entries) => { + for entry in entries { + self.expr(&entry.key, in_owner_arm, position); + self.expr(&entry.value, in_owner_arm, position); + } + } + Expr::Object(fields) | Expr::TypeConstructor { fields, .. } => { + self.fields(fields, in_owner_arm, position); + } + Expr::Update { record, fields } => { + if self.is_cell(record) { + self.access(record, in_owner_arm, position); + } + self.fields(fields, in_owner_arm, position); + } + Expr::Binary { left, right, .. } | Expr::Pipe { left, right } => { + self.expr(left, in_owner_arm, position); + self.expr(right, in_owner_arm, position); + } + Expr::Unary { operand, .. } | Expr::Await(operand) | Expr::Recv(operand) => { + self.expr(operand, in_owner_arm, position); + } + Expr::Spawn(operand) => self.escaping(operand, position), + Expr::Call { + function, + arguments, + named_arguments, + } => { + self.expr(function, in_owner_arm, position); + self.exprs(arguments, in_owner_arm, position); + self.named(named_arguments, in_owner_arm, position); + } + Expr::MethodCall { + target, + arguments, + named_arguments, + .. + } => { + self.expr(target, in_owner_arm, position); + self.exprs(arguments, in_owner_arm, position); + self.named(named_arguments, in_owner_arm, position); + } + Expr::FieldAccess { target, .. } => self.expr(target, in_owner_arm, position), + Expr::Index { target, index } => { + self.expr(target, in_owner_arm, position); + self.expr(index, in_owner_arm, position); + } + Expr::Lambda { + parameters, + body, + position: lambda_position, + .. + } => { + let saved = self.locals.clone(); + self.locals + .extend(parameters.iter().map(|parameter| parameter.name.clone())); + self.escaping(body, *lambda_position); + self.locals = saved; + } + Expr::Match { value, arms } => { + self.expr(value, in_owner_arm, position); + for arm in arms { + self.match_arm(arm, in_owner_arm, position); + } + } + Expr::Block { statements, value } => { + self.block(statements, value.as_deref(), in_owner_arm); + } + Expr::Yield(value) | Expr::Resume(value) => { + if let Some(value) = value { + self.expr(value, in_owner_arm, position); + } + } + Expr::Send { channel, value } => { + self.expr(channel, in_owner_arm, position); + self.expr(value, in_owner_arm, position); + } + Expr::Select { arms } => { + for arm in arms { + self.match_arm(arm, in_owner_arm, position); + } + } + Expr::Perform { + arguments, + named_arguments, + position: perform_position, + .. + } => { + self.exprs(arguments, in_owner_arm, *perform_position); + self.named(named_arguments, in_owner_arm, *perform_position); + } + Expr::Handler { + effect, + arms, + body, + position: handler_position, + } => self.handler(effect, arms, body, *handler_position), + Expr::Integer(_) + | Expr::Float(_) + | Expr::Str(_) + | Expr::Bool(_) + | Expr::Identifier(_) => {} + } + } + + fn block(&mut self, statements: &[Stmt], value: Option<&Expr>, in_owner_arm: bool) { + let saved = self.locals.clone(); + for statement in statements { + match statement { + Stmt::Let { + name, + value, + position, + .. + } => { + self.expr(value, in_owner_arm, *position); + let _ = self.locals.insert(name.clone()); + } + Stmt::Assignment { + name, + value, + position, + } => { + if self.is_cell(name) { + self.access(name, in_owner_arm, *position); + } + self.expr(value, in_owner_arm, *position); + } + Stmt::Expr { value, position } => self.expr(value, in_owner_arm, *position), + _ => {} + } + } + if let Some(value) = value { + self.expr(value, in_owner_arm, None); + } + self.locals = saved; + } + + fn handler( + &mut self, + effect: &str, + arms: &[HandlerArm], + body: &Expr, + position: Option, + ) { + self.expr(body, false, position); + let owned = self.allow_owner_handlers && self.effects.contains(effect); + self.found_owner_handler |= owned; + for arm in arms { + self.scoped(arm.params.clone(), |this| { + this.expr(&arm.body, owned, position); + }); + } + } + + fn match_arm(&mut self, arm: &MatchArm, in_owner_arm: bool, position: Option) { + let mut names = BTreeSet::new(); + pattern_names(&arm.pattern, &mut names); + self.scoped(names, |this| this.expr(&arm.body, in_owner_arm, position)); + } + + fn scoped(&mut self, names: I, action: impl FnOnce(&mut Self)) + where + I: IntoIterator, + { + let saved = self.locals.clone(); + self.locals.extend(names); + action(self); + self.locals = saved; + } + + fn escaping(&mut self, expression: &Expr, position: Option) { + let previous = self.allow_owner_handlers; + self.allow_owner_handlers = false; + self.expr(expression, false, position); + self.allow_owner_handlers = previous; + } + + fn exprs(&mut self, values: &[Expr], inside: bool, position: Option) { + for value in values { + self.expr(value, inside, position); + } + } + + fn fields( + &mut self, + fields: &[osprey_ast::FieldAssignment], + inside: bool, + position: Option, + ) { + for field in fields { + self.expr(&field.value, inside, position); + } + } + + fn named( + &mut self, + values: &[osprey_ast::NamedArgument], + inside: bool, + position: Option, + ) { + for value in values { + self.expr(&value.value, inside, position); + } + } + + fn is_cell(&self, name: &str) -> bool { + self.cells.contains(name) && !self.locals.contains(name) + } + + fn access(&mut self, name: &str, allowed: bool, position: Option) { + if !allowed { + push_error( + self.errors, + self.sources, + self.source, + position, + format!("state cell `{name}` is only accessible inside its owning handler arms"), + ); + } + } +} diff --git a/crates/osprey-project/src/state_support.rs b/crates/osprey-project/src/state_support.rs new file mode 100644 index 00000000..228051a6 --- /dev/null +++ b/crates/osprey-project/src/state_support.rs @@ -0,0 +1,105 @@ +//! State validation path identities, diagnostics, patterns, and cell injection. + +use crate::model::SymbolKey; +use crate::{ProjectError, SourceMetadata}; +use osprey_ast::{Expr, Pattern, Position, Stmt}; +use std::collections::BTreeSet; + +pub(crate) fn pattern_names(pattern: &Pattern, names: &mut BTreeSet) { + match pattern { + Pattern::Constructor { + fields, + sub_patterns, + .. + } => { + names.extend(fields.iter().cloned()); + for nested in sub_patterns { + pattern_names(nested, names); + } + } + Pattern::TypeAnnotated { name, .. } | Pattern::Binding(name) => { + let _ = names.insert(name.clone()); + } + Pattern::Structural { fields } => names.extend(fields.iter().cloned()), + Pattern::List { elements, rest } => { + for nested in elements { + pattern_names(nested, names); + } + names.extend(rest.iter().cloned()); + } + Pattern::Wildcard | Pattern::Literal(_) => {} + } +} + +pub(crate) fn inject(body: &mut Expr, cells: &[Stmt]) { + if let Expr::Block { statements, .. } = body { + let mut prefixed = cells.to_vec(); + prefixed.append(statements); + *statements = prefixed; + } else { + let original = std::mem::replace(body, Expr::Bool(false)); + *body = Expr::Block { + statements: cells.to_vec(), + value: Some(Box::new(original)), + }; + } +} + +pub(crate) fn owned_effect_names( + module: &SymbolKey, + effects: &BTreeSet, + aliases: &[String], +) -> BTreeSet { + let relative_prefix = module.path.join("::"); + let absolute_prefix = absolute_prefix(module); + let mut names = BTreeSet::new(); + for effect in effects { + let _ = names.insert(effect.clone()); + let _ = names.insert(format!("{relative_prefix}::{effect}")); + let _ = names.insert(format!("{absolute_prefix}::{effect}")); + names.extend(aliases.iter().map(|alias| format!("{alias}::{effect}"))); + } + names +} + +pub(crate) fn owned_cell_names( + module: &SymbolKey, + cells: &BTreeSet, + aliases: &[String], +) -> BTreeSet { + let relative_prefix = module.path.join("::"); + let absolute_prefix = absolute_prefix(module); + let mut names = BTreeSet::new(); + for cell in cells { + let _ = names.insert(format!("{relative_prefix}::{cell}")); + let _ = names.insert(format!("{absolute_prefix}::{cell}")); + names.extend(aliases.iter().map(|alias| format!("{alias}::{cell}"))); + } + names +} + +fn absolute_prefix(module: &SymbolKey) -> String { + std::iter::once(module.namespace.as_str()) + .chain(module.path.iter().map(String::as_str)) + .collect::>() + .join("::") +} + +pub(crate) fn push_error( + errors: &mut Vec, + sources: &[SourceMetadata], + source: usize, + position: Option, + message: impl Into, +) { + if let Some(metadata) = sources.get(source) { + errors.push(ProjectError::source(metadata, position, message)); + } else { + errors.push(ProjectError { + message: message.into(), + path: None, + line: None, + column: None, + }); + } +} diff --git a/crates/osprey-project/src/symbol_rewrite.rs b/crates/osprey-project/src/symbol_rewrite.rs new file mode 100644 index 00000000..ad6557ac --- /dev/null +++ b/crates/osprey-project/src/symbol_rewrite.rs @@ -0,0 +1,77 @@ +//! Resolved value-symbol materialization and constant substitution. + +use crate::model::{DeclKind, SymbolKey}; +use crate::resolve::{Context, Resolver}; +use osprey_ast::Expr; + +impl Resolver<'_> { + pub(crate) fn replace_symbol_expression( + &mut self, + expression: &mut Expr, + key: &SymbolKey, + context: &Context, + ) { + if let Some(declaration) = self.graph.declarations.get(key) { + if declaration.state_owner { + self.replace_state_cell(expression, key, context, &declaration.owner); + return; + } + } + if self.graph.constants.contains_key(key) { + self.replace_constant(expression, key, context); + return; + } + if self + .graph + .declarations + .get(key) + .is_some_and(|declaration| declaration.kind == DeclKind::Module) + { + self.error( + context.source, + None, + format!("module `{}` is not a value", key.source_name()), + ); + return; + } + *expression = Expr::Identifier(self.link_name(key, false)); + } + + fn replace_state_cell( + &mut self, + expression: &mut Expr, + key: &SymbolKey, + context: &Context, + owner: &[String], + ) { + if key.namespace == context.namespace && context.module.starts_with(owner) { + if let Some(name) = key.path.last() { + *expression = Expr::Identifier(name.clone()); + } + } else { + self.error( + context.source, + None, + format!( + "state cell `{}` cannot escape its owning module", + key.source_name() + ), + ); + } + } + + fn replace_constant(&mut self, expression: &mut Expr, key: &SymbolKey, context: &Context) { + if self.runtime_constants.contains(key) { + self.error( + context.source, + None, + format!( + "entry runtime binding `{}` cannot be captured by a project declaration", + key.source_name() + ), + ); + } else if let Some(value) = self.constant_value(key) { + *expression = value; + } + } +} diff --git a/crates/osprey-project/src/type_rewrite.rs b/crates/osprey-project/src/type_rewrite.rs new file mode 100644 index 00000000..d794c8c7 --- /dev/null +++ b/crates/osprey-project/src/type_rewrite.rs @@ -0,0 +1,245 @@ +//! Type/effect-name rewriting and alias expansion. + +use crate::model::{DeclKind, SymbolKey}; +use crate::resolve::{Context, Locals, Resolver}; +use osprey_ast::{EffectRef, TypeExpr}; +use std::collections::BTreeMap; + +impl Resolver<'_> { + pub fn rewrite_type(&mut self, ty: &mut TypeExpr, context: &Context, locals: &mut Locals) { + for parameter in &mut ty.generic_params { + self.rewrite_type(parameter, context, locals); + } + if let Some(element) = &mut ty.array_element { + self.rewrite_type(element, context, locals); + } + for parameter in &mut ty.parameter_types { + self.rewrite_type(parameter, context, locals); + } + if let Some(result) = &mut ty.return_type { + self.rewrite_type(result, context, locals); + } + if ty.name.is_empty() || locals.types.contains(&ty.name) { + return; + } + let Some(key) = self.resolve_type_key(&ty.name, context, ty.position) else { + return; + }; + let Some(declaration) = self.graph.declarations.get(&key) else { + return; + }; + if declaration.kind != DeclKind::Type { + self.error( + context.source, + ty.position, + format!("`{}` does not name a type", key.source_name()), + ); + return; + } + let alias = self.aliases.get(&key).cloned(); + if let Some(alias) = alias { + let visible_representation = !alias.opaque || context.module.starts_with(&alias.owner); + if visible_representation { + self.expand_alias(ty, &key, &alias, context); + return; + } + } + ty.name = self.link_name(&key, false); + } + + pub fn rewrite_effect_refs( + &mut self, + effects: &mut [EffectRef], + context: &Context, + locals: &mut Locals, + ) { + for effect in effects { + for argument in &mut effect.type_args { + self.rewrite_type(argument, context, locals); + } + let original = effect.name.clone(); + let key = if original.contains("::") { + let path = original.split("::").map(str::to_string).collect::>(); + self.resolve_path(&path, context, effect.position) + } else { + self.resolve_bare(&original, context, effect.position) + }; + if let Some(key) = key { + if self + .graph + .declarations + .get(&key) + .is_some_and(|declaration| declaration.kind == DeclKind::Effect) + { + effect.name = self.link_name(&key, false); + } else { + self.error( + context.source, + effect.position, + format!("`{}` does not name an effect", key.source_name()), + ); + } + } + } + } + + pub fn rewrite_type_text( + &mut self, + text: &str, + context: &Context, + locals: &mut Locals, + ) -> String { + let mut output = String::with_capacity(text.len()); + let mut token = String::new(); + for character in text.chars().chain(std::iter::once('\0')) { + if character.is_alphanumeric() || character == '_' || character == ':' { + token.push(character); + continue; + } + if !token.is_empty() { + output.push_str(&self.rewrite_type_token(&token, context, locals)); + token.clear(); + } + if character != '\0' { + output.push(character); + } + } + output + } + + fn rewrite_type_token( + &mut self, + token: &str, + context: &Context, + locals: &mut Locals, + ) -> String { + if token + .chars() + .next() + .is_none_or(|first| first.is_ascii_digit()) + { + return token.to_string(); + } + let mut ty = TypeExpr::named(token); + self.rewrite_type(&mut ty, context, locals); + render_type(&ty) + } + + fn resolve_type_key( + &mut self, + name: &str, + context: &Context, + position: Option, + ) -> Option { + if name.contains("::") { + let path = name.split("::").map(str::to_string).collect::>(); + self.resolve_path(&path, context, position) + } else { + self.resolve_bare(name, context, position) + } + } + + fn expand_alias( + &mut self, + target: &mut TypeExpr, + key: &SymbolKey, + alias: &crate::resolve::AliasInfo, + use_context: &Context, + ) { + if !self.alias_active.insert(key.clone()) { + self.error( + use_context.source, + target.position, + format!("type alias cycle involving `{}`", key.source_name()), + ); + return; + } + if alias.type_params.len() != target.generic_params.len() { + self.error( + use_context.source, + target.position, + format!( + "type alias `{}` expects {} type argument(s), found {}", + key.source_name(), + alias.type_params.len(), + target.generic_params.len() + ), + ); + let _ = self.alias_active.remove(key); + return; + } + let substitutions = alias + .type_params + .iter() + .cloned() + .zip(target.generic_params.iter().cloned()) + .collect::>(); + let mut representation = alias.value.clone(); + substitute(&mut representation, &substitutions); + let definition_context = Context { + contribution: alias.contribution, + source: alias.source, + namespace: key.namespace.clone(), + module: alias.owner.clone(), + }; + self.rewrite_type( + &mut representation, + &definition_context, + &mut Locals::default(), + ); + let _ = self.alias_active.remove(key); + *target = representation; + } +} + +fn substitute(ty: &mut TypeExpr, substitutions: &BTreeMap) { + if let Some(replacement) = substitutions.get(&ty.name) { + *ty = replacement.clone(); + return; + } + for parameter in &mut ty.generic_params { + substitute(parameter, substitutions); + } + if let Some(element) = &mut ty.array_element { + substitute(element, substitutions); + } + for parameter in &mut ty.parameter_types { + substitute(parameter, substitutions); + } + if let Some(result) = &mut ty.return_type { + substitute(result, substitutions); + } +} + +fn render_type(ty: &TypeExpr) -> String { + if ty.is_array { + return ty.array_element.as_deref().map_or_else( + || "[]".to_string(), + |element| format!("[{}]", render_type(element)), + ); + } + if ty.is_function { + let parameters = ty + .parameter_types + .iter() + .map(render_type) + .collect::>() + .join(", "); + let result = ty + .return_type + .as_deref() + .map_or_else(|| "unit".to_string(), render_type); + return format!("fn({parameters}) -> {result}"); + } + if ty.generic_params.is_empty() { + ty.name.clone() + } else { + let parameters = ty + .generic_params + .iter() + .map(render_type) + .collect::>() + .join(", "); + format!("{}<{parameters}>", ty.name) + } +} diff --git a/crates/osprey-project/tests/modules.rs b/crates/osprey-project/tests/modules.rs new file mode 100644 index 00000000..7358e7e5 --- /dev/null +++ b/crates/osprey-project/tests/modules.rs @@ -0,0 +1,385 @@ +//! Project resolver coverage for module graph, imports, signatures, and entry rules. + +mod support; + +use osprey_ast::{ + Expr, ImportMember, ImportSelection, ModuleItem, ModuleKind, NamespaceName, Parameter, + SignatureAscription, SignatureItem, SignatureType, Stmt, SymbolPath, TypeExpr, Visibility, +}; +use osprey_project::assemble; +use osprey_syntax::Flavor; +use support::{ast, config, contains, error_messages, function, import, item, parsed}; + +#[test] +fn mixed_flavors_resolve_by_namespace_not_file_path() { + // Implements [MODULES-FLAVOR-PROJECTION], [MODULES-PATH-INDEPENDENCE], [MODULES-IMPORT]. + let library = parsed( + "src/completely/unrelated/location.ospml", + Flavor::Ml, + "namespace billing\nmodule Tax\n export addTax cents = cents + 1\n", + ); + let entry = parsed( + "src/main.osp", + Flavor::Default, + "namespace app;\nimport billing::Tax::{addTax}\nfn main() = addTax(1)\n", + ); + let result = assemble(&config("src/main.osp"), &[entry, library]); + assert!(result.is_ok(), "assembly errors: {result:?}"); + if let Ok(project) = result { + assert!(project + .source_name_by_mangled + .values() + .any(|name| name == "billing::Tax::addTax")); + assert!(project.program.statements.iter().all(|statement| { + !matches!( + statement, + Stmt::Module { .. } | Stmt::Namespace { .. } | Stmt::Import(_) + ) + })); + } +} + +#[test] +fn private_member_import_is_rejected() { + // Implements [MODULES-EXPORTS], [MODULES-IMPORT]. + let library = parsed( + "lib.osp", + Flavor::Default, + "namespace billing;\nmodule Tax { fn secret() = 1 }\n", + ); + let entry = parsed( + "main.osp", + Flavor::Default, + "import billing::Tax::{secret}\nfn main() = 0\n", + ); + let messages = error_messages(&config("main.osp"), &[library, entry]); + assert!( + contains(&messages, "private imported member"), + "{messages:?}" + ); +} + +#[test] +fn duplicate_declarations_across_open_namespace_contributions_are_rejected() { + // Implements [MODULES-NAMESPACE], [MODULES-EXPORTS]. + let first = parsed( + "one.osp", + Flavor::Default, + "namespace shared;\nfn clash() = 1\n", + ); + let second = parsed("two.ospml", Flavor::Ml, "namespace shared\nclash () = 2\n"); + let messages = error_messages(&config("one.osp"), &[first, second]); + assert!( + contains(&messages, "duplicate declaration `shared::clash`"), + "{messages:?}" + ); +} + +#[test] +fn ambiguous_member_imports_are_rejected_even_when_unused() { + // Implements [MODULES-IMPORT]. + let modules = parsed( + "modules.osp", + Flavor::Default, + "namespace lib;\nmodule A { export fn run() = 1 }\nmodule B { export fn run() = 2 }\n", + ); + let entry = parsed( + "main.osp", + Flavor::Default, + "import lib::A::{run}\nimport lib::B::{run}\nfn main() = 0\n", + ); + let messages = error_messages(&config("main.osp"), &[modules, entry]); + assert!( + contains(&messages, "ambiguous import binding `run`"), + "{messages:?}" + ); +} + +#[test] +fn module_declaration_precedes_imported_member() { + // Implements [MODULES-RESOLUTION]. + let imported = parsed( + "imported.osp", + Flavor::Default, + "namespace lib;\nmodule Other { export fn value() = 1 }\n", + ); + let entry = parsed( + "main.osp", + Flavor::Default, + "namespace app;\nimport lib::Other::{value}\nfn value() = 2\nfn main() = value()\n", + ); + let result = assemble(&config("main.osp"), &[entry, imported]); + assert!(result.is_ok(), "assembly errors: {result:?}"); +} + +#[test] +fn relative_module_path_precedes_import_alias() { + // Implements [MODULES-RESOLUTION]. + let remote = parsed( + "remote.osp", + Flavor::Default, + "namespace lib;\nmodule Remote { export fn read() = 1 }\n", + ); + let local = Stmt::Module { + path: SymbolPath::single("Local"), + kind: ModuleKind::Plain, + signature: None, + body: vec![item( + Visibility::Exported, + function("read", Expr::Integer(2)), + )], + doc: None, + position: None, + }; + let entry = ast( + "main.osp", + vec![ + import("lib", &["Remote"], Some("Local"), ImportSelection::Whole), + local, + function("main", support::path(&["Local", "read"])), + ], + ); + let result = assemble(&config("main.osp"), &[remote, entry]); + assert!(result.is_ok(), "assembly errors: {result:?}"); +} + +#[test] +fn private_intermediate_module_cannot_be_traversed() { + // Implements [MODULES-EXPORTS]. + let hidden = Stmt::Module { + path: SymbolPath::single("Hidden"), + kind: ModuleKind::Plain, + signature: None, + body: vec![item( + Visibility::Exported, + Stmt::Module { + path: SymbolPath::single("Nested"), + kind: ModuleKind::Plain, + signature: None, + body: vec![item( + Visibility::Exported, + function("read", Expr::Integer(1)), + )], + doc: None, + position: None, + }, + )], + doc: None, + position: None, + }; + let outer = Stmt::Module { + path: SymbolPath::single("Outer"), + kind: ModuleKind::Plain, + signature: None, + body: vec![item(Visibility::Private, hidden)], + doc: None, + position: None, + }; + let entry = ast( + "main.osp", + vec![ + outer, + function( + "main", + support::path(&["app", "Outer", "Hidden", "Nested", "read"]), + ), + ], + ); + let messages = error_messages(&config("main.osp"), &[entry]); + assert!(contains(&messages, "is private"), "{messages:?}"); +} + +#[test] +fn explicit_function_types_must_conform_to_signature() { + // Implements [MODULES-SIGNATURE]. + let contract = Stmt::Signature { + name: "Api".to_string(), + items: vec![SignatureItem::Function { + name: "convert".to_string(), + type_params: Vec::new(), + parameters: vec![TypeExpr::named("int")], + return_type: TypeExpr::named("int"), + effects: Vec::new(), + position: None, + }], + doc: None, + position: None, + }; + let implementation = Stmt::Function { + name: "convert".to_string(), + type_params: Vec::new(), + parameters: vec![Parameter { + name: "value".to_string(), + ty: Some(TypeExpr::named("string")), + }], + return_type: Some(TypeExpr::named("int")), + effects: Vec::new(), + body: Expr::Integer(0), + doc: None, + position: None, + }; + let module = ascribed_module("Api", vec![item(Visibility::Private, implementation)]); + let messages = error_messages( + &config("api.osp"), + &[ast("api.osp", vec![contract, module])], + ); + assert!( + contains(&messages, "parameter types do not match"), + "{messages:?}" + ); +} + +#[test] +fn abstract_alias_is_rejected_instead_of_leaking_representation() { + // Implements [MODULES-OPAQUE-TYPES], [MODULES-SIGNATURE]. + let contract = Stmt::Signature { + name: "Api".to_string(), + items: vec![SignatureItem::Type { + name: "Id".to_string(), + type_params: Vec::new(), + definition: SignatureType::Abstract, + opaque: true, + position: None, + }], + doc: None, + position: None, + }; + let implementation = Stmt::Type { + name: "Id".to_string(), + type_params: Vec::new(), + variants: Vec::new(), + alias: Some(TypeExpr::named("int")), + validation_func: None, + doc: None, + position: None, + }; + let module = ascribed_module("Api", vec![item(Visibility::Private, implementation)]); + let messages = error_messages( + &config("api.osp"), + &[ast("api.osp", vec![contract, module])], + ); + assert!(contains(&messages, "opaque alias"), "{messages:?}"); + assert!(contains(&messages, "unsupported"), "{messages:?}"); +} + +#[test] +fn unknown_and_quoted_unaliased_imports_are_rejected() { + // Implements [MODULES-IMPORT]. + let unknown = import("missing", &["Nope"], None, ImportSelection::Whole); + let quoted = Stmt::Import(osprey_ast::ImportDecl { + target: osprey_ast::ImportTarget { + namespace: NamespaceName::Quoted("vendor/api".to_string()), + path: SymbolPath::default(), + }, + alias: None, + selection: ImportSelection::Whole, + position: None, + }); + let vendor = ast( + "vendor.osp", + vec![Stmt::Namespace { + name: NamespaceName::Quoted("vendor/api".to_string()), + body: vec![function("ok", Expr::Bool(true))], + file_scoped: false, + position: None, + }], + ); + let entry = ast( + "main.osp", + vec![unknown, quoted, function("main", Expr::Integer(0))], + ); + let messages = error_messages(&config("main.osp"), &[vendor, entry]); + assert!(contains(&messages, "unknown import target"), "{messages:?}"); + assert!(contains(&messages, "requires `as Alias`"), "{messages:?}"); +} + +#[test] +fn non_entry_main_and_top_level_execution_are_rejected() { + // Implements [MODULES-PROJECT]. + let entry = ast("entry.osp", vec![function("main", Expr::Integer(0))]); + let other = ast( + "other.osp", + vec![ + function("main", Expr::Integer(1)), + Stmt::Expr { + value: Expr::Integer(2), + position: None, + }, + ], + ); + let messages = error_messages(&config("entry.osp"), &[entry, other]); + assert!( + contains(&messages, "only allowed in the selected entry"), + "{messages:?}" + ); + assert!( + contains(&messages, "only allowed in the entry source"), + "{messages:?}" + ); +} + +#[test] +fn member_alias_resolves_to_exported_declaration() { + let library = parsed( + "lib.osp", + Flavor::Default, + "namespace lib;\nmodule Values { export fn original() = 1 }\n", + ); + let entry = ast( + "main.osp", + vec![ + import( + "lib", + &["Values"], + None, + ImportSelection::Members(vec![ImportMember { + name: "original".to_string(), + alias: Some("renamed".to_string()), + }]), + ), + function("main", Expr::Identifier("renamed".to_string())), + ], + ); + let result = assemble(&config("main.osp"), &[library, entry]); + assert!(result.is_ok(), "assembly errors: {result:?}"); +} + +#[test] +fn constant_initializer_cycles_fail_before_codegen() { + // Implements [MODULES-CYCLES], [MODULES-INIT]. + let binding = |name: &str, target: &str| Stmt::Let { + name: name.to_string(), + mutable: false, + ty: None, + value: Expr::Identifier(target.to_string()), + doc: None, + position: None, + }; + let source = ast( + "main.osp", + vec![ + binding("first", "second"), + binding("second", "first"), + function("main", Expr::Integer(0)), + ], + ); + let messages = error_messages(&config("main.osp"), &[source]); + assert!( + contains(&messages, "constant initializer cycle"), + "{messages:?}" + ); +} + +fn ascribed_module(signature: &str, body: Vec) -> Stmt { + Stmt::Module { + path: SymbolPath::single("Implementation"), + kind: ModuleKind::Plain, + signature: Some(SignatureAscription { + path: SymbolPath::single(signature), + allow_extra: false, + }), + body, + doc: None, + position: None, + } +} diff --git a/crates/osprey-project/tests/opaque_boundary.rs b/crates/osprey-project/tests/opaque_boundary.rs new file mode 100644 index 00000000..43c4baf1 --- /dev/null +++ b/crates/osprey-project/tests/opaque_boundary.rs @@ -0,0 +1,80 @@ +//! Opaque signatures must hide their representation in the flattened public API. + +mod support; + +use osprey_ast::{Stmt, TypeExpr}; +use osprey_project::assemble; +use osprey_syntax::Flavor; +use support::{config, parsed}; + +#[test] +fn abstract_type_does_not_collapse_in_exported_function_contracts() { + // Implements [MODULES-OPAQUE-TYPES], [MODULES-SIGNATURE]. + let source = parsed( + "main.osp", + Flavor::Default, + concat!( + "signature IdApi {\n", + " opaque type Id\n", + " fn keep(value: Id) -> Id\n", + "}\n", + "module Ids : IdApi {\n", + " type Id = int\n", + " fn keep(value) = value\n", + "}\n", + "fn main() = 0\n", + ), + ); + let assembled = assemble(&config("main.osp"), &[source]); + let project = match assembled { + Ok(project) => project, + Err(errors) => { + assert!( + errors.iter().any(|error| { + error.message.contains("opaque") && error.message.contains("unsupported") + }), + "unexpected assembly errors: {errors:?}" + ); + return; + } + }; + let keep = project + .source_name_by_mangled + .iter() + .find_map(|(mangled, source)| (source == "app::Ids::keep").then_some(mangled)); + let contract = project + .program + .statements + .iter() + .find_map(|statement| match statement { + Stmt::Function { + name, + parameters, + return_type, + .. + } if keep.is_some_and(|keep| keep == name) => Some(( + parameters + .first() + .and_then(|parameter| parameter.ty.as_ref()), + return_type.as_ref(), + )), + _ => None, + }); + assert!( + contract.is_some(), + "missing exported keep contract: {:#?}", + project.program + ); + if let Some((Some(parameter), Some(result))) = contract { + assert_nominal(parameter); + assert_nominal(result); + assert_eq!(parameter.name, result.name); + } +} + +fn assert_nominal(ty: &TypeExpr) { + assert_ne!( + ty.name, "int", + "opaque representation leaked into public API" + ); +} diff --git a/crates/osprey-project/tests/state_modules.rs b/crates/osprey-project/tests/state_modules.rs new file mode 100644 index 00000000..c8bafdcb --- /dev/null +++ b/crates/osprey-project/tests/state_modules.rs @@ -0,0 +1,366 @@ +//! State-module ownership and initializer regression coverage. + +mod support; + +use osprey_ast::{Expr, ImportSelection, ModuleKind, Stmt, SymbolPath, Visibility}; +use osprey_project::assemble; +use support::{ + ast, config, contains, error_messages, function, handler, import, item, path, state_module, +}; + +#[test] +fn exact_owned_handler_gets_fresh_installer_cells() { + // Implements [MODULES-STATE-MODULE], [MODULES-INIT]. + let state = state_module( + "Counter", + Expr::Integer(0), + Vec::new(), + handler("CounterFx", path(&["Counter", "count"])), + ); + let result = assemble(&config("state.osp"), &[ast("state.osp", vec![state])]); + assert!(result.is_ok(), "assembly errors: {result:?}"); + if let Ok(project) = result { + assert!(project.program.statements.iter().any(|statement| { + matches!(statement, Stmt::Function { body: Expr::Block { statements, .. }, .. } + if statements.iter().any(|statement| matches!(statement, Stmt::Let { name, mutable: true, .. } if name == "count"))) + })); + } +} + +#[test] +fn ordinary_state_read_and_write_are_rejected() { + // Implements [MODULES-STATE-SOURCE-OF-TRUTH]. + let read = item( + Visibility::Private, + function("readOutside", Expr::Identifier("count".to_string())), + ); + let write = item( + Visibility::Private, + function( + "writeOutside", + Expr::Block { + statements: vec![Stmt::Assignment { + name: "count".to_string(), + value: Expr::Integer(1), + position: None, + }], + value: None, + }, + ), + ); + let state = state_module( + "Counter", + Expr::Integer(0), + vec![read, write], + handler("CounterFx", Expr::Identifier("count".to_string())), + ); + let messages = error_messages(&config("state.osp"), &[ast("state.osp", vec![state])]); + assert!( + contains(&messages, "only accessible inside"), + "{messages:?}" + ); +} + +#[test] +fn lambda_and_spawn_cannot_create_handler_factories() { + // Implements [MODULES-STATE-MODULE]. + let lambda = state_module( + "LambdaCounter", + Expr::Integer(0), + Vec::new(), + Expr::Lambda { + parameters: Vec::new(), + return_type: None, + body: Box::new(handler("CounterFx", Expr::Identifier("count".to_string()))), + position: None, + }, + ); + let lambda_messages = error_messages(&config("lambda.osp"), &[ast("lambda.osp", vec![lambda])]); + assert!( + contains(&lambda_messages, "exported handler installer"), + "{lambda_messages:?}" + ); + assert!( + contains(&lambda_messages, "only accessible inside"), + "{lambda_messages:?}" + ); + + let spawned = state_module( + "SpawnCounter", + Expr::Integer(0), + Vec::new(), + Expr::Spawn(Box::new(handler( + "CounterFx", + Expr::Identifier("count".to_string()), + ))), + ); + let spawn_messages = error_messages(&config("spawn.osp"), &[ast("spawn.osp", vec![spawned])]); + assert!( + contains(&spawn_messages, "exported handler installer"), + "{spawn_messages:?}" + ); + assert!( + contains(&spawn_messages, "only accessible inside"), + "{spawn_messages:?}" + ); +} + +#[test] +fn differently_qualified_same_tail_effect_does_not_authorize_state() { + // Implements [MODULES-STATE-MODULE]. + let state = state_module( + "Counter", + Expr::Integer(0), + Vec::new(), + handler("Other::CounterFx", Expr::Identifier("count".to_string())), + ); + let messages = error_messages(&config("state.osp"), &[ast("state.osp", vec![state])]); + assert!( + contains(&messages, "only accessible inside"), + "{messages:?}" + ); + assert!( + contains(&messages, "exported handler installer"), + "{messages:?}" + ); +} + +#[test] +fn alias_qualified_cell_cannot_bypass_ownership_check() { + // Implements [MODULES-STATE-SOURCE-OF-TRUTH]. + let leaked = item(Visibility::Private, function("leak", path(&["C", "count"]))); + let state = state_module( + "Counter", + Expr::Integer(0), + vec![leaked], + handler("C::CounterFx", path(&["C", "count"])), + ); + let source = ast( + "state.osp", + vec![ + import("app", &["Counter"], Some("C"), ImportSelection::Whole), + state, + ], + ); + let messages = error_messages(&config("state.osp"), &[source]); + assert!( + contains(&messages, "only accessible inside"), + "{messages:?}" + ); +} + +#[test] +fn state_initializer_must_be_pure_and_dependency_free() { + // Implements [MODULES-INIT]. + let effectful = Expr::Call { + function: Box::new(Expr::Identifier("load".to_string())), + arguments: Vec::new(), + named_arguments: Vec::new(), + }; + let state = state_module( + "Counter", + effectful, + Vec::new(), + handler("CounterFx", Expr::Identifier("count".to_string())), + ); + let messages = error_messages(&config("state.osp"), &[ast("state.osp", vec![state])]); + assert!(contains(&messages, "must be pure"), "{messages:?}"); +} + +#[test] +fn wildcard_import_from_state_module_is_always_rejected() { + // Implements [MODULES-IMPORT], [MODULES-STATE-MODULE]. + let state = state_module( + "Counter", + Expr::Integer(0), + Vec::new(), + handler("CounterFx", Expr::Identifier("count".to_string())), + ); + let entry = ast( + "main.osp", + vec![ + import("app", &["Counter"], None, ImportSelection::Wildcard), + function("main", Expr::Integer(0)), + ], + ); + let mut project = config("main.osp"); + project.allow_wildcard_imports = true; + let messages = error_messages(&project, &[ast("state.osp", vec![state]), entry]); + assert!( + contains(&messages, "wildcard imports from state modules"), + "{messages:?}" + ); + + let namespace_state = state_module( + "Counter", + Expr::Integer(0), + Vec::new(), + handler("CounterFx", Expr::Identifier("count".to_string())), + ); + let namespace_entry = ast( + "main.osp", + vec![ + import("app", &[], None, ImportSelection::Wildcard), + function("main", Expr::Integer(0)), + ], + ); + let namespace_messages = error_messages( + &project, + &[ast("state.osp", vec![namespace_state]), namespace_entry], + ); + assert!( + contains(&namespace_messages, "wildcard imports from state modules"), + "{namespace_messages:?}" + ); +} + +#[test] +fn nested_module_handler_cannot_qualify_as_outer_installer() { + // Implements [MODULES-STATE-MODULE]. + let nested = Stmt::Module { + path: SymbolPath::single("Nested"), + kind: ModuleKind::Plain, + signature: None, + body: vec![item( + Visibility::Private, + function( + "run", + handler("CounterFx", Expr::Identifier("count".to_string())), + ), + )], + doc: None, + position: None, + }; + let state = state_module( + "Counter", + Expr::Integer(0), + vec![item(Visibility::Private, nested)], + Expr::Bool(true), + ); + let messages = error_messages(&config("state.osp"), &[ast("state.osp", vec![state])]); + assert!( + contains(&messages, "exported handler installer"), + "{messages:?}" + ); + assert!( + contains(&messages, "only accessible inside"), + "{messages:?}" + ); +} + +#[test] +fn namespace_cannot_have_two_state_owners() { + // Implements [MODULES-STATE-MODULE]. + let first = empty_state("First"); + let second = empty_state("Second"); + let messages = error_messages( + &config("state.osp"), + &[ast("state.osp", vec![first, second])], + ); + assert!( + contains(&messages, "at most one state module"), + "{messages:?}" + ); +} + +#[test] +fn private_effect_is_not_a_valid_state_surface() { + // Implements [MODULES-STATE-MODULE]. + let mut state = state_module( + "Counter", + Expr::Integer(0), + Vec::new(), + handler("CounterFx", Expr::Identifier("count".to_string())), + ); + if let Stmt::Module { body, .. } = &mut state { + if let Some(effect) = body + .iter_mut() + .find(|item| matches!(item.declaration.as_ref(), Stmt::Effect { .. })) + { + effect.visibility = Visibility::Private; + } + } + let messages = error_messages(&config("state.osp"), &[ast("state.osp", vec![state])]); + assert!(contains(&messages, "exported owned effect"), "{messages:?}"); +} + +#[test] +fn module_mutation_boundaries_preserve_ordinary_local_mut() { + // Implements [MODULES-STATE-TOPLEVEL], [MODULES-STATE-MODULE]. + let mutable = |name: &str| Stmt::Let { + name: name.to_string(), + mutable: true, + ty: None, + value: Expr::Integer(0), + doc: None, + position: None, + }; + let namespace_messages = error_messages( + &config("namespace.osp"), + &[ast("namespace.osp", vec![mutable("global")])], + ); + assert!( + contains(&namespace_messages, "namespace-level `mut`"), + "{namespace_messages:?}" + ); + + let plain = Stmt::Module { + path: SymbolPath::single("Plain"), + kind: ModuleKind::Plain, + signature: None, + body: vec![item(Visibility::Private, mutable("cell"))], + doc: None, + position: None, + }; + let plain_messages = error_messages(&config("plain.osp"), &[ast("plain.osp", vec![plain])]); + assert!( + contains(&plain_messages, "plain modules cannot declare"), + "{plain_messages:?}" + ); + + let mut exported = state_module( + "Counter", + Expr::Integer(0), + Vec::new(), + handler("CounterFx", Expr::Identifier("count".to_string())), + ); + if let Stmt::Module { body, .. } = &mut exported { + if let Some(cell) = body.first_mut() { + cell.visibility = Visibility::Exported; + } + } + let export_messages = + error_messages(&config("export.osp"), &[ast("export.osp", vec![exported])]); + assert!( + contains(&export_messages, "`export mut` is forbidden"), + "{export_messages:?}" + ); + + let local_main = function( + "main", + Expr::Block { + statements: vec![ + mutable("local"), + Stmt::Assignment { + name: "local".to_string(), + value: Expr::Integer(1), + position: None, + }, + ], + value: Some(Box::new(Expr::Identifier("local".to_string()))), + }, + ); + let result = assemble(&config("local.osp"), &[ast("local.osp", vec![local_main])]); + assert!(result.is_ok(), "local mut assembly errors: {result:?}"); +} + +fn empty_state(name: &str) -> Stmt { + Stmt::Module { + path: SymbolPath::single(name), + kind: ModuleKind::State, + signature: None, + body: Vec::new(), + doc: None, + position: None, + } +} diff --git a/crates/osprey-project/tests/support/mod.rs b/crates/osprey-project/tests/support/mod.rs new file mode 100644 index 00000000..163b60c3 --- /dev/null +++ b/crates/osprey-project/tests/support/mod.rs @@ -0,0 +1,159 @@ +#![expect( + dead_code, + reason = "this support module is compiled independently by focused integration-test crates" +)] + +use osprey_ast::{ + EffectOperation, Expr, HandlerArm, ModuleItem, ModuleKind, Program, Stmt, SymbolPath, + Visibility, +}; +use osprey_project::{assemble, ProjectConfig, SourceFile}; +use osprey_syntax::{parse_program_with_flavor, Flavor}; +use std::path::PathBuf; + +pub(crate) fn config(entry: &str) -> ProjectConfig { + ProjectConfig { + name: "app".to_string(), + source_roots: vec![PathBuf::from("src")], + default_namespace: Some("app".to_string()), + entry: Some(PathBuf::from(entry)), + flavor: None, + allow_wildcard_imports: false, + } +} + +pub(crate) fn parsed(path: &str, flavor: Flavor, text: &str) -> SourceFile { + let parsed = parse_program_with_flavor(text, flavor); + assert!( + parsed.errors.is_empty(), + "parse errors: {:?}", + parsed.errors + ); + SourceFile { + path: PathBuf::from(path), + flavor, + source: text.to_string(), + program: parsed.program, + } +} + +pub(crate) fn ast(path: &str, statements: Vec) -> SourceFile { + SourceFile { + path: PathBuf::from(path), + flavor: Flavor::Default, + source: "\n".repeat(statements.len().max(1)), + program: Program { statements }, + } +} + +pub(crate) fn error_messages(config: &ProjectConfig, sources: &[SourceFile]) -> Vec { + match assemble(config, sources) { + Ok(_) => Vec::new(), + Err(errors) => errors.into_iter().map(|error| error.message).collect(), + } +} + +pub(crate) fn contains(messages: &[String], expected: &str) -> bool { + messages.iter().any(|message| message.contains(expected)) +} + +pub(crate) fn state_module( + name: &str, + initializer: Expr, + extra_items: Vec, + installer_body: Expr, +) -> Stmt { + let mut body = vec![ + item( + Visibility::Private, + Stmt::Let { + name: "count".to_string(), + mutable: true, + ty: None, + value: initializer, + doc: None, + position: None, + }, + ), + item( + Visibility::Exported, + Stmt::Effect { + name: "CounterFx".to_string(), + type_params: Vec::new(), + operations: vec![EffectOperation { + name: "next".to_string(), + ty: "fn() -> int".to_string(), + parameters: Vec::new(), + return_type: "int".to_string(), + }], + doc: None, + position: None, + }, + ), + ]; + body.extend(extra_items); + body.push(item(Visibility::Exported, function("run", installer_body))); + Stmt::Module { + path: SymbolPath::single(name), + kind: ModuleKind::State, + signature: None, + body, + doc: None, + position: None, + } +} + +pub(crate) fn handler(effect: &str, arm_body: Expr) -> Expr { + Expr::Handler { + effect: effect.to_string(), + arms: vec![HandlerArm { + operation: "next".to_string(), + params: Vec::new(), + body: arm_body, + }], + body: Box::new(Expr::Bool(true)), + position: None, + } +} + +pub(crate) fn function(name: &str, body: Expr) -> Stmt { + Stmt::Function { + name: name.to_string(), + type_params: Vec::new(), + parameters: Vec::new(), + return_type: None, + effects: Vec::new(), + body, + doc: None, + position: None, + } +} + +pub(crate) fn item(visibility: Visibility, statement: Stmt) -> ModuleItem { + ModuleItem { + visibility, + opaque: false, + declaration: Box::new(statement), + } +} + +pub(crate) fn import( + namespace: &str, + path: &[&str], + alias: Option<&str>, + selection: osprey_ast::ImportSelection, +) -> Stmt { + Stmt::Import(osprey_ast::ImportDecl { + target: osprey_ast::ImportTarget { + namespace: osprey_ast::NamespaceName::Identifier(namespace.to_string()), + path: SymbolPath::new(path.iter().copied()), + }, + alias: alias.map(str::to_string), + selection, + position: None, + }) +} + +pub(crate) fn path(parts: &[&str]) -> Expr { + Expr::Path(SymbolPath::new(parts.iter().copied())) +} diff --git a/crates/osprey-syntax/src/default/expr.rs b/crates/osprey-syntax/src/default/expr.rs index a8040e19..2000fd52 100644 --- a/crates/osprey-syntax/src/default/expr.rs +++ b/crates/osprey-syntax/src/default/expr.rs @@ -4,7 +4,7 @@ use super::lower::Lowerer; use crate::strings::{lower_interpolation, unquote}; use osprey_ast::{ - Expr, FieldAssignment, HandlerArm, MapEntry, MatchArm, NamedArgument, Pattern, Stmt, + Expr, FieldAssignment, HandlerArm, MapEntry, MatchArm, NamedArgument, Pattern, Stmt, SymbolPath, }; use tree_sitter::Node; @@ -77,22 +77,7 @@ impl Lowerer<'_> { } "await_call" => Expr::Await(Box::new(self.lower_inner_expr(node))), "recv_call" => Expr::Recv(Box::new(self.lower_inner_expr(node))), - "send_call" => { - let mut cursor = node.walk(); - let mut exprs = node - .named_children(&mut cursor) - .filter(|c| c.kind() == "expression"); - let channel = exprs - .next() - .map_or(Expr::Bool(false), |n| self.lower_expr(n)); - let value = exprs - .next() - .map_or(Expr::Bool(false), |n| self.lower_expr(n)); - Expr::Send { - channel: Box::new(channel), - value: Box::new(value), - } - } + "send_call" => self.lower_send(node), "lambda_expression" => Expr::Lambda { parameters: self.lower_params(node.child_by_field_name("parameters").or_else( || { @@ -126,12 +111,29 @@ impl Lowerer<'_> { "object_literal" => Expr::Object(self.lower_field_assignments(node)), "block" => self.lower_block(node), "literal" => self.lower_literal(node), + "qualified_path" => Expr::Path(SymbolPath::new( + self.descendants_of_kind(node, "identifier") + .into_iter() + .map(|identifier| self.text(identifier)), + )), "identifier" => Expr::Identifier(self.text(node)), "ternary_expression" => self.lower_ternary(node), _ => Expr::Bool(false), } } + fn lower_send(&self, node: Node<'_>) -> Expr { + let mut cursor = node.walk(); + let mut expressions = node + .named_children(&mut cursor) + .filter(|child| child.kind() == "expression") + .map(|expression| self.lower_expr(expression)); + Expr::Send { + channel: Box::new(expressions.next().unwrap_or(Expr::Bool(false))), + value: Box::new(expressions.next().unwrap_or(Expr::Bool(false))), + } + } + /// `if cond { a } else { b }` desugars to `match cond { true => a false => b }`, /// reusing the boolean-match path ([GRAMMAR-IF-ELSE]). `else if` is a nested /// `if_expression` in the `alternative` field, so it recurses naturally into diff --git a/crates/osprey-syntax/src/default/lower.rs b/crates/osprey-syntax/src/default/lower.rs index c88c0db0..b9e889b3 100644 --- a/crates/osprey-syntax/src/default/lower.rs +++ b/crates/osprey-syntax/src/default/lower.rs @@ -2,12 +2,10 @@ //! `effect`, `extern`, `module`), type expressions, and match patterns. use super::position_from_point; -use crate::strings::unquote; use osprey_ast::{ - DocComment, DocScope, EffectOperation, EffectRef, Expr, ExternParameter, ImportDecl, - ImportMember, ImportSelection, ImportTarget, ModuleItem, ModuleKind, NamespaceName, Parameter, - Pattern, Position, Program, SignatureAscription, SignatureItem, SignatureType, Stmt, - SymbolPath, TypeExpr, TypeField, TypeParam, TypeVariant, Variance, Visibility, + DocComment, DocScope, EffectOperation, EffectRef, Expr, ExternParameter, ModuleKind, Parameter, + Pattern, Position, Program, Stmt, SymbolPath, TypeExpr, TypeField, TypeParam, TypeVariant, + Variance, }; use tree_sitter::Node; @@ -112,10 +110,11 @@ impl<'a> Lowerer<'a> { // A file-scoped namespace owns every following declaration in the // file. Canonicalise that relationship here rather than making // later phases reinterpret source order. [MODULES-FILE-SCOPED-NAMESPACE] - if node.kind() == "namespace_declaration" - && node.child_by_field_name("body").is_none() + if node.kind() == "namespace_declaration" && node.child_by_field_name("body").is_none() { - let body = source_statements[index + 1..] + let body = source_statements + .get(index.saturating_add(1)..) + .unwrap_or_default() .iter() .filter_map(|s| self.first_named(*s)) .filter_map(|s| self.lower_stmt(s)) @@ -251,17 +250,20 @@ impl<'a> Lowerer<'a> { // making the adoption-friendly `type UserId = int` spelling an alias. // Osprey constructors conventionally begin uppercase; a lone lowercase // RHS therefore has an unambiguous type-alias interpretation. - if alias.is_none() - && variants.len() == 1 - && variants[0].fields.is_empty() - && variants[0] - .name - .chars() - .next() - .is_some_and(char::is_lowercase) - { - alias = Some(TypeExpr::named(variants[0].name.clone())); - variants.clear(); + let lowercase_alias = match variants.as_slice() { + [variant] + if variant.fields.is_empty() + && variant.name.chars().next().is_some_and(char::is_lowercase) => + { + Some(variant.name.clone()) + } + _ => None, + }; + if alias.is_none() { + if let Some(name) = lowercase_alias { + alias = Some(TypeExpr::named(name)); + variants.clear(); + } } Stmt::Type { name: self.field_text(node, "name"), @@ -306,7 +308,7 @@ impl<'a> Lowerer<'a> { out } - fn lower_operations(&self, node: Node<'_>) -> Vec { + pub(crate) fn lower_operations(&self, node: Node<'_>) -> Vec { self.named_of_kind(node, "operation_declaration") .iter() .map(|op| EffectOperation { @@ -347,7 +349,7 @@ impl<'a> Lowerer<'a> { /// Lower a declaration's `type_parameters` field into variance-carrying /// [`TypeParam`]s. Implements [TYPE-VARIANCE-DECL]. - fn lower_type_params(&self, node: Node<'_>) -> Vec { + pub(crate) fn lower_type_params(&self, node: Node<'_>) -> Vec { let Some(list) = node.child_by_field_name("type_parameters") else { return Vec::new(); }; @@ -366,7 +368,7 @@ impl<'a> Lowerer<'a> { /// Lower an effect row into effect references with optional type /// arguments (`!State`). Implements [EFFECTS-GENERIC-ROWS]. - fn lower_effects(&self, effects: Option>) -> Vec { + pub(crate) fn lower_effects(&self, effects: Option>) -> Vec { let Some(effects) = effects else { return Vec::new(); }; @@ -493,7 +495,7 @@ impl<'a> Lowerer<'a> { "field_pattern" => Pattern::Structural { fields: self.field_pattern_names(inner), }, - "identifier" => { + "identifier" | "qualified_path" => { // Could be: constructor `Ctor { fields }`, type-annotated, sub-patterns, // or a bare binding. Inspect siblings of the name field. let name = self.text(inner); @@ -658,25 +660,6 @@ mod tests { children.into_iter().find_map(|c| find_kind(c, kind)) } - #[test] - fn lowers_import_and_module() { - // `import` exercises lower_stmt's Import arm (texts_of_kind identifiers). - match one("import std.io.file\n") { - Stmt::Import { module } => assert_eq!(module, vec!["std", "io", "file"]), - s => panic!("expected import, got {s:?}"), - } - // A module body re-enters lower_stmt for nested declarations. - match one("module M {\n let x = 1\n fn f() = x\n}\n") { - Stmt::Module { name, body, .. } => { - assert_eq!(name, "M"); - assert_eq!(body.len(), 2); - assert!(matches!(body[0], Stmt::Let { .. })); - assert!(matches!(body[1], Stmt::Function { .. })); - } - s => panic!("expected module, got {s:?}"), - } - } - #[test] fn lowers_record_type_and_array_and_function_types() { // record_type definition (lower_type_decl record arm + lower_field_decls) diff --git a/crates/osprey-syntax/src/default/mod.rs b/crates/osprey-syntax/src/default/mod.rs index a6de21f9..36c1614d 100644 --- a/crates/osprey-syntax/src/default/mod.rs +++ b/crates/osprey-syntax/src/default/mod.rs @@ -16,6 +16,7 @@ use tree_sitter::{Node, Parser, Point, Tree}; mod expr; mod lower; +mod modules; pub use lower::Lowerer; @@ -69,6 +70,17 @@ fn collect_errors(node: Node<'_>, src: &[u8], out: &mut Vec) { }, position: position_from_point(p), }); + } else if node.kind() == "identifier" + && node + .utf8_text(src) + .is_ok_and(|word| MODULE_KEYWORDS.contains(&word)) + { + let p = node.start_position(); + let word = node.utf8_text(src).unwrap_or_default(); + out.push(SyntaxError { + message: format!("`{word}` is reserved for the module system"), + position: position_from_point(p), + }); } let mut cursor = node.walk(); for child in node.children(&mut cursor) { @@ -76,6 +88,19 @@ fn collect_errors(node: Node<'_>, src: &[u8], out: &mut Vec) { } } +/// Tree-sitter keywords are contextual at identifier-only parse states. The +/// language contract reserves module words globally, so reject an identifier +/// node carrying one even when the CST could otherwise accept it. +const MODULE_KEYWORDS: &[&str] = &[ + "namespace", + "signature", + "export", + "opaque", + "state", + "as", + "extra", +]; + /// Convert a tree-sitter point to Osprey's one-based-line source position. pub(crate) fn position_from_point(point: Point) -> Position { Position { diff --git a/crates/osprey-syntax/src/default/modules.rs b/crates/osprey-syntax/src/default/modules.rs new file mode 100644 index 00000000..e7b2a1f8 --- /dev/null +++ b/crates/osprey-syntax/src/default/modules.rs @@ -0,0 +1,472 @@ +//! Default-flavor lowering for logical namespaces, imports, modules, exports, +//! and explicit signatures. These surface forms converge on the shared module +//! AST before project resolution begins. [MODULES-FLAVOR-PROJECTION] + +use super::lower::Lowerer; +use crate::strings::unquote; +use osprey_ast::{ + ImportDecl, ImportMember, ImportSelection, ImportTarget, ModuleItem, NamespaceName, + SignatureAscription, SignatureItem, SignatureType, Stmt, SymbolPath, TypeExpr, Visibility, +}; +use tree_sitter::Node; + +impl Lowerer<'_> { + /// Lower both modern `::` imports and the original dotted Default spelling + /// into one canonical import edge. [MODULES-IMPORT] + pub(crate) fn lower_import(&self, node: Node<'_>) -> ImportDecl { + if let Some(legacy) = node.child_by_field_name("legacy_target") { + let mut segments = self.texts_of_kind(legacy, "identifier").into_iter(); + let namespace = segments.next().unwrap_or_default(); + return ImportDecl { + target: ImportTarget { + namespace: NamespaceName::Identifier(namespace), + path: SymbolPath::new(segments), + }, + alias: None, + selection: ImportSelection::Whole, + position: Some(self.pos(node)), + }; + } + + let target = node.child_by_field_name("target"); + let namespace_node = target.and_then(|target| target.child_by_field_name("namespace")); + let namespace = self.lower_namespace_name(namespace_node); + let all_identifiers: Vec = target + .map(|target| { + self.descendants_of_kind(target, "identifier") + .into_iter() + .map(|identifier| self.text(identifier)) + .collect() + }) + .unwrap_or_default(); + let path = match namespace { + NamespaceName::Identifier(_) => SymbolPath::new(all_identifiers.into_iter().skip(1)), + NamespaceName::Quoted(_) => SymbolPath::new(all_identifiers), + }; + let tail = node.child_by_field_name("tail"); + let alias = tail + .and_then(|tail| tail.child_by_field_name("alias")) + .map(|alias| self.text(alias)); + let selection = match tail { + Some(tail) if self.text(tail).trim_end().ends_with('*') => ImportSelection::Wildcard, + Some(tail) if self.text(tail).contains('{') => ImportSelection::Members( + self.descendants_of_kind(tail, "import_member") + .into_iter() + .map(|member| ImportMember { + name: self.field_text(member, "name"), + alias: member + .child_by_field_name("alias") + .map(|alias| self.text(alias)), + }) + .collect(), + ), + _ => ImportSelection::Whole, + }; + ImportDecl { + target: ImportTarget { namespace, path }, + alias, + selection, + position: Some(self.pos(node)), + } + } + + pub(crate) fn lower_namespace_name(&self, node: Option>) -> NamespaceName { + let Some(node) = node else { + return NamespaceName::Identifier(String::new()); + }; + let inner = if node.kind() == "namespace_name" { + self.first_named(node).unwrap_or(node) + } else { + node + }; + if inner.kind() == "string" { + NamespaceName::Quoted(unquote(&self.text(inner))) + } else { + NamespaceName::Identifier(self.text(inner)) + } + } + + pub(crate) fn lower_symbol_path(&self, node: Node<'_>) -> SymbolPath { + SymbolPath::new( + self.descendants_of_kind(node, "identifier") + .into_iter() + .map(|identifier| self.text(identifier)), + ) + } + + pub(crate) fn lower_statement_children(&self, node: Node<'_>) -> Vec { + self.named_of_kind(node, "statement") + .iter() + .filter_map(|statement| self.first_named(*statement)) + .filter_map(|statement| self.lower_stmt(statement)) + .collect() + } + + pub(crate) fn lower_signature_ascription(&self, node: Node<'_>) -> SignatureAscription { + SignatureAscription { + path: node + .child_by_field_name("path") + .map_or_else(SymbolPath::default, |path| self.lower_symbol_path(path)), + allow_extra: node.child_by_field_name("extra").is_some(), + } + } + + pub(crate) fn lower_module_item(&self, node: Node<'_>) -> Option { + let export = self.first_child_of_kind(node, "export_declaration"); + let export_doc = export.and_then(|export| self.doc_text(export)); + let (declaration_node, visibility, opaque) = match export { + Some(export) => ( + export.child_by_field_name("declaration")?, + Visibility::Exported, + export.child_by_field_name("opaque").is_some(), + ), + None => (self.first_named(node)?, Visibility::Private, false), + }; + let mut declaration = self.lower_stmt(declaration_node)?; + if let Some(doc) = export_doc { + attach_doc(&mut declaration, doc); + } + // A bare uppercase alias is syntactically indistinguishable from the + // legacy one-variant union. `opaque` supplies the missing intent. + if opaque { + if let Stmt::Type { + variants, alias, .. + } = &mut declaration + { + let alias_name = match variants.as_slice() { + [variant] if variant.fields.is_empty() => Some(variant.name.clone()), + _ => None, + }; + if alias.is_none() { + if let Some(name) = alias_name { + *alias = Some(TypeExpr::named(name)); + variants.clear(); + } + } + } + } + Some(ModuleItem { + visibility, + opaque, + declaration: Box::new(declaration), + }) + } + + pub(crate) fn lower_signature_item(&self, node: Node<'_>) -> Option { + let item = self.first_named(node)?; + Some(match item.kind() { + "signature_value" => SignatureItem::Value { + name: self.field_text(item, "name"), + ty: item + .child_by_field_name("type") + .map_or_else(|| TypeExpr::named(""), |ty| self.lower_type(ty)), + position: Some(self.pos(item)), + }, + "signature_function" => { + let parameters = item + .child_by_field_name("parameters") + .map(|parameters| { + self.named_of_kind(parameters, "extern_parameter") + .into_iter() + .filter_map(|parameter| parameter.child_by_field_name("type")) + .map(|ty| self.lower_type(ty)) + .collect() + }) + .unwrap_or_default(); + SignatureItem::Function { + name: self.field_text(item, "name"), + type_params: self.lower_type_params(item), + parameters, + return_type: item + .child_by_field_name("return_type") + .map_or_else(|| TypeExpr::named("Unit"), |ty| self.lower_type(ty)), + effects: self.lower_effects(item.child_by_field_name("effects")), + position: Some(self.pos(item)), + } + } + "signature_type" => SignatureItem::Type { + name: self.field_text(item, "name"), + type_params: self.lower_type_params(item), + definition: item + .child_by_field_name("definition") + .map_or(SignatureType::Abstract, |ty| { + SignatureType::Manifest(self.lower_type(ty)) + }), + opaque: item.child_by_field_name("opaque").is_some(), + position: Some(self.pos(item)), + }, + "effect_declaration" => SignatureItem::Effect { + name: self.field_text(item, "name"), + type_params: self.lower_type_params(item), + operations: self.lower_operations(item), + position: Some(self.pos(item)), + }, + "signature_module" => SignatureItem::Module { + path: item + .child_by_field_name("path") + .map_or_else(SymbolPath::default, |path| self.lower_symbol_path(path)), + signature: item.child_by_field_name("signature").map_or( + SignatureAscription { + path: SymbolPath::default(), + allow_extra: false, + }, + |signature| self.lower_signature_ascription(signature), + ), + position: Some(self.pos(item)), + }, + _ => return None, + }) + } +} + +fn attach_doc(statement: &mut Stmt, doc: osprey_ast::DocComment) { + match statement { + Stmt::Let { doc: slot, .. } + | Stmt::Function { doc: slot, .. } + | Stmt::Extern { doc: slot, .. } + | Stmt::Type { doc: slot, .. } + | Stmt::Effect { doc: slot, .. } + | Stmt::Module { doc: slot, .. } + | Stmt::Signature { doc: slot, .. } => *slot = Some(doc), + _ => {} + } +} + +#[cfg(test)] +#[expect( + clippy::indexing_slicing, + reason = "test assertions: indexing failures should identify malformed ASTs" +)] +mod tests { + use crate::parse_program; + use osprey_ast::{ + Expr, ImportSelection, ModuleKind, NamespaceName, SignatureItem, SignatureType, Stmt, + Visibility, + }; + + fn parse(src: &str) -> Vec { + let parsed = parse_program(src); + assert!( + parsed.errors.is_empty(), + "syntax errors: {:?}", + parsed.errors + ); + parsed.program.statements + } + + #[test] + fn lowers_file_and_block_namespaces_with_opaque_labels() { + // The file-scoped form owns every following declaration in canonical + // AST form. [MODULES-FILE-SCOPED-NAMESPACE] + let statements = parse("namespace billing;\nlet x = 1\nfn f() = x\n"); + match &statements[0] { + Stmt::Namespace { + name, + body, + file_scoped, + position, + } => { + assert_eq!(name, &NamespaceName::Identifier("billing".into())); + assert!(*file_scoped); + assert_eq!(body.len(), 2); + assert_eq!(position.map(|p| p.line), Some(1)); + } + other => panic!("expected file namespace, got {other:?}"), + } + + let statements = parse("namespace \"billing/api\" { let x = 1 }\n"); + match &statements[0] { + Stmt::Namespace { + name, + body, + file_scoped, + .. + } => { + assert_eq!(name, &NamespaceName::Quoted("billing/api".into())); + assert!(!file_scoped); + assert_eq!(body.len(), 1); + } + other => panic!("expected block namespace, got {other:?}"), + } + } + + #[test] + fn lowers_every_import_selection_and_legacy_dots() { + let statements = parse( + "import billing::Tax\n\ + import billing::Tax as T\n\ + import billing::Tax::{addTax, zero as noTax}\n\ + import billing::Tax::*\n\ + import \"billing/api\" as api\n\ + import std.io.file\n", + ); + let imports: Vec<_> = statements + .iter() + .map(|statement| match statement { + Stmt::Import(import) => import, + other => panic!("expected import, got {other:?}"), + }) + .collect(); + assert_eq!(imports[0].target.namespace.label(), "billing"); + assert_eq!(imports[0].target.path.segments, ["Tax"]); + assert_eq!(imports[1].alias.as_deref(), Some("T")); + match &imports[2].selection { + ImportSelection::Members(members) => { + assert_eq!(members.len(), 2); + assert_eq!(members[1].name, "zero"); + assert_eq!(members[1].alias.as_deref(), Some("noTax")); + } + other => panic!("expected member selection, got {other:?}"), + } + assert!(matches!(imports[3].selection, ImportSelection::Wildcard)); + assert!(imports[4].target.namespace.is_quoted()); + assert_eq!(imports[4].alias.as_deref(), Some("api")); + assert_eq!(imports[5].target.namespace.label(), "std"); + assert_eq!(imports[5].target.path.segments, ["io", "file"]); + } + + #[test] + fn lowers_state_module_paths_ascription_exports_and_opaque_alias() { + let statements = parse( + "state module Storage::Memory : StoreSig + extra {\n\ + mut count = 0\n\ + export opaque type Store = int\n\ + export fn empty() -> Store = count\n\ + }\n", + ); + match &statements[0] { + Stmt::Module { + path, + kind, + signature, + body, + position, + .. + } => { + assert_eq!(path.segments, ["Storage", "Memory"]); + assert_eq!(*kind, ModuleKind::State); + let ascription = signature.as_ref().expect("signature"); + assert_eq!(ascription.path.segments, ["StoreSig"]); + assert!(ascription.allow_extra); + assert_eq!(body.len(), 3); + assert_eq!(body[0].visibility, Visibility::Private); + assert_eq!(body[1].visibility, Visibility::Exported); + assert!(body[1].opaque); + assert!(matches!( + body[1].declaration.as_ref(), + Stmt::Type { + alias: Some(alias), + variants, + .. + } if alias.name == "int" && variants.is_empty() + )); + assert_eq!(position.map(|p| p.line), Some(1)); + } + other => panic!("expected state module, got {other:?}"), + } + } + + #[test] + fn lowers_typed_signature_items() { + let statements = parse( + "signature StoreSig {\n\ + opaque type Store\n\ + type Count = int\n\ + let zero: Count\n\ + fn empty() -> Store\n\ + effect StoreFx { load: fn() -> Store }\n\ + module Nested : NestedSig + extra\n\ + }\n", + ); + match &statements[0] { + Stmt::Signature { name, items, .. } => { + assert_eq!(name, "StoreSig"); + assert_eq!(items.len(), 6); + assert!(matches!( + items[0], + SignatureItem::Type { + definition: SignatureType::Abstract, + opaque: true, + .. + } + )); + assert!(matches!( + items[1], + SignatureItem::Type { + definition: SignatureType::Manifest(_), + opaque: false, + .. + } + )); + assert!(matches!(items[2], SignatureItem::Value { .. })); + assert!(matches!(items[3], SignatureItem::Function { .. })); + assert!(matches!(items[4], SignatureItem::Effect { .. })); + assert!(matches!( + &items[5], + SignatureItem::Module { signature, .. } if signature.allow_extra + )); + } + other => panic!("expected signature, got {other:?}"), + } + } + + #[test] + fn lowers_qualified_paths_in_calls_types_and_interpolation() { + let statements = parse( + "fn run(x: billing::Money) = billing::Tax::addTax(x)\n\ + let shown = \"${billing::Tax::addTax(1)}\"\n", + ); + match &statements[0] { + Stmt::Function { + parameters, + body: Expr::Call { function, .. }, + .. + } => { + assert_eq!( + parameters[0].ty.as_ref().map(|ty| ty.name.as_str()), + Some("billing::Money") + ); + assert!(matches!( + function.as_ref(), + Expr::Path(path) if path.segments == ["billing", "Tax", "addTax"] + )); + } + other => panic!("expected qualified call, got {other:?}"), + } + let Stmt::Let { + value: Expr::InterpolatedStr(parts), + .. + } = &statements[1] + else { + panic!("expected interpolated let") + }; + assert!(parts.iter().any(|part| matches!( + part, + osprey_ast::InterpolatedPart::Expr(Expr::Call { function, .. }) + if matches!(function.as_ref(), Expr::Path(_)) + ))); + } + + #[test] + fn module_keywords_are_reserved_as_identifiers() { + for keyword in [ + "namespace", + "signature", + "export", + "opaque", + "state", + "as", + "extra", + ] { + let parsed = parse_program(&format!("let {keyword} = 1\n")); + assert!( + parsed + .errors + .iter() + .any(|error| error.message.contains("reserved for the module system")), + "expected {keyword:?} to be reserved; errors: {:?}", + parsed.errors + ); + } + } +} diff --git a/crates/osprey-syntax/src/ml/cst.rs b/crates/osprey-syntax/src/ml/cst.rs index 74b6706c..b413c18e 100644 --- a/crates/osprey-syntax/src/ml/cst.rs +++ b/crates/osprey-syntax/src/ml/cst.rs @@ -243,6 +243,9 @@ pub(crate) enum MlItem { type_params: Vec, /// The declared variants (one per constructor; a record has exactly one). variants: Vec, + /// A direct manifest alias (`type UserId = int`) instead of a + /// variant/record body. + alias: Option, /// Source position of the `type` keyword. pos: Position, }, diff --git a/crates/osprey-syntax/src/ml/lower.rs b/crates/osprey-syntax/src/ml/lower.rs index 4f46957e..583d33b0 100644 --- a/crates/osprey-syntax/src/ml/lower.rs +++ b/crates/osprey-syntax/src/ml/lower.rs @@ -31,8 +31,8 @@ use osprey_ast::{ DocComment, DocScope, EffectOperation, EffectRef, Expr, ExternParameter, FieldAssignment, HandlerArm, ImportDecl, ImportMember, ImportSelection, ImportTarget, MapEntry, MatchArm, ModuleItem, ModuleKind, NamespaceName, Parameter, Pattern, Position, Program, - SignatureAscription, SignatureItem, SignatureType, Stmt, SymbolPath, TypeExpr, TypeField, - TypeParam, TypeVariant, Variance, Visibility, + SignatureAscription, SignatureItem, Stmt, SymbolPath, TypeExpr, TypeField, TypeParam, + TypeVariant, Variance, }; use std::cell::RefCell; use std::collections::HashSet; @@ -174,68 +174,156 @@ fn collect_names_in_expr(expr: &MlExpr, out: &mut HashSet) { /// same name that immediately follows it. An orphaned signature (no matching /// binding next) is dropped. Used at top level and inside layout blocks so /// local signed functions work too. -fn lower_items(items: Vec) -> Vec { - let mut out = Vec::new(); - let mut pending: Option = None; - // The most recent `(** … *)` doc comment, attached to the next declaration - // ([DOC-SIGIL-ML]) — the same pairing pattern as a signature. - let mut pending_doc: Option = None; - for item in items { +pub(super) fn lower_items(items: Vec) -> Vec { + if let Some(index) = items + .iter() + .position(|item| matches!(item, MlItem::Namespace { body: None, .. })) + { + return lower_file_namespace(items, index); + } + ItemLower::default().lower_all(items) +} + +/// A file-scoped namespace owns every declaration after its header. Imports +/// before the header remain file-level edges. +fn lower_file_namespace(mut items: Vec, index: usize) -> Vec { + let tail = items.split_off(index.saturating_add(1)); + match items.pop() { + Some(MlItem::Namespace { name, pos, .. }) => { + let mut out = lower_items(items); + out.push(Stmt::Namespace { + name: lower_namespace_name(name), + body: lower_items(tail), + file_scoped: true, + position: Some(pos), + }); + out + } + _ => lower_items(items), + } +} + +/// Stateful pairing of docs/signatures with the declaration they annotate. +#[derive(Default)] +struct ItemLower { + out: Vec, + pending: Option, + pending_doc: Option, +} + +impl ItemLower { + fn lower_all(mut self, items: Vec) -> Vec { + for item in items { + self.lower_item(item); + } + self.out + } + + fn lower_item(&mut self, item: MlItem) { match item { MlItem::Doc(text) => { - pending_doc = Some(crate::docparse::parse_doc(&text, DocScope::Outer)); + self.pending_doc = Some(crate::docparse::parse_doc(&text, DocScope::Outer)); } - MlItem::ValueSignature { + item @ MlItem::ValueSignature { .. } => self.lower_signature(item), + item @ MlItem::Binding { .. } => self.lower_binding_item(item), + item @ (MlItem::Assign { .. } + | MlItem::Expr { .. } + | MlItem::Import { .. } + | MlItem::Export { .. } + | MlItem::Opaque { .. }) => self.lower_simple(item), + item @ (MlItem::Type { .. } | MlItem::Extern { .. } | MlItem::Effect { .. }) => { + self.lower_declaration(item); + } + item @ (MlItem::Namespace { .. } + | MlItem::Module { .. } + | MlItem::ModuleSignature { .. }) => self.lower_container(item), + } + } + + fn lower_signature(&mut self, item: MlItem) { + if let MlItem::ValueSignature { + name, + type_params, + ty, + effects, + .. + } = item + { + self.pending = Some(MlSig { name, type_params, ty, effects, - } => { - pending = Some(MlSig { + }); + } + } + + fn lower_binding_item(&mut self, item: MlItem) { + let MlItem::Binding { + mutable, + name, + params, + uncurried, + body, + pos, + } = item + else { + return; + }; + let sig = self + .pending + .take() + .filter(|signature| signature.name == name); + let stmt = lower_binding(mutable, name, params, uncurried, body, pos, sig); + self.out.push(attach_doc(stmt, self.pending_doc.take())); + } + + fn lower_simple(&mut self, item: MlItem) { + match item { + MlItem::Assign { name, value, pos } => { + self.clear_pending(); + self.out.push(Stmt::Assignment { name, - type_params, - ty, - effects, + value: lower_expr(value), + position: Some(pos), }); } - MlItem::Binding { - mutable, - name, - params, - uncurried, - body, - pos, - } => { - // Pair the binding with its preceding signature's type params, - // type and effect row (all `None`/empty when unsigned), passed - // as one `sig` argument so the lowerer stays within the - // parameter budget. - let sig = pending.take().filter(|s| s.name == name); - let stmt = lower_binding(mutable, name, params, uncurried, body, pos, sig); - out.push(attach_doc(stmt, pending_doc.take())); - } - MlItem::Assign { name, value, pos } => { - pending = None; - pending_doc = None; - out.push(Stmt::Assignment { - name, + MlItem::Expr { value, pos } => { + self.clear_pending(); + self.out.push(Stmt::Expr { value: lower_expr(value), position: Some(pos), }); } + MlItem::Import { import, pos } => { + self.clear_pending(); + self.out.push(Stmt::Import(lower_import(import, pos))); + } + MlItem::Export { item, .. } | MlItem::Opaque { item, .. } => { + self.pending = None; + self.out.extend(lower_items(vec![*item])); + } + _ => {} + } + } + + fn lower_declaration(&mut self, item: MlItem) { + self.pending = None; + match item { MlItem::Type { name, type_params, variants, + alias, pos, } => { - pending = None; - out.push(Stmt::Type { + self.out.push(Stmt::Type { name, type_params: type_params.into_iter().map(lower_type_param).collect(), variants: variants.into_iter().map(lower_variant).collect(), + alias: alias.as_ref().map(required_type_expr), validation_func: None, - doc: pending_doc.take(), + doc: self.pending_doc.take(), position: Some(pos), }); } @@ -245,12 +333,11 @@ fn lower_items(items: Vec) -> Vec { return_type, pos, } => { - pending = None; - out.push(Stmt::Extern { + self.out.push(Stmt::Extern { name, parameters: params.into_iter().map(lower_extern_param).collect(), return_type: return_type.as_ref().and_then(type_expr), - doc: pending_doc.take(), + doc: self.pending_doc.take(), position: Some(pos), }); } @@ -260,32 +347,144 @@ fn lower_items(items: Vec) -> Vec { operations, pos, } => { - pending = None; - out.push(Stmt::Effect { + self.out.push(Stmt::Effect { name, type_params: type_params.into_iter().map(lower_type_param).collect(), operations: operations.into_iter().map(lower_effect_op).collect(), - doc: pending_doc.take(), + doc: self.pending_doc.take(), position: Some(pos), }); } - MlItem::Expr { value, pos } => { - pending = None; - pending_doc = None; - out.push(Stmt::Expr { - value: lower_expr(value), + _ => {} + } + } + + fn lower_container(&mut self, item: MlItem) { + self.pending = None; + match item { + MlItem::Namespace { + name, + body: Some(body), + pos, + } => { + self.out.push(Stmt::Namespace { + name: lower_namespace_name(name), + body: lower_items(body), + file_scoped: false, + position: Some(pos), + }); + } + MlItem::Namespace { + body: None, + name, + pos, + } => { + self.out.push(Stmt::Namespace { + name: lower_namespace_name(name), + body: Vec::new(), + file_scoped: true, position: Some(pos), }); } + MlItem::Module { + path, + kind, + signature, + body, + pos, + } => { + self.out.push(Stmt::Module { + path: lower_symbol_path(path), + kind: lower_module_kind(kind), + signature: signature.map(|path| SignatureAscription { + path: lower_symbol_path(path), + allow_extra: false, + }), + body: lower_module_items(body), + doc: self.pending_doc.take(), + position: Some(pos), + }); + } + MlItem::ModuleSignature { name, items, pos } => { + self.out.push(Stmt::Signature { + name, + items: items.into_iter().map(lower_signature_item).collect(), + doc: self.pending_doc.take(), + position: Some(pos), + }); + } + _ => {} } } - out + + fn clear_pending(&mut self) { + self.pending = None; + self.pending_doc = None; + } +} + +fn lower_namespace_name(name: MlNamespaceName) -> NamespaceName { + match name { + MlNamespaceName::Ident(label) => NamespaceName::Identifier(label), + MlNamespaceName::Quoted(label) => NamespaceName::Quoted(crate::strings::unquote(&label)), + } +} + +fn lower_symbol_path(path: MlSymbolPath) -> SymbolPath { + SymbolPath { + segments: path.segments, + } +} + +fn lower_import(import: MlImport, pos: Position) -> ImportDecl { + ImportDecl { + target: ImportTarget { + namespace: lower_namespace_name(import.namespace), + path: lower_symbol_path(import.path), + }, + alias: import.alias, + selection: match import.selection { + MlImportSelection::Whole => ImportSelection::Whole, + MlImportSelection::Wildcard => ImportSelection::Wildcard, + MlImportSelection::Members(members) => ImportSelection::Members( + members + .into_iter() + .map(|member| ImportMember { + name: member.name, + alias: member.alias, + }) + .collect(), + ), + }, + position: Some(pos), + } +} + +const fn lower_module_kind(kind: MlModuleKind) -> ModuleKind { + match kind { + MlModuleKind::Plain => ModuleKind::Plain, + MlModuleKind::State => ModuleKind::State, + } +} + +/// Lower implementation declarations while retaining the visibility/opacity +/// wrappers which exist only inside a closed module ([MODULES-EXPORTS]). +fn lower_module_items(items: Vec) -> Vec { + super::module_lower::module_items(items) +} + +fn lower_signature_item(item: MlSignatureItem) -> SignatureItem { + super::module_lower::signature_item(item) +} + +fn required_type_expr(ty: &MlType) -> TypeExpr { + super::module_lower::required_type(ty) } /// Attach a pending doc comment to the `Function`/`Let` a binding lowered to. /// A binding lowers to exactly one of those two, so this sets whichever it is — /// matching by mutable reference to the `doc` field only, no struct rebuild. -fn attach_doc(mut stmt: Stmt, doc: Option) -> Stmt { +pub(super) fn attach_doc(mut stmt: Stmt, doc: Option) -> Stmt { if let Stmt::Function { doc: slot, .. } | Stmt::Let { doc: slot, .. } = &mut stmt { *slot = doc; } @@ -329,7 +528,7 @@ fn lower_type_field(field: MlTypeField) -> TypeField { /// type checker's `convert.rs` accepts (`int -> bool` is rejected). The argument /// side is always parenthesised (`(int)`, or a tuple's own `(a, b)`); the result /// side is rendered bare so a curried tail reads `(int) -> (int) -> int`. -fn render_type(ty: &MlType) -> String { +pub(super) fn render_type(ty: &MlType) -> String { match ty { MlType::Name(name) => name.clone(), MlType::App { head, args } => { @@ -364,7 +563,7 @@ fn render_tuple(parts: &[MlType]) -> String { /// `Function` (twinning Default `fn f(x, y)`); `f x y = …` (curried) builds a /// one-parameter `Function` returning a `Lambda` chain ([FLAVOR-ML-CURRY]). The /// unit marker `()` yields a zero-parameter function, matching `fn f() = …`. -fn lower_binding( +pub(super) fn lower_binding( mutable: bool, name: String, params: Vec, @@ -413,17 +612,33 @@ fn lower_binding( } /// A parsed signature awaiting its binding: `name : ty ! effects`. -struct MlSig { - name: String, +pub(super) struct MlSig { + pub(super) name: String, type_params: Vec, ty: MlType, effects: Vec, } +impl MlSig { + pub(super) fn new( + name: String, + type_params: Vec, + ty: MlType, + effects: Vec, + ) -> Self { + Self { + name, + type_params, + ty, + effects, + } + } +} + /// Lower one CST type parameter to the canonical variance-carrying /// [`TypeParam`] — byte-identical to the Default flavor's lowering. /// Implements [TYPE-VARIANCE-DECL]. -fn lower_type_param(p: MlTypeParam) -> TypeParam { +pub(super) fn lower_type_param(p: MlTypeParam) -> TypeParam { TypeParam { name: p.name, variance: match p.variance { @@ -437,7 +652,7 @@ fn lower_type_param(p: MlTypeParam) -> TypeParam { /// Lower one effect-row reference to the canonical [`EffectRef`], threading /// its type arguments through the shared [`type_expr`] path so they are /// byte-identical to the Default flavor's. Implements [EFFECTS-GENERIC-ROWS]. -fn lower_effect_ref(r: MlEffectRef) -> EffectRef { +pub(super) fn lower_effect_ref(r: MlEffectRef) -> EffectRef { EffectRef { name: r.name, type_args: r @@ -500,7 +715,7 @@ fn expand_tuple_head(spine: Vec, param_count: usize) -> Vec { /// [`EffectOperation`], rendering the payload/result into the `fn(P) -> R` /// surface string the Default flavor emits ([FLAVOR-ML-EFFECT]). `parameters` /// and `return_type` stay empty/blank, matching the Default-flavor shape. -fn lower_effect_op(op: MlEffectOp) -> EffectOperation { +pub(super) fn lower_effect_op(op: MlEffectOp) -> EffectOperation { EffectOperation { ty: format!( "fn({}) -> {}", @@ -636,7 +851,7 @@ fn lower_lambda(params: Vec, body: Expr, pos: Position) -> Expr { /// Flatten the top-level arrow spine of a type: `a -> b -> c` ⇒ `[a, b, c]`, /// `(a, b) -> c` ⇒ `[(a,b), c]`, a non-arrow ⇒ a single-element list. -fn arrow_spine(ty: &MlType) -> Vec { +pub(super) fn arrow_spine(ty: &MlType) -> Vec { match ty { MlType::Arrow { from, to } => { let mut spine = vec![(**from).clone()]; @@ -649,7 +864,7 @@ fn arrow_spine(ty: &MlType) -> Vec { /// Rebuild a right-associative function type from an arrow-spine slice: `[]` ⇒ /// no type, `[t]` ⇒ `t`, `[a, b, …]` ⇒ `a -> (b -> …)`. -fn arrow_of(slice: &[MlType]) -> Option { +pub(super) fn arrow_of(slice: &[MlType]) -> Option { match slice { [] => None, [single] => type_expr(single), @@ -659,7 +874,7 @@ fn arrow_of(slice: &[MlType]) -> Option { is_array: false, array_element: None, is_function: true, - parameter_types: vec![type_expr(first)?], + parameter_types: arrow_parameter_types(first)?, return_type: Some(Box::new(arrow_of(rest)?)), position: None, }), @@ -669,7 +884,7 @@ fn arrow_of(slice: &[MlType]) -> Option { /// Convert an ML type to a canonical [`TypeExpr`]. A tuple type has no canonical /// `TypeExpr` form, so it (and anything containing one) yields `None` — leaving /// that position to inference rather than annotating it wrongly. -fn type_expr(ty: &MlType) -> Option { +pub(super) fn type_expr(ty: &MlType) -> Option { match ty { MlType::Name(name) => Some(TypeExpr::named(name.clone())), MlType::App { head, args } => { @@ -685,7 +900,7 @@ fn type_expr(ty: &MlType) -> Option { is_array: false, array_element: None, is_function: true, - parameter_types: vec![type_expr(from)?], + parameter_types: arrow_parameter_types(from)?, return_type: Some(Box::new(type_expr(to)?)), position: None, }), @@ -693,6 +908,16 @@ fn type_expr(ty: &MlType) -> Option { } } +/// ML's bare `Unit` arrow domain is the zero-argument function boundary, just +/// as `()` is the zero-argument binding/call marker. Other domains contribute +/// one canonical parameter; tuple domains are handled by their callers. +fn arrow_parameter_types(domain: &MlType) -> Option> { + match domain { + MlType::Name(name) if name == UNIT_PAYLOAD => Some(Vec::new()), + other => Some(vec![type_expr(other)?]), + } +} + /// Lower one CST expression to a canonical [`Expr`]. fn lower_expr(expr: MlExpr) -> Expr { match expr { @@ -739,19 +964,7 @@ fn lower_expr(expr: MlExpr) -> Expr { uncurried, body, pos, - } => { - let body = lower_expr(*body); - if uncurried { - Expr::Lambda { - parameters: flat_params(params), - return_type: None, - body: Box::new(body), - position: Some(pos), - } - } else { - lower_lambda(params, body, pos) - } - } + } => lower_lambda_node(params, uncurried, *body, pos), MlExpr::Match { scrutinee, arms } => Expr::Match { value: Box::new(lower_expr(*scrutinee)), arms: arms.into_iter().map(lower_arm).collect(), @@ -810,6 +1023,19 @@ fn lower_expr(expr: MlExpr) -> Expr { } } +fn lower_lambda_node(params: Vec, uncurried: bool, body: MlExpr, pos: Position) -> Expr { + let body = lower_expr(body); + if !uncurried { + return lower_lambda(params, body, pos); + } + Expr::Lambda { + parameters: flat_params(params), + return_type: None, + body: Box::new(body), + position: Some(pos), + } +} + /// Lower one `op param* => body` handle arm to the canonical [`HandlerArm`] — /// byte-identical to the Default handler arm ([FLAVOR-ML-EFFECT]). fn lower_handle_arm(arm: MlHandleArm) -> HandlerArm { @@ -938,10 +1164,8 @@ fn lower_application(func: MlExpr, arg: MlExpr) -> Expr { args.reverse(); let curried = match &head { MlExpr::Ident(name) => BOUND_NAMES.with(|s| s.borrow().contains(name)), - // A qualified callable's declaration lives outside this source file. - // Preserve ML's curry-by-default application spine; authors explicitly - // select a flat cross-flavor call with `(a, b)` ([FLAVOR-INTEROP]). - MlExpr::Path(_) => true, + // Qualified and higher-order callables preserve ML's curry-by-default + // spine; `(a, b)` explicitly selects a flat interop call. _ => true, }; if curried { diff --git a/crates/osprey-syntax/src/ml/mod.rs b/crates/osprey-syntax/src/ml/mod.rs index 24aab2fd..3ebdd49b 100644 --- a/crates/osprey-syntax/src/ml/mod.rs +++ b/crates/osprey-syntax/src/ml/mod.rs @@ -28,6 +28,9 @@ use crate::{Flavor, Parsed}; mod cst; mod lexer; mod lower; +mod module_lower; +mod module_parse; +mod modules; mod parser; mod token; diff --git a/crates/osprey-syntax/src/ml/module_lower.rs b/crates/osprey-syntax/src/ml/module_lower.rs new file mode 100644 index 00000000..528ec394 --- /dev/null +++ b/crates/osprey-syntax/src/ml/module_lower.rs @@ -0,0 +1,234 @@ +//! Canonical lowering for ML module bodies and named signatures +//! ([MODULES-MODEL], [MODULES-EXPORTS], [MODULES-SIGNATURE]). + +use super::cst::{MlItem, MlSignatureItem, MlType}; +use super::lower::{ + arrow_of, arrow_spine, attach_doc, lower_binding, lower_effect_op, lower_effect_ref, + lower_items, lower_type_param, render_type, type_expr, MlSig, +}; +use osprey_ast::{ + DocComment, DocScope, ModuleItem, SignatureAscription, SignatureItem, SignatureType, Stmt, + SymbolPath, TypeExpr, Visibility, +}; + +pub(super) fn module_items(items: Vec) -> Vec { + let mut state = ModuleLower::default(); + for item in items { + state.lower_item(item); + } + state.out +} + +#[derive(Default)] +struct ModuleLower { + out: Vec, + pending: Option<(MlSig, Visibility)>, + doc: Option, +} + +impl ModuleLower { + fn lower_item(&mut self, raw: MlItem) { + if let MlItem::Doc(text) = raw { + self.doc = Some(crate::docparse::parse_doc(&text, DocScope::Outer)); + return; + } + let (visibility, opaque, item) = item_metadata(raw); + match item { + MlItem::ValueSignature { + name, + type_params, + ty, + effects, + .. + } => self.pending = Some((MlSig::new(name, type_params, ty, effects), visibility)), + MlItem::Binding { + mutable, + name, + params, + uncurried, + body, + pos, + } => self.lower_binding_item( + visibility, opaque, mutable, name, params, uncurried, body, pos, + ), + other => self.lower_declaration(visibility, opaque, other), + } + } + + #[expect( + clippy::too_many_arguments, + reason = "faithful Binding CST destructuring before canonical construction" + )] + fn lower_binding_item( + &mut self, + visibility: Visibility, + opaque: bool, + mutable: bool, + name: String, + params: Vec, + uncurried: bool, + body: super::cst::MlExpr, + pos: osprey_ast::Position, + ) { + let paired = self.pending.take().filter(|(sig, _)| sig.name == name); + let visibility = paired + .as_ref() + .map_or(visibility, |(_, signed_visibility)| *signed_visibility); + let sig = paired.map(|(sig, _)| sig); + let stmt = lower_binding(mutable, name, params, uncurried, body, pos, sig); + let doc = self.doc.take(); + self.push(visibility, opaque, attach_doc(stmt, doc)); + } + + fn lower_declaration(&mut self, visibility: Visibility, opaque: bool, item: MlItem) { + self.pending = None; + for stmt in lower_items(vec![item]) { + let statement = attach_declaration_doc(stmt, self.doc.take()); + self.push(visibility, opaque, statement); + } + } + + fn push(&mut self, visibility: Visibility, opaque: bool, declaration: Stmt) { + self.out.push(ModuleItem { + visibility, + opaque, + declaration: Box::new(declaration), + }); + } +} + +fn item_metadata(item: MlItem) -> (Visibility, bool, MlItem) { + match item { + MlItem::Export { item, .. } => { + let (_, opaque, declaration) = item_metadata(*item); + (Visibility::Exported, opaque, declaration) + } + MlItem::Opaque { item, .. } => { + let (visibility, _, declaration) = item_metadata(*item); + (visibility, true, declaration) + } + declaration => (Visibility::Private, false, declaration), + } +} + +fn attach_declaration_doc(mut stmt: Stmt, doc: Option) -> Stmt { + match &mut stmt { + Stmt::Function { doc: slot, .. } + | Stmt::Let { doc: slot, .. } + | Stmt::Extern { doc: slot, .. } + | Stmt::Type { doc: slot, .. } + | Stmt::Effect { doc: slot, .. } + | Stmt::Module { doc: slot, .. } + | Stmt::Signature { doc: slot, .. } => *slot = doc, + _ => {} + } + stmt +} + +pub(super) fn signature_item(item: MlSignatureItem) -> SignatureItem { + match item { + MlSignatureItem::Value { + name, + type_params, + ty, + effects, + pos, + } => signature_value(name, type_params, &ty, effects, pos), + MlSignatureItem::Type { + name, + manifest, + pos, + } => signature_type(name, manifest, pos), + MlSignatureItem::Effect { + name, + type_params, + operations, + pos, + } => SignatureItem::Effect { + name, + type_params: type_params.into_iter().map(lower_type_param).collect(), + operations: operations.into_iter().map(lower_effect_op).collect(), + position: Some(pos), + }, + MlSignatureItem::Module { + name, + signature, + pos, + } => SignatureItem::Module { + path: SymbolPath::single(name), + signature: SignatureAscription { + path: SymbolPath { + segments: signature.segments, + }, + allow_extra: false, + }, + position: Some(pos), + }, + } +} + +fn signature_type( + name: String, + manifest: Option, + pos: osprey_ast::Position, +) -> SignatureItem { + let opaque = manifest.is_none(); + let definition = manifest.map_or(SignatureType::Abstract, |ty| { + SignatureType::Manifest(required_type(&ty)) + }); + SignatureItem::Type { + name, + type_params: Vec::new(), + definition, + opaque, + position: Some(pos), + } +} + +fn signature_value( + name: String, + type_params: Vec, + ty: &MlType, + effects: Vec, + pos: osprey_ast::Position, +) -> SignatureItem { + let spine = arrow_spine(ty); + if spine.len() < 2 { + return SignatureItem::Value { + name, + ty: required_type(ty), + position: Some(pos), + }; + } + let (parameters, return_type) = signature_function_parts(&spine); + SignatureItem::Function { + name, + type_params: type_params.into_iter().map(lower_type_param).collect(), + parameters, + return_type, + effects: effects.into_iter().map(lower_effect_ref).collect(), + position: Some(pos), + } +} + +fn signature_function_parts(spine: &[MlType]) -> (Vec, TypeExpr) { + match spine.split_first() { + Some((MlType::Tuple(parts), rest)) => ( + parts.iter().map(required_type).collect(), + arrow_of(rest).unwrap_or_else(|| TypeExpr::named("Unit")), + ), + Some((MlType::Name(name), rest)) if name == "Unit" => ( + Vec::new(), + arrow_of(rest).unwrap_or_else(|| TypeExpr::named("Unit")), + ), + Some((first, rest)) => ( + vec![required_type(first)], + arrow_of(rest).unwrap_or_else(|| TypeExpr::named("Unit")), + ), + None => (Vec::new(), TypeExpr::named("Unit")), + } +} + +pub(super) fn required_type(ty: &MlType) -> TypeExpr { + type_expr(ty).unwrap_or_else(|| TypeExpr::named(render_type(ty))) +} diff --git a/crates/osprey-syntax/src/ml/module_parse.rs b/crates/osprey-syntax/src/ml/module_parse.rs new file mode 100644 index 00000000..f0e80830 --- /dev/null +++ b/crates/osprey-syntax/src/ml/module_parse.rs @@ -0,0 +1,326 @@ +//! Layout-native ML parsing for namespaces, modules, signatures, exports, and +//! imports. Kept outside the expression parser to isolate [MODULES-*] syntax. + +use super::cst::{ + MlImport, MlImportMember, MlImportSelection, MlItem, MlModuleKind, MlNamespaceName, + MlSignatureItem, MlSymbolPath, +}; +use super::parser::Parser; +use super::token::TokKind; + +pub(super) fn import_decl(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + parser.advance(); + let namespace = namespace_name(parser)?; + let path = path_tail(parser); + let alias = parser.eat(&TokKind::KwAs).then(|| parser.ident()).flatten(); + let selection = parse_import_selection(parser, alias.is_some()); + Some(MlItem::Import { + import: MlImport { + namespace, + path, + alias, + selection, + }, + pos, + }) +} + +fn parse_import_selection(parser: &mut Parser<'_>, aliased: bool) -> MlImportSelection { + if !parser.eat(&TokKind::Indent) { + return MlImportSelection::Whole; + } + if aliased { + parser.error("an aliased whole import cannot also select members"); + } + import_selection(parser) +} + +fn import_selection(parser: &mut Parser<'_>) -> MlImportSelection { + parser.skip_separators(); + if matches!(parser.peek(), TokKind::Op(op) if op == "*") { + return wildcard_import(parser); + } + let members = import_members(parser); + let _ = parser.eat(&TokKind::Dedent); + MlImportSelection::Members(members) +} + +fn wildcard_import(parser: &mut Parser<'_>) -> MlImportSelection { + parser.advance(); + parser.skip_separators(); + if !parser.at_block_end() { + parser.error("wildcard import '*' must be the only selected member"); + parser.recover(); + } + let _ = parser.eat(&TokKind::Dedent); + MlImportSelection::Wildcard +} + +fn import_members(parser: &mut Parser<'_>) -> Vec { + let mut members = Vec::new(); + while !parser.at_block_end() { + parser.skip_separators(); + if parser.at_block_end() { + break; + } + if let Some(name) = parser.ident() { + let alias = parser.eat(&TokKind::KwAs).then(|| parser.ident()).flatten(); + members.push(MlImportMember { name, alias }); + } else { + parser.recover(); + } + } + members +} + +pub(super) fn namespace_decl(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + parser.advance(); + let name = namespace_name(parser)?; + let body = parser + .eat(&TokKind::Indent) + .then(|| items_until_dedent(parser)); + Some(MlItem::Namespace { name, body, pos }) +} + +pub(super) fn module_decl(parser: &mut Parser<'_>, kind: MlModuleKind) -> Option { + let pos = parser.pos(); + parser.advance(); + reject_redundant_module(parser, kind); + let path = symbol_path(parser)?; + let signature = parser + .eat(&TokKind::Colon) + .then(|| symbol_path(parser)) + .flatten(); + let body = module_body(parser); + Some(MlItem::Module { + path, + kind, + signature, + body, + pos, + }) +} + +fn reject_redundant_module(parser: &mut Parser<'_>, kind: MlModuleKind) { + if kind == MlModuleKind::State && parser.eat(&TokKind::KwModule) { + parser.error("ML state modules are written 'state Name', without redundant 'module'"); + } +} + +fn module_body(parser: &mut Parser<'_>) -> Vec { + if parser.eat(&TokKind::Indent) { + items_until_dedent(parser) + } else { + parser.error("module declaration requires an indented body"); + Vec::new() + } +} + +pub(super) fn signature_decl(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + parser.advance(); + let name = parser.ident()?; + let items = if parser.eat(&TokKind::Indent) { + signature_items(parser) + } else { + parser.error("signature declaration requires an indented body"); + Vec::new() + }; + Some(MlItem::ModuleSignature { name, items, pos }) +} + +fn signature_items(parser: &mut Parser<'_>) -> Vec { + let mut items = Vec::new(); + while !parser.at_block_end() { + parser.skip_separators(); + if parser.at_block_end() { + break; + } + match signature_item(parser) { + Some(item) => items.push(item), + None => parser.recover(), + } + } + let _ = parser.eat(&TokKind::Dedent); + items +} + +fn signature_item(parser: &mut Parser<'_>) -> Option { + match parser.peek() { + TokKind::Ident(_) => signature_value(parser), + TokKind::KwType => signature_type(parser), + TokKind::KwEffect => signature_effect(parser), + TokKind::KwModule => signature_module(parser), + TokKind::KwExport => redundant_signature_word( + parser, + "signature items are public by definition; remove redundant 'export'", + ), + TokKind::KwOpaque => redundant_signature_word( + parser, + "write 'type T' for an abstract ML signature type; 'opaque' is redundant", + ), + other => { + parser.error(format!("unexpected token {other:?} in signature")); + None + } + } +} + +fn redundant_signature_word( + parser: &mut Parser<'_>, + message: &'static str, +) -> Option { + parser.error(message); + None +} + +fn signature_value(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + let name = parser.ident()?; + let type_params = parser.signature_type_params(); + if !parser.eat(&TokKind::Colon) { + parser.error("expected ':' in signature value"); + } + let ty = parser.ty(); + let effects = parser.effect_row(); + Some(MlSignatureItem::Value { + name, + type_params, + ty, + effects, + pos, + }) +} + +fn signature_type(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + parser.advance(); + let name = parser.ident()?; + let manifest = parser.eat(&TokKind::Eq).then(|| parser.ty()); + Some(MlSignatureItem::Type { + name, + manifest, + pos, + }) +} + +fn signature_effect(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + parser.advance(); + let name = parser.ident()?; + let type_params = parser.type_params(); + let operations = parser.effect_operations(); + Some(MlSignatureItem::Effect { + name, + type_params, + operations, + pos, + }) +} + +fn signature_module(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + parser.advance(); + let name = parser.ident()?; + if !parser.eat(&TokKind::Colon) { + parser.error("expected ':' in nested module signature item"); + } + let signature = symbol_path(parser)?; + Some(MlSignatureItem::Module { + name, + signature, + pos, + }) +} + +pub(super) fn export_decl(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + parser.advance(); + if parser.eat(&TokKind::KwExport) { + parser.error_at(pos, "duplicate 'export' is redundant"); + } + let item = parser.item()?; + if !super::modules::is_exportable(&item) { + parser.error_at( + pos, + "'export' must modify a value, function, type, effect, extern, or module declaration", + ); + } + Some(MlItem::Export { + item: Box::new(item), + pos, + }) +} + +pub(super) fn opaque_decl(parser: &mut Parser<'_>) -> Option { + let pos = parser.pos(); + parser.advance(); + if !parser.eat(&TokKind::KwType) { + parser.error("'opaque' may modify only a type declaration"); + return None; + } + let item = parser.type_decl_after_keyword(pos)?; + Some(MlItem::Opaque { + item: Box::new(item), + pos, + }) +} + +fn items_until_dedent(parser: &mut Parser<'_>) -> Vec { + let mut items = Vec::new(); + while !parser.at_block_end() { + parser.skip_separators(); + if parser.at_block_end() { + break; + } + match parser.item() { + Some(item) => items.push(item), + None => parser.recover(), + } + } + let _ = parser.eat(&TokKind::Dedent); + items +} + +fn namespace_name(parser: &mut Parser<'_>) -> Option { + match parser.peek().clone() { + TokKind::Ident(name) => { + parser.advance(); + Some(MlNamespaceName::Ident(name)) + } + TokKind::Str(name) => { + parser.advance(); + Some(MlNamespaceName::Quoted(name)) + } + other => { + parser.error(format!("expected namespace name, found {other:?}")); + None + } + } +} + +fn symbol_path(parser: &mut Parser<'_>) -> Option { + let first = parser.ident()?; + let mut segments = vec![first]; + path_segments(parser, &mut segments); + Some(MlSymbolPath { segments }) +} + +fn path_tail(parser: &mut Parser<'_>) -> MlSymbolPath { + let mut segments = Vec::new(); + path_segments(parser, &mut segments); + MlSymbolPath { segments } +} + +fn path_segments(parser: &mut Parser<'_>, segments: &mut Vec) { + while parser.eat(&TokKind::ColonColon) { + if let Some(segment) = parser.ident() { + segments.push(segment); + } else { + parser.error("expected path segment after '::'"); + break; + } + } +} diff --git a/crates/osprey-syntax/src/ml/modules.rs b/crates/osprey-syntax/src/ml/modules.rs new file mode 100644 index 00000000..e83f86c9 --- /dev/null +++ b/crates/osprey-syntax/src/ml/modules.rs @@ -0,0 +1,143 @@ +//! Cross-item validation for the ML module surface. These checks need sibling +//! context but remain flavor-local, before canonical AST lowering. + +use super::cst::MlItem; +use crate::SyntaxError; +use osprey_ast::Position; + +pub(super) fn validate(items: &[MlItem], errors: &mut Vec) { + validate_items(items, None, errors); +} + +fn validate_items(items: &[MlItem], module_ascribed: Option, errors: &mut Vec) { + for (index, item) in items.iter().enumerate() { + match item { + MlItem::Namespace { + body: Some(body), .. + } => validate_items(body, None, errors), + MlItem::Module { + signature, body, .. + } => validate_items(body, Some(signature.is_some()), errors), + MlItem::Export { + item: exported, + pos, + } => validate_export(items, index, exported, *pos, module_ascribed, errors), + MlItem::Opaque { pos, .. } => push_error( + errors, + *pos, + "an opaque representation requires exactly one 'export opaque type' declaration", + ), + MlItem::ValueSignature { name, pos, .. } => { + validate_signature_follower(items, index, name, false, *pos, errors); + } + _ => {} + } + } +} + +fn validate_export( + items: &[MlItem], + index: usize, + exported: &MlItem, + pos: Position, + module_ascribed: Option, + errors: &mut Vec, +) { + validate_export_context(module_ascribed, pos, errors); + if matches!(exported, MlItem::Binding { mutable: true, .. }) { + push_error(errors, pos, "mutable cells cannot be exported"); + } + if let MlItem::ValueSignature { name, .. } = exported { + validate_signature_follower(items, index, name, true, pos, errors); + } + if let MlItem::Opaque { item, .. } = exported { + if !matches!(item.as_ref(), MlItem::Type { .. }) { + push_error( + errors, + pos, + "'opaque' may modify only an exported type declaration", + ); + } + } +} + +fn validate_export_context( + module_ascribed: Option, + pos: Position, + errors: &mut Vec, +) { + match module_ascribed { + None => push_error( + errors, + pos, + "namespace declarations are public by default; 'export' is valid only inside an un-ascribed module", + ), + Some(true) => push_error( + errors, + pos, + "an ascribed module exports exactly its signature; remove redundant 'export'", + ), + Some(false) => {} + } +} + +fn validate_signature_follower( + items: &[MlItem], + index: usize, + name: &str, + exported_signature: bool, + pos: Position, + errors: &mut Vec, +) { + let follower = items.get(index.saturating_add(1)); + if is_matching_bare(follower, name) { + return; + } + let message = signature_error(follower, name, exported_signature); + push_error(errors, pos, message); +} + +fn is_matching_bare(follower: Option<&MlItem>, name: &str) -> bool { + matches!( + follower, + Some(MlItem::Binding { + name: following, + .. + }) if following == name + ) +} + +fn signature_error(follower: Option<&MlItem>, name: &str, exported: bool) -> String { + let double = matches!( + follower, + Some(MlItem::Export { item, .. }) + if matches!(item.as_ref(), MlItem::Binding { name: following, .. } if following == name) + ); + if exported && double { + format!( + "'{name}' is already exported by its signature; remove 'export' from the definition" + ) + } else { + format!("signature for '{name}' must be immediately followed by its bare definition") + } +} + +fn push_error(errors: &mut Vec, position: Position, message: impl Into) { + errors.push(SyntaxError { + message: message.into(), + position, + }); +} + +pub(super) fn is_exportable(item: &MlItem) -> bool { + matches!( + item, + MlItem::Binding { .. } + | MlItem::ValueSignature { .. } + | MlItem::Type { .. } + | MlItem::Effect { .. } + | MlItem::Extern { .. } + | MlItem::Module { .. } + | MlItem::Opaque { .. } + ) +} diff --git a/crates/osprey-syntax/src/ml/parser.rs b/crates/osprey-syntax/src/ml/parser.rs index e5bc56f4..b6f913b4 100644 --- a/crates/osprey-syntax/src/ml/parser.rs +++ b/crates/osprey-syntax/src/ml/parser.rs @@ -37,9 +37,9 @@ //! concrete authoritative spec of layout-driven token insertion. use super::cst::{ - MlArm, MlEffectOp, MlEffectRef, MlExpr, MlExternParam, MlField, MlHandleArm, MlImport, - MlImportMember, MlImportSelection, MlItem, MlModuleKind, MlNamespaceName, MlParam, MlPattern, - MlSignatureItem, MlSymbolPath, MlType, MlTypeField, MlTypeParam, MlVariance, MlVariant, + MlArm, MlEffectOp, MlEffectRef, MlExpr, MlExternParam, MlField, MlHandleArm, MlItem, + MlModuleKind, MlParam, MlPattern, MlSymbolPath, MlType, MlTypeField, MlTypeParam, MlVariance, + MlVariant, }; use super::lexer::lex; use super::token::{TokKind, Token}; @@ -58,7 +58,7 @@ pub(crate) fn parse(source: &str) -> (Vec, Vec) { }; parser.program() }; - validate_module_items(&items, None, &mut errors); + super::modules::validate(&items, &mut errors); (items, errors) } @@ -85,14 +85,14 @@ fn infix_bp(op: &str) -> Option { } /// Recursive-descent + Pratt parser over the layout-resolved token slice. -struct Parser<'t> { +pub(super) struct Parser<'t> { toks: &'t [Token], i: usize, errors: &'t mut Vec, } impl Parser<'_> { - fn peek(&self) -> &TokKind { + pub(super) fn peek(&self) -> &TokKind { self.toks.get(self.i).map_or(&TokKind::Eof, |t| &t.kind) } @@ -102,19 +102,19 @@ impl Parser<'_> { .map_or(&TokKind::Eof, |t| &t.kind) } - fn pos(&self) -> Position { + pub(super) fn pos(&self) -> Position { self.toks.get(self.i).map_or(Position::default(), |t| t.pos) } /// Consume the current token, discarding it (callers peek first when they /// need its payload). - fn advance(&mut self) { + pub(super) fn advance(&mut self) { if self.i < self.toks.len() { self.i += 1; } } - fn eat(&mut self, kind: &TokKind) -> bool { + pub(super) fn eat(&mut self, kind: &TokKind) -> bool { if self.peek() == kind { self.i += 1; true @@ -123,12 +123,12 @@ impl Parser<'_> { } } - fn error(&mut self, message: impl Into) { + pub(super) fn error(&mut self, message: impl Into) { let position = self.pos(); self.error_at(position, message); } - fn error_at(&mut self, position: Position, message: impl Into) { + pub(super) fn error_at(&mut self, position: Position, message: impl Into) { self.errors.push(SyntaxError { message: message.into(), position, @@ -137,7 +137,7 @@ impl Parser<'_> { /// Panic-mode recovery (Dragon Book §4.1.4): drop tokens up to the next /// statement separator so one bad line cannot derail the rest. - fn recover(&mut self) { + pub(super) fn recover(&mut self) { while !matches!( self.peek(), TokKind::Newline | TokKind::Dedent | TokKind::Eof @@ -146,13 +146,13 @@ impl Parser<'_> { } } - fn skip_separators(&mut self) { + pub(super) fn skip_separators(&mut self) { while matches!(self.peek(), TokKind::Newline) { self.i += 1; } } - fn at_block_end(&self) -> bool { + pub(super) fn at_block_end(&self) -> bool { matches!(self.peek(), TokKind::Dedent | TokKind::Eof) } @@ -175,7 +175,7 @@ impl Parser<'_> { /// Parse one item, or `None` for a skipped signature line or a recoverable /// error. - fn item(&mut self) -> Option { + pub(super) fn item(&mut self) -> Option { match self.peek() { TokKind::Doc(text) => { let text = text.clone(); @@ -210,344 +210,34 @@ impl Parser<'_> { /// member projection ([MODULES-IMPORT]). ML uses layout instead of Default's /// punctuation-heavy `::{...}` member list. fn import_decl(&mut self) -> Option { - let pos = self.pos(); - self.advance(); // `import` - let namespace = self.namespace_name()?; - let path = self.path_tail(); - let alias = if self.eat(&TokKind::KwAs) { - self.ident() - } else { - None - }; - let selection = if self.eat(&TokKind::Indent) { - if alias.is_some() { - self.error("an aliased whole import cannot also select members"); - } - self.import_selection() - } else { - MlImportSelection::Whole - }; - Some(MlItem::Import { - import: MlImport { - namespace, - path, - alias, - selection, - }, - pos, - }) - } - - /// Parse the indented lines below an import. `*` must be the sole line; - /// named members may each carry one `as Alias`. - fn import_selection(&mut self) -> MlImportSelection { - self.skip_separators(); - if matches!(self.peek(), TokKind::Op(op) if op == "*") { - self.advance(); - self.skip_separators(); - if !matches!(self.peek(), TokKind::Dedent | TokKind::Eof) { - self.error("wildcard import '*' must be the only selected member"); - self.recover(); - } - let _ = self.eat(&TokKind::Dedent); - return MlImportSelection::Wildcard; - } - let mut members = Vec::new(); - while !self.at_block_end() { - self.skip_separators(); - if self.at_block_end() { - break; - } - let before = self.i; - if let Some(name) = self.ident() { - let alias = if self.eat(&TokKind::KwAs) { - self.ident() - } else { - None - }; - members.push(MlImportMember { name, alias }); - } else { - self.recover(); - } - if self.i == before { - self.recover(); - } - } - let _ = self.eat(&TokKind::Dedent); - MlImportSelection::Members(members) + super::module_parse::import_decl(self) } /// `namespace name`: an indented body is a block contribution; without one /// the declaration applies to subsequent declarations in the file /// ([MODULES-FILE-SCOPED-NAMESPACE]). fn namespace_decl(&mut self) -> Option { - let pos = self.pos(); - self.advance(); // `namespace` - let name = self.namespace_name()?; - let body = if self.eat(&TokKind::Indent) { - Some(self.items_until_dedent()) - } else { - None - }; - Some(MlItem::Namespace { name, body, pos }) + super::module_parse::namespace_decl(self) } /// A layout module head. ML deliberately spells a state module `state Name` /// rather than the redundant `state module Name` ([MODULES-STATE-MODULE]). fn module_decl(&mut self, kind: MlModuleKind) -> Option { - let pos = self.pos(); - self.advance(); // `module` / `state` - if kind == MlModuleKind::State && matches!(self.peek(), TokKind::KwModule) { - self.error("ML state modules are written 'state Name', without redundant 'module'"); - self.advance(); - } - let path = self.symbol_path()?; - let signature = if self.eat(&TokKind::Colon) { - self.symbol_path() - } else { - None - }; - if !self.eat(&TokKind::Indent) { - self.error("module declaration requires an indented body"); - return Some(MlItem::Module { - path, - kind, - signature, - body: Vec::new(), - pos, - }); - } - let body = self.items_until_dedent(); - Some(MlItem::Module { - path, - kind, - signature, - body, - pos, - }) + super::module_parse::module_decl(self, kind) } /// `signature Name` plus its public, export-free interface requirements. fn module_signature_decl(&mut self) -> Option { - let pos = self.pos(); - self.advance(); // `signature` - let name = self.ident()?; - if !self.eat(&TokKind::Indent) { - self.error("signature declaration requires an indented body"); - return Some(MlItem::ModuleSignature { - name, - items: Vec::new(), - pos, - }); - } - let items = self.signature_items(); - Some(MlItem::ModuleSignature { name, items, pos }) - } - - fn signature_items(&mut self) -> Vec { - let mut items = Vec::new(); - loop { - self.skip_separators(); - if self.at_block_end() { - break; - } - let before = self.i; - match self.signature_item() { - Some(item) => items.push(item), - None => self.recover(), - } - if self.i == before { - self.recover(); - } - } - let _ = self.eat(&TokKind::Dedent); - items - } - - fn signature_item(&mut self) -> Option { - match self.peek() { - TokKind::Ident(_) => self.signature_value_item(), - TokKind::KwType => self.signature_type_item(), - TokKind::KwEffect => self.signature_effect_item(), - TokKind::KwModule => self.signature_module_item(), - TokKind::KwExport => { - self.error("signature items are public by definition; remove redundant 'export'"); - None - } - TokKind::KwOpaque => { - self.error("write 'type T' for an abstract ML signature type; 'opaque' is redundant"); - None - } - other => { - self.error(format!("unexpected token {other:?} in signature")); - None - } - } - } - - fn signature_value_item(&mut self) -> Option { - let pos = self.pos(); - let name = self.ident()?; - let type_params = self.signature_type_params(); - if !self.eat(&TokKind::Colon) { - self.error("expected ':' in signature value"); - } - let ty = self.ty(); - let effects = self.effect_row(); - Some(MlSignatureItem::Value { - name, - type_params, - ty, - effects, - pos, - }) - } - - fn signature_type_item(&mut self) -> Option { - let pos = self.pos(); - self.advance(); // `type` - let name = self.ident()?; - let manifest = if self.eat(&TokKind::Eq) { - Some(self.ty()) - } else { - None - }; - Some(MlSignatureItem::Type { - name, - manifest, - pos, - }) - } - - fn signature_effect_item(&mut self) -> Option { - let pos = self.pos(); - self.advance(); // `effect` - let name = self.ident()?; - let type_params = self.type_params(); - let operations = self.effect_operations(); - Some(MlSignatureItem::Effect { - name, - type_params, - operations, - pos, - }) - } - - fn signature_module_item(&mut self) -> Option { - let pos = self.pos(); - self.advance(); // `module` - let name = self.ident()?; - if !self.eat(&TokKind::Colon) { - self.error("expected ':' in nested module signature item"); - } - let signature = self.symbol_path()?; - Some(MlSignatureItem::Module { - name, - signature, - pos, - }) + super::module_parse::signature_decl(self) } /// Wrap exactly one following declaration in explicit visibility metadata. fn export_decl(&mut self) -> Option { - let pos = self.pos(); - self.advance(); // `export` - if self.eat(&TokKind::KwExport) { - self.error_at(pos, "duplicate 'export' is redundant"); - } - let item = self.item()?; - if !is_exportable(&item) { - self.error_at(pos, "'export' must modify a value, function, type, effect, extern, or module declaration"); - } - Some(MlItem::Export { - item: Box::new(item), - pos, - }) + super::module_parse::export_decl(self) } fn opaque_decl(&mut self) -> Option { - let pos = self.pos(); - self.advance(); // `opaque` - if !self.eat(&TokKind::KwType) { - self.error("'opaque' may modify only a type declaration"); - return None; - } - let item = self.type_decl_after_keyword(pos)?; - Some(MlItem::Opaque { - item: Box::new(item), - pos, - }) - } - - /// Parse declarations until the matching `Dedent`. Unlike expression block - /// parsing, module/namespace bodies do not reinterpret the final expression - /// as a trailing block value. - fn items_until_dedent(&mut self) -> Vec { - let mut items = Vec::new(); - loop { - self.skip_separators(); - if self.at_block_end() { - break; - } - let before = self.i; - match self.item() { - Some(item) => items.push(item), - None => self.recover(), - } - if self.i == before { - self.recover(); - } - } - let _ = self.eat(&TokKind::Dedent); - items - } - - fn namespace_name(&mut self) -> Option { - match self.peek().clone() { - TokKind::Ident(name) => { - self.advance(); - Some(MlNamespaceName::Ident(name)) - } - TokKind::Str(name) => { - self.advance(); - Some(MlNamespaceName::Quoted(name)) - } - other => { - self.error(format!("expected namespace name, found {other:?}")); - None - } - } - } - - fn symbol_path(&mut self) -> Option { - let first = self.ident()?; - let mut path = MlSymbolPath { - segments: vec![first], - }; - while self.eat(&TokKind::ColonColon) { - if let Some(segment) = self.ident() { - path.segments.push(segment); - } else { - self.error("expected path segment after '::'"); - break; - } - } - Some(path) - } - - /// Continue an import target after its namespace label. The first namespace - /// component is deliberately stored separately from the module path. - fn path_tail(&mut self) -> MlSymbolPath { - let mut segments = Vec::new(); - while self.eat(&TokKind::ColonColon) { - if let Some(segment) = self.ident() { - segments.push(segment); - } else { - self.error("expected import path segment after '::'"); - break; - } - } - MlSymbolPath { segments } + super::module_parse::opaque_decl(self) } /// `mut name = body` → a mutable binding. @@ -580,15 +270,20 @@ impl Parser<'_> { /// Finish a type declaration after its `type` token has already been /// consumed (also reused by `opaque type`). - fn type_decl_after_keyword(&mut self, pos: Position) -> Option { + pub(super) fn type_decl_after_keyword(&mut self, pos: Position) -> Option { let name = self.ident()?; let type_params = self.type_params(); let _ = self.expect_eq(); - let variants = self.type_body(&name); + let (variants, alias) = match self.peek() { + TokKind::Indent => (self.type_body(&name), None), + TokKind::Newline | TokKind::Dedent | TokKind::Eof => (Vec::new(), None), + _ => (Vec::new(), Some(self.ty())), + }; Some(MlItem::Type { name, type_params, variants, + alias, pos, }) } @@ -599,7 +294,7 @@ impl Parser<'_> { /// contextual keywords reserved inside type-parameter position in BOTH /// flavors — a marker must be followed by a parameter name. Implements /// [TYPE-VARIANCE-DECL]. - fn type_params(&mut self) -> Vec { + pub(super) fn type_params(&mut self) -> Vec { let mut out = Vec::new(); loop { let variance = match self.peek() { @@ -781,7 +476,7 @@ impl Parser<'_> { } /// The indented `op : P => R` operation lines of an `effect` block. - fn effect_operations(&mut self) -> Vec { + pub(super) fn effect_operations(&mut self) -> Vec { let mut operations = Vec::new(); if !self.eat(&TokKind::Indent) { return operations; @@ -869,7 +564,7 @@ impl Parser<'_> { /// The `` binder of a generic signature. The caller has already /// validated the whole shape via [`Self::at_generic_signature`], so this /// only consumes: `<`, comma-separated parameter groups, `>`. - fn signature_type_params(&mut self) -> Vec { + pub(super) fn signature_type_params(&mut self) -> Vec { if !matches!(self.peek(), TokKind::Op(op) if op == "<") { return Vec::new(); } @@ -918,7 +613,7 @@ impl Parser<'_> { /// bracketed `! [Ref, …]`, each reference optionally applied to type /// arguments (`State`). Empty when no `!` is present /// ([FLAVOR-ML-EFFECT], [EFFECTS-GENERIC-ROWS]). - fn effect_row(&mut self) -> Vec { + pub(super) fn effect_row(&mut self) -> Vec { if !matches!(self.peek(), TokKind::Op(op) if op == "!") { return Vec::new(); } @@ -957,7 +652,7 @@ impl Parser<'_> { } /// A type: arrows are right-associative (`a -> b -> c` = `a -> (b -> c)`). - fn ty(&mut self) -> MlType { + pub(super) fn ty(&mut self) -> MlType { let from = self.ty_app(); if self.eat(&TokKind::Arrow) { return MlType::Arrow { @@ -2016,7 +1711,7 @@ impl Parser<'_> { } } - fn ident(&mut self) -> Option { + pub(super) fn ident(&mut self) -> Option { if let TokKind::Ident(name) = self.peek() { let name = name.clone(); self.advance(); @@ -2053,127 +1748,6 @@ impl Parser<'_> { } } -/// Validate declaration-group rules which need sibling context. Keeping this -/// pass over the faithful CST makes the parser routines small while still -/// rejecting redundancy before canonical lowering ([MODULES-EXPORTS]). -fn validate_module_items( - items: &[MlItem], - module_ascribed: Option, - errors: &mut Vec, -) { - for (index, item) in items.iter().enumerate() { - match item { - MlItem::Namespace { - body: Some(body), .. - } => validate_module_items(body, None, errors), - MlItem::Namespace { body: None, .. } => {} - MlItem::Module { - signature, body, .. - } => validate_module_items(body, Some(signature.is_some()), errors), - MlItem::Export { - item: exported, - pos, - } => { - match module_ascribed { - None => push_validation_error( - errors, - *pos, - "namespace declarations are public by default; 'export' is valid only inside an un-ascribed module", - ), - Some(true) => push_validation_error( - errors, - *pos, - "an ascribed module exports exactly its signature; remove redundant 'export'", - ), - Some(false) => {} - } - if matches!(exported.as_ref(), MlItem::Binding { mutable: true, .. }) { - push_validation_error(errors, *pos, "mutable cells cannot be exported"); - } - if let MlItem::ValueSignature { name, .. } = exported.as_ref() { - validate_signature_follower(items, index, name, true, *pos, errors); - } - if let MlItem::Opaque { item, .. } = exported.as_ref() { - if !matches!(item.as_ref(), MlItem::Type { .. }) { - push_validation_error( - errors, - *pos, - "'opaque' may modify only an exported type declaration", - ); - } - } - } - MlItem::Opaque { pos, .. } => push_validation_error( - errors, - *pos, - "an opaque representation requires exactly one 'export opaque type' declaration", - ), - MlItem::ValueSignature { name, pos, .. } => { - validate_signature_follower(items, index, name, false, *pos, errors); - } - _ => {} - } - } -} - -fn validate_signature_follower( - items: &[MlItem], - index: usize, - name: &str, - exported_signature: bool, - pos: Position, - errors: &mut Vec, -) { - let follower = items.get(index.saturating_add(1)); - let matching_bare = matches!( - follower, - Some(MlItem::Binding { - name: following, - .. - }) if following == name - ); - if matching_bare { - return; - } - let matching_exported = matches!( - follower, - Some(MlItem::Export { item, .. }) - if matches!(item.as_ref(), MlItem::Binding { name: following, .. } if following == name) - ); - let message = if exported_signature && matching_exported { - format!( - "'{name}' is already exported by its signature; remove 'export' from the definition" - ) - } else { - format!("signature for '{name}' must be immediately followed by its bare definition") - }; - push_validation_error(errors, pos, message); -} - -fn push_validation_error( - errors: &mut Vec, - position: Position, - message: impl Into, -) { - errors.push(SyntaxError { - message: message.into(), - position, - }); -} - -fn is_exportable(item: &MlItem) -> bool { - matches!( - item, - MlItem::Binding { .. } - | MlItem::ValueSignature { .. } - | MlItem::Type { .. } - | MlItem::Effect { .. } - | MlItem::Extern { .. } - | MlItem::Module { .. } - | MlItem::Opaque { .. } - ) -} - /// An uppercase initial marks a constructor/type name; lowercase marks a value /// binding or variable, mirroring the Default flavor's lexical convention. fn is_constructor(name: &str) -> bool { diff --git a/crates/osprey-syntax/tests/ml_coverage.rs b/crates/osprey-syntax/tests/ml_coverage.rs index 903d2975..7b6bd422 100644 --- a/crates/osprey-syntax/tests/ml_coverage.rs +++ b/crates/osprey-syntax/tests/ml_coverage.rs @@ -810,16 +810,16 @@ fn empty_interpolation_fragment_falls_back_to_an_identifier() { } #[test] -fn orphan_signature_without_a_matching_binding_is_dropped() { - // A signature whose name does not match the next binding is discarded, and - // the following binding still lowers cleanly (untyped). - match ml_one("foo : int\nbar = 1\n") { - Stmt::Let { name, ty, .. } => { - assert_eq!(name, "bar"); - assert!(ty.is_none()); - } - other => panic!("expected a let, got {other:?}"), - } +fn orphan_signature_without_a_matching_binding_is_rejected() { + let parsed = ml_err("foo : int\nbar = 1\n"); + assert!( + parsed + .errors + .iter() + .any(|error| error.message.contains("immediately followed")), + "errors: {:?}", + parsed.errors + ); } // ---- generics, variance, and generic effects ([FLAVOR-ML-GENERICS]) ---- diff --git a/crates/osprey-syntax/tests/ml_modules.rs b/crates/osprey-syntax/tests/ml_modules.rs new file mode 100644 index 00000000..377a3391 --- /dev/null +++ b/crates/osprey-syntax/tests/ml_modules.rs @@ -0,0 +1,280 @@ +//! ML module-surface coverage for [MODULES-NAMESPACE], [MODULES-MODULE], +//! [MODULES-SIGNATURE], [MODULES-EXPORTS], and [MODULES-IMPORT]. +#![expect( + clippy::indexing_slicing, + reason = "test assertions: malformed AST indexing is a test failure" +)] + +use osprey_ast::{ + Expr, ImportSelection, ModuleKind, NamespaceName, SignatureItem, SignatureType, Stmt, + Visibility, +}; +use osprey_syntax::{parse_program_with_flavor, Flavor, Parsed}; + +fn parse(src: &str) -> Parsed { + parse_program_with_flavor(src, Flavor::Ml) +} + +fn ok(src: &str) -> Vec { + let parsed = parse(src); + assert!(parsed.errors.is_empty(), "errors: {:?}", parsed.errors); + parsed.program.statements +} + +fn errors(src: &str) -> Vec { + let parsed = parse(src); + assert!(!parsed.errors.is_empty(), "expected errors: {parsed:#?}"); + parsed + .errors + .into_iter() + .map(|error| error.message) + .collect() +} + +#[test] +fn file_scoped_namespace_owns_following_declarations() { + let statements = ok("namespace billing\nanswer = 42\n"); + match &statements[0] { + Stmt::Namespace { + name, + body, + file_scoped, + .. + } => { + assert_eq!(name, &NamespaceName::Identifier("billing".to_owned())); + assert!(*file_scoped); + assert!(matches!(&body[0], Stmt::Let { name, .. } if name == "answer")); + } + other => panic!("expected namespace, got {other:?}"), + } +} + +#[test] +fn indented_namespace_is_a_block_contribution() { + let statements = ok("namespace billing\n inside = 1\noutside = 2\n"); + assert_eq!(statements.len(), 2); + match &statements[0] { + Stmt::Namespace { + body, file_scoped, .. + } => { + assert!(!file_scoped); + assert!(matches!(&body[0], Stmt::Let { name, .. } if name == "inside")); + } + other => panic!("expected namespace, got {other:?}"), + } +} + +#[test] +fn signature_and_ascribed_module_have_no_redundant_exports() { + let src = "signature TaxApi\n addTax : int -> int\n\nmodule Tax : TaxApi\n rate = 10\n addTax cents = cents + rate\n"; + let statements = ok(src); + assert!(matches!(&statements[0], Stmt::Signature { name, .. } if name == "TaxApi")); + match &statements[1] { + Stmt::Module { + kind, + signature, + body, + .. + } => { + assert_eq!(*kind, ModuleKind::Plain); + assert_eq!( + signature + .as_ref() + .map(|sig| sig.path.to_string()) + .as_deref(), + Some("TaxApi") + ); + assert!(body + .iter() + .all(|item| item.visibility == Visibility::Private)); + } + other => panic!("expected module, got {other:?}"), + } +} + +#[test] +fn state_is_the_complete_ml_state_module_head() { + let statements = ok("state Counter\n mut count = 0\n"); + match &statements[0] { + Stmt::Module { kind, body, .. } => { + assert_eq!(*kind, ModuleKind::State); + assert!(matches!( + body[0].declaration.as_ref(), + Stmt::Let { mutable: true, .. } + )); + } + other => panic!("expected state module, got {other:?}"), + } +} + +#[test] +fn exported_annotation_propagates_to_one_bare_definition() { + let statements = ok("module Tax\n export addTax : int -> int\n addTax cents = cents\n"); + match &statements[0] { + Stmt::Module { body, .. } => { + assert_eq!(body.len(), 1); + assert_eq!(body[0].visibility, Visibility::Exported); + assert!( + matches!(body[0].declaration.as_ref(), Stmt::Function { name, .. } if name == "addTax") + ); + } + other => panic!("expected module, got {other:?}"), + } +} + +#[test] +fn unsigned_definition_can_be_exported_once() { + let statements = ok("module Tax\n export addTax cents = cents\n"); + match &statements[0] { + Stmt::Module { body, .. } => assert_eq!(body[0].visibility, Visibility::Exported), + other => panic!("expected module, got {other:?}"), + } +} + +#[test] +fn redundancy_and_mutable_exports_are_rejected() { + let double = + errors("module Tax\n export addTax : int -> int\n export addTax cents = cents\n"); + assert!(double + .iter() + .any(|error| error.contains("already exported"))); + + let ascribed = errors("module Tax : Api\n export x = 1\n"); + assert!(ascribed + .iter() + .any(|error| error.contains("exactly its signature"))); + + let mutable = errors("state Store\n export mut count = 0\n"); + assert!(mutable + .iter() + .any(|error| error.contains("cannot be exported"))); +} + +#[test] +fn orphan_and_redundant_signature_markers_are_rejected() { + let orphan = errors("module Tax\n f : int -> int\n g x = x\n"); + assert!(orphan + .iter() + .any(|error| error.contains("immediately followed"))); + + let exported = errors("signature Api\n export f : int -> int\n"); + assert!(exported + .iter() + .any(|error| error.contains("public by definition"))); + + let opaque = errors("signature Api\n opaque type T\n"); + assert!(opaque.iter().any(|error| error.contains("redundant"))); +} + +#[test] +fn redundant_state_module_spelling_is_rejected() { + let found = errors("state module Store\n x = 1\n"); + assert!(found + .iter() + .any(|error| error.contains("without redundant 'module'"))); +} + +#[test] +fn signature_abstract_and_manifest_types_lower_distinctly() { + let statements = ok("signature Ids\n type UserId\n type Raw = int\n"); + match &statements[0] { + Stmt::Signature { items, .. } => { + assert!(matches!( + &items[0], + SignatureItem::Type { + definition: SignatureType::Abstract, + opaque: true, + .. + } + )); + assert!(matches!( + &items[1], + SignatureItem::Type { + definition: SignatureType::Manifest(_), + opaque: false, + .. + } + )); + } + other => panic!("expected signature, got {other:?}"), + } +} + +#[test] +fn opaque_export_retains_private_representation_metadata() { + let statements = ok("module Ids\n export opaque type UserId = int\n"); + match &statements[0] { + Stmt::Module { body, .. } => { + assert_eq!(body[0].visibility, Visibility::Exported); + assert!(body[0].opaque); + assert!(matches!( + body[0].declaration.as_ref(), + Stmt::Type { alias: Some(_), .. } + )); + } + other => panic!("expected module, got {other:?}"), + } +} + +#[test] +fn whole_alias_member_and_wildcard_imports_lower() { + let src = "import billing::Tax\nimport billing::Tax as T\nimport billing::Tax\n addTax\n zero as noTax\nimport billing::Tax\n *\n"; + let statements = ok(src); + assert_eq!(statements.len(), 4); + assert!( + matches!(&statements[0], Stmt::Import(import) if import.selection == ImportSelection::Whole) + ); + assert!(matches!(&statements[1], Stmt::Import(import) if import.alias.as_deref() == Some("T"))); + assert!( + matches!(&statements[2], Stmt::Import(import) if matches!(&import.selection, ImportSelection::Members(items) if items.len() == 2)) + ); + assert!( + matches!(&statements[3], Stmt::Import(import) if import.selection == ImportSelection::Wildcard) + ); +} + +#[test] +fn quoted_namespace_import_preserves_opaque_label() { + let statements = ok("import \"billing/api\" as api\n"); + assert!(matches!( + &statements[0], + Stmt::Import(import) + if import.target.namespace == NamespaceName::Quoted("billing/api".to_owned()) + && import.alias.as_deref() == Some("api") + )); +} + +#[test] +fn qualification_is_not_value_field_access_and_stays_curried() { + let statements = ok("gross = Tax::addTax 100 2\nfield = invoice.total\n"); + match &statements[0] { + Stmt::Let { value, .. } => match value { + Expr::Call { function, .. } => { + assert!( + matches!(function.as_ref(), Expr::Call { function, .. } if matches!(function.as_ref(), Expr::Path(_))) + ); + } + other => panic!("expected nested curried call, got {other:?}"), + }, + other => panic!("expected let, got {other:?}"), + } + assert!(matches!( + &statements[1], + Stmt::Let { + value: Expr::FieldAccess { .. }, + .. + } + )); +} + +#[test] +fn parenthesised_cross_flavor_call_is_flat() { + let statements = ok("gross = Tax::addTax (100, 2)\n"); + assert!(matches!( + &statements[0], + Stmt::Let { + value: Expr::Call { arguments, .. }, + .. + } if arguments.len() == 2 + )); +} diff --git a/crates/osprey-syntax/tests/module_equiv.rs b/crates/osprey-syntax/tests/module_equiv.rs new file mode 100644 index 00000000..fb3b7643 --- /dev/null +++ b/crates/osprey-syntax/tests/module_equiv.rs @@ -0,0 +1,150 @@ +//! Cross-flavor canonical-AST contracts for [MODULES-FLAVOR-PROJECTION]. + +use osprey_syntax::{parse_program_with_flavor, Flavor}; + +fn canonical(source: &str, flavor: Flavor) -> String { + let parsed = parse_program_with_flavor(source, flavor); + assert!( + parsed.errors.is_empty(), + "{flavor} syntax errors: {:?}", + parsed.errors + ); + scrub_positions(&format!("{:?}", parsed.program)) +} + +fn scrub_positions(debug: &str) -> String { + let mut out = String::with_capacity(debug.len()); + let mut rest = debug; + while let Some(start) = rest.find("Position {") { + out.push_str(&rest[..start]); + rest = &rest[start..]; + match rest.find('}') { + Some(end) => rest = &rest[end.saturating_add(1)..], + None => break, + } + } + out.push_str(rest); + out.replace("position: Some()", "position: None") +} + +fn assert_equivalent(default: &str, ml: &str) { + assert_eq!( + canonical(default, Flavor::Default), + canonical(ml, Flavor::Ml) + ); +} + +#[test] +fn file_namespace_and_explicit_export_module_are_equivalent() { + let default = concat!( + "namespace billing;\n", + "module Tax {\n", + " export fn addTax(cents) = cents\n", + "}\n", + ); + let ml = concat!( + "namespace billing\n", + "module Tax\n", + " export addTax cents = cents\n", + ); + assert_equivalent(default, ml); +} + +#[test] +fn ascribed_signature_module_needs_no_redundant_ml_export() { + let default = concat!( + "signature TaxApi {\n", + " fn addTax(cents: int) -> int\n", + "}\n", + "module Tax : TaxApi {\n", + " fn addTax(cents) = cents\n", + "}\n", + ); + let ml = concat!( + "signature TaxApi\n", + " addTax : int -> int\n", + "module Tax : TaxApi\n", + " addTax cents = cents\n", + ); + assert_equivalent(default, ml); +} + +#[test] +fn state_module_shapes_are_equivalent_without_redundant_ml_module() { + let default = concat!( + "state module Counter {\n", + " mut count = 0\n", + " export effect CounterFx { read: fn() -> int }\n", + " export fn run(action) =\n", + " handle CounterFx read => count in action()\n", + "}\n", + ); + let ml = concat!( + "state Counter\n", + " mut count = 0\n", + " export effect CounterFx\n", + " read : Unit => int\n", + " export run action =\n", + " handle CounterFx\n", + " read => count\n", + " in\n", + " action ()\n", + ); + assert_equivalent(default, ml); +} + +#[test] +fn whole_alias_and_member_imports_are_equivalent() { + let default = concat!( + "import billing::Tax\n", + "import billing::Tax as T\n", + "import billing::Tax::{addTax, zero as noTax}\n", + ); + let ml = concat!( + "import billing::Tax\n", + "import billing::Tax as T\n", + "import billing::Tax\n", + " addTax\n", + " zero as noTax\n", + ); + assert_equivalent(default, ml); +} + +#[test] +fn qualified_uncurried_calls_are_equivalent() { + let default = "let gross = Tax::addTax(100, 2)\n"; + let ml = "gross = Tax::addTax (100, 2)\n"; + assert_equivalent(default, ml); +} + +#[test] +fn qualified_curried_calls_are_equivalent() { + let default = "let gross = Tax::addTax(100)(2)\n"; + let ml = "gross = Tax::addTax 100 2\n"; + assert_equivalent(default, ml); +} + +#[test] +fn unit_arrow_domains_are_zero_arity_even_when_nested() { + let default = concat!( + "signature RunnerApi {\n", + " fn tick() -> int\n", + " fn run(action: fn() -> int) -> int\n", + "}\n", + "module Runner : RunnerApi {\n", + " fn tick() -> int = 1\n", + " fn run(action: fn() -> int) -> int = action()\n", + "}\n", + ); + let ml = concat!( + "signature RunnerApi\n", + " tick : Unit -> int\n", + " run : (Unit -> int) -> int\n", + "module Runner : RunnerApi\n", + " tick : Unit -> int\n", + " tick () = 1\n", + " run : (Unit -> int) -> int\n", + " run action = action ()\n", + ); + assert_equivalent(default, ml); +} diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index f503d66a..19f41a87 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -531,10 +531,26 @@ impl Checker { .. } => self.check_function(name, parameters, effects, body, env, *position), Stmt::Module { body, .. } => { + let mut inner = env.child(); + let prog = Program { + statements: body + .iter() + .map(|item| item.declaration.as_ref().clone()) + .collect(), + }; + // Module declarations live in their own lexical scope. Run + // both checker passes there: the old implementation only + // ran pass two, so module functions were never registered + // and their bodies were silently skipped. + self.collect(&prog, &mut inner); + self.check(&prog, &mut inner); + } + Stmt::Namespace { body, .. } => { let mut inner = env.child(); let prog = Program { statements: body.clone(), }; + self.collect(&prog, &mut inner); self.check(&prog, &mut inner); } // `let` / assignment / bare-expr statements infer the same way at @@ -867,6 +883,14 @@ mod tests { }\n", ); assert!(errs.iter().any(|e| e.message.contains("type mismatch"))); + // Module functions must run both declaration collection and body + // checking; historically only module lets reached inference. + let errs = check( + "module BadFn {\n\ + fn broken() -> int = \"not an int\"\n\ + }\n", + ); + assert!(errs.iter().any(|e| e.message.contains("type mismatch"))); } #[test] diff --git a/crates/osprey-types/src/expr.rs b/crates/osprey-types/src/expr.rs index e2870e65..5f14b651 100644 --- a/crates/osprey-types/src/expr.rs +++ b/crates/osprey-types/src/expr.rs @@ -41,6 +41,7 @@ impl Checker { Type::string() } Expr::Identifier(name) => self.lookup_ident(name, env), + Expr::Path(path) => self.lookup_ident(&path.to_string(), env), Expr::List(items) => { let elem = self.ctx.fresh(); for it in items { @@ -350,6 +351,10 @@ impl Checker { ) -> Type { let (fname, ft) = match function { Expr::Identifier(n) => (Some(n.clone()), self.lookup_ident(n, env)), + Expr::Path(path) => { + let name = path.to_string(); + (Some(name.clone()), self.lookup_ident(&name, env)) + } other => (None, self.infer_expr(other, env)), }; let args = self.ordered_arg_types(fname.as_deref(), arguments, named, env); diff --git a/crates/osprey-types/src/pattern.rs b/crates/osprey-types/src/pattern.rs index 158b95e4..96bbbc99 100644 --- a/crates/osprey-types/src/pattern.rs +++ b/crates/osprey-types/src/pattern.rs @@ -508,10 +508,10 @@ mod tests { #[test] fn result_pattern_with_an_unknown_field_binds_a_fresh_var() { - // `Success { extra }` over a Result binds the standard `value`/`message` + // `Success { surplus }` over a Result binds the standard `value`/`message` // and a fresh var for any other field name (the `_ => fresh()` arm). ok("fn f(r: Result) -> int = match r {\n\ - Success { value, extra } => value\n\ + Success { value, surplus } => value\n\ Error { message } => 0\n\ }\n"); } diff --git a/docs/plans/0014-modules-and-namespaces.md b/docs/plans/0014-modules-and-namespaces.md index 62ab8d00..cb6c0819 100644 --- a/docs/plans/0014-modules-and-namespaces.md +++ b/docs/plans/0014-modules-and-namespaces.md @@ -8,20 +8,27 @@ signatures for abstraction, and explicit state modules for centralising mutable state. Namespaces are flat-first opaque labels; module/member qualification uses `::`, not a promoted dot hierarchy. -The existing compiler already has `Stmt::Import`, `Stmt::Module`, Default-flavor -syntax for `import`/`module`, child-scope module checking, and project-adjacent -LSP work. The missing pieces are the project namespace graph, import resolution, -exports, signatures, symbol paths, state-ownership checks, and codegen/LSP -support for source-level symbol paths. +The compiler now has one shared module AST, both surface projections, a +compiler-facing project resolver, deterministic flattening into the existing +checker/backend, project CLI commands, and module-aware same-document tooling. +The remaining work is listed explicitly below rather than hidden behind a +generic "modules planned" status. ## Current State -- `osprey_ast::Stmt::Import { module: Vec }` and - `Stmt::Module { name, body }` exist. -- The Default lowerer parses `import_statement` and `module_declaration`. -- The type checker recurses into module bodies with a child scope, but module - declarations do not export/import usable symbols. -- The LSP outline recurses into modules but flattens names. +- `osprey-ast` has structured namespaces, symbol paths, imports, modules, + signatures, visibility, opacity, and state-kind metadata. +- Default and ML parse their deliberately different surfaces into that one AST. +- `osprey-project` scans mixed-flavor source roots, merges logical namespace + contributions, checks imports/signatures/privacy/state ownership, and emits a + resolved flat program for the existing type checker and backend. +- `osprey build`, directory/manifest inputs, and module-aware single files work; + ordinary scripts still bypass assembly unchanged. +- LSP/formatter/editor support understands module syntax within a document. + Incremental cross-file LSP indexing remains part of plan 0009. +- Opaque record/union boundaries retain nominal structure. Opaque manifest + aliases are rejected loudly because the flat checker cannot yet expose their + representation only to the owner without leaking its ABI to clients. - `docs/specs/0011-LightweightFibersAndConcurrency.md` has an older fiber-isolated module sketch. Spec 0025 supersedes it. - Cross-file LSP is already planned in @@ -50,116 +57,129 @@ TODO: old fiber-isolated module paragraph as superseded by spec 0025. - [x] Add the comparative language-practice survey and flat-first namespace style rules to spec 0025. -- [ ] Decide exact surface grammar for ML-flavor `namespace`, `module`, - `signature`, `export`, and `state module`. -- [ ] Reserve new keywords in both flavors: `namespace`, `signature`, `export`, +- [x] Decide exact surface grammar for ML-flavor `namespace`, `module`, + `signature`, `export`, and punctuation-free `state Name`. +- [x] Reserve new keywords in both flavors: `namespace`, `signature`, `export`, `opaque`, `state`, `as`. ## Phase 1 - AST And Project Model TODO: -- [ ] Add `NamespaceName(String)` and `SymbolPath(Vec)` to `osprey-ast`. -- [ ] Replace string-only `Stmt::Module { name }` with symbol paths and +- [x] Add `NamespaceName(String)` and `SymbolPath(Vec)` to `osprey-ast`. +- [x] Replace string-only `Stmt::Module { name }` with symbol paths and visibility/export metadata. -- [ ] Add `Stmt::Namespace { name, body }`. -- [ ] Add `Stmt::Signature { name, items }`. -- [ ] Add import forms: namespace/module import, member import list, alias, and +- [x] Add `Stmt::Namespace { name, body }`. +- [x] Add `Stmt::Signature { name, items }`. +- [x] Add import forms: namespace/module import, member import list, alias, and wildcard. -- [ ] Add `Visibility::{Private, Exported}` on module items. -- [ ] Add opaque/manifest type export metadata. -- [ ] Add `ModuleKind::{Plain, State}` and `state_boundary` metadata. -- [ ] Preserve source spans on every new declaration for diagnostics and LSP. +- [x] Add `Visibility::{Private, Exported}` on module items. +- [x] Add opaque/manifest type export metadata. +- [x] Add `ModuleKind::{Plain, State}`. There is deliberately no annotation + escape hatch in the initial module system. +- [x] Preserve source positions on every new declaration and rebase positions + into collision-free per-project ranges for diagnostics and LSP. ## Phase 2 - Frontend Lowering TODO: -- [ ] Default flavor: parse block-scoped and file-scoped `namespace`. -- [ ] Default flavor: parse `module A::B { ... }`, `state module`, `signature`, +- [x] Default flavor: parse block-scoped and file-scoped `namespace`. +- [x] Default flavor: parse `module A::B { ... }`, `state module`, `signature`, `export`, `opaque type`, import aliases, member lists, and wildcards. -- [ ] Default flavor: parse flat namespace labels plus quoted slash labels in +- [x] Default flavor: parse flat namespace labels plus quoted slash labels in namespace/import declarations. -- [ ] Default flavor: parse `::` symbol paths in expressions and types. -- [ ] ML flavor: add the same constructs in layout form and lower to the same +- [x] Default flavor: parse `::` symbol paths in expressions and types. +- [x] ML flavor: add the same constructs in layout form and lower to the same canonical AST. -- [ ] Interpolation re-entry must parse `::` symbol paths using the current file's +- [x] Interpolation re-entry must parse `::` symbol paths using the current file's flavor. -- [ ] Add parser tests for path-independent namespace declarations, flat +- [x] Add parser tests for path-independent namespace declarations, flat namespaces, quoted slash labels, duplicate namespace blocks, exports, signatures, aliases, and `::` calls. -- [ ] Add formatter/lint fixtures that prefer flat labels in docs/examples but +- [x] Add formatter/lint fixtures that prefer flat labels in docs/examples but continue accepting quoted slash labels and reverse-domain labels. ## Phase 3 - Project Loader And Namespace Graph TODO: -- [ ] Add `Project` / `ProjectGraph` in a compiler-facing crate, shared by CLI - and LSP. -- [ ] Read `osprey.toml` with `source_roots`, `default_namespace`, and module +- [x] Add `ProjectGraph` and assembled-project metadata in the compiler-facing + `osprey-project` crate, consumed by the CLI; LSP adoption remains below. +- [x] Read `osprey.toml` with `source_roots`, `default_namespace`, and module policy. Single-file mode remains unchanged. -- [ ] Scan `.osp` and `.ospml` files under source roots. -- [ ] Resolve flavor per file using the existing precedence rules. -- [ ] Parse every file independently, then merge namespace declarations by +- [x] Scan `.osp` and `.ospml` files under source roots. +- [x] Resolve flavor per file using the existing precedence rules. +- [x] Parse every file independently, then merge namespace declarations by namespace label. -- [ ] Build an import table that maps imports to namespaces/modules, never file +- [x] Build an import table that maps imports to namespaces/modules, never file paths. -- [ ] Detect duplicate exported declarations in one namespace/module. -- [ ] Detect ambiguous imports and emit actionable diagnostics. +- [x] Detect duplicate declarations/exports in one namespace/module. +- [x] Detect ambiguous imports and require explicit qualification or aliases. - [ ] Add style diagnostics as warnings only: folder drift, deep hierarchy in app code, and reverse-domain labels outside published-library config. -- [ ] Enforce one project entry point: designated entry file or `fn main()`. -- [ ] Reject executable top-level statements in non-entry project files. +- [x] Enforce one project entry point: designated entry file or `fn main()`. +- [x] Reject executable top-level statements in non-entry project files. ## Phase 4 - Name Resolution And Type Checking TODO: -- [ ] Add a resolver pass before type checking: local scope, module private +- [x] Add a resolver pass before type checking: local scope, module private scope, imported aliases, imported members, namespace/symbol-path lookup, builtins. -- [ ] Store resolved symbol IDs on declarations/references or in a side table. -- [ ] Make type inference consume resolved symbols instead of raw strings. -- [ ] Enforce module privacy: private names are visible only inside their module. -- [ ] Check explicit exports and signature ascriptions. +- [x] Store deterministic resolved linkage names plus a source-name side table. +- [x] Make type inference consume resolved linkage names instead of unresolved + `::` paths. +- [x] Enforce module privacy, including private intermediate module boundaries. +- [x] Check explicit exports and structural signature ascriptions. - [ ] Implement opaque exported types: representation available inside the owning - module, abstract outside. -- [ ] Check effect declarations and operations through signatures. + module, abstract outside. Opaque manifest aliases currently fail loudly + instead of leaking; transparent aliases are implemented. +- [x] Check effect declarations and operation shapes through signatures. - [ ] Allow separate type checking of importers against signatures. -- [ ] Add tests for cross-file values, functions, types, effects, and flavor - pairs. +- [x] Add tests for cross-file values, functions, effects, signatures, and + Default/ML flavor pairs. Full imported opaque-alias tests remain blocked + by the item above. ## Phase 5 - State Ownership Rules TODO: -- [ ] Reject namespace-level `mut`. -- [ ] Reject exported `mut` cells. +- [x] Reject namespace-level `mut` while preserving ordinary function-local + `mut` and reassignment. +- [x] Reject direct state-cell reads and writes everywhere except the owning + state module's algebraic-effect handler arms. +- [x] Reject exported `mut` cells, including signature-based export attempts. - [ ] Reject state-cell escape through exported pointers/references once pointer escape analysis exists; until then, reject direct export of `Ptr` derived from a state cell. -- [ ] Require every `state module` to expose a declared access path: handler, - effect, or function API. -- [ ] Enforce one unannotated `state module` per namespace. -- [ ] Add `@state_boundary("reason")` parsing and diagnostics. -- [ ] Prefer handler-owned state for state modules that expose algebraic effects. +- [x] Require every state owner with cells to export its owned algebraic effect + and a fused handler installer; ordinary functions are never a state access + path. +- [x] Enforce one `state module` per namespace with no initial-stage annotation + escape hatch. +- [x] Instantiate fresh private cells inside each handler installer rather than + emitting module-global storage. - [ ] Add LSP warnings and docs metadata that list all project state boundaries. -- [ ] Add compile-fail tests for scattered state, wildcard import of state - modules, state cycles, and exported mutable cells. +- [x] Add negative tests for scattered state, direct/qualified access, + wrong-effect handlers, escaping lambda/spawn factories, nested-module + handlers, wildcard state imports, impure initialization, and exported + mutable cells. ## Phase 6 - Codegen And Runtime TODO: -- [ ] Mangle namespace labels and `::` symbol paths deterministically. -- [ ] Update function, extern, effect-operation, handler, type-constructor, and +- [x] Mangle namespace labels and `::` symbol paths deterministically and + collision-free. +- [x] Update function, extern, effect, handler, type-constructor, and qualified generated lambda names to use resolved symbol IDs. -- [ ] Ensure imports do not emit runtime initialization. -- [ ] Lower pure namespace/module constants without hidden order dependence. -- [ ] Lower state module instances through explicit handler/instance +- [x] Ensure imports do not emit runtime initialization. +- [x] Lower pure namespace/module constants without hidden order dependence. +- [x] Lower state module instances through explicit handler/instance construction. -- [ ] Reject cyclic state initialization before codegen. +- [x] Reject cyclic/impure constant and state initialization before codegen. - [ ] Preserve source-level names in debug info and stack traces. - [ ] Add IR equivalence tests for cross-flavor modules with identical canonical project graphs. @@ -168,17 +188,19 @@ TODO: TODO: -- [ ] CLI: `osprey build` / project mode reads `osprey.toml`; existing single-file +- [x] CLI: `osprey build` / project mode reads `osprey.toml`; existing single-file commands keep working. -- [ ] CLI: diagnostics show namespace labels, `::` symbol paths, and import - candidates. +- [ ] CLI: diagnostics show namespace labels, `::` symbol paths, and ranked + import candidates. Physical source mapping and qualified paths work; + ranked candidate suggestions remain. - [ ] LSP: maintain an incremental project graph across open files and source roots. -- [ ] LSP: go-to-definition, references, hover, completion, and document symbols - understand namespaces/modules/imports. +- [x] LSP: same-document go-to-definition, references, hover, completion, and + fully-qualified document symbols understand namespaces/modules/imports. + Cross-file behavior depends on the incremental graph item above. - [ ] LSP: show state-boundary warnings and quick fixes for aliases and explicit `::` paths. -- [ ] Formatter: preserve file-scoped namespace and format module/signature +- [x] Formatter: preserve file-scoped namespace and format module/signature blocks in both flavors. - [ ] Docs generator: create namespace/module reference pages from exported signatures. @@ -187,19 +209,20 @@ TODO: TODO: -- [ ] Add `examples/tested/modules/` with multi-file projects. -- [ ] Include path-independent namespaces where file paths intentionally do not +- [x] Add `examples/projects/modules/` as a real multi-file build/run project + (the single-file differential harness cannot represent project manifests). +- [x] Include path-independent namespaces where file paths intentionally do not match namespace names. -- [ ] Include flat namespace examples and at least one quoted slash-label example +- [x] Include flat namespace examples and a quoted slash-label example to lock in separator neutrality. -- [ ] Include Default imports ML and ML imports Default. -- [ ] Include explicit import lists, aliases, ambiguous import failures, and - wildcard policy failures. +- [x] Include Default imports ML and ML imports Default. +- [x] Include explicit import lists and aliases in the runnable project, plus + ambiguous-import and wildcard-policy failures in project tests. - [ ] Include signatures with opaque and manifest types. -- [ ] Include a state module that exposes an effect handler and a pure fake for +- [x] Include a state module that exposes an effect handler and a pure fake for tests. -- [ ] Add compile-fail examples for namespace-level `mut`, exported `mut`, - duplicate exports, private-name leakage, and state cycles. +- [x] Add compile-fail project tests for namespace/plain-module/exported `mut`, + duplicate/private boundaries, state scatter, and initializer failures. - [ ] Add LSP integration tests for cross-file completion/hover/definition. - [ ] `make ci` green. diff --git a/docs/plans/README.md b/docs/plans/README.md index 4f928d36..786d6a92 100644 --- a/docs/plans/README.md +++ b/docs/plans/README.md @@ -21,7 +21,7 @@ repros. | [0011](0011-arc-gc-implementation.md) | Reclaiming memory backends (tracing GC + ARC) | codegen/runtime | Phase 1 conservative GC shipped (`--memory=gc`); Perceus ARC + Cheney + static-mode not started | High | | [0012](0012-osprey-debugger.md) | Modern Osprey debugger | compiler/editor/runtime | Spec written; Phase 1 source line debugging in progress | High | | [0013](0013-ml-flavor-frontend.md) | ML flavor frontend (layout syntax, curry-by-default) | frontend/types/codegen/tooling | Frontend shipped (68 `.ospml` twins, VSIX, equivalence tests); handler *values* + ML must-reject remain | Mostly done | -| [0014](0014-modules-and-namespaces.md) | Modules, namespaces & multi-file apps | frontend/resolver/types/codegen/lsp | Spec written ([0025](../specs/0025-ModulesAndNamespaces.md)); parser has only early `import`/`module` grouping | High | +| [0014](0014-modules-and-namespaces.md) | Modules, namespaces & multi-file apps | frontend/resolver/types/codegen/lsp | Initial Default + ML project compiler is live; opaque manifest aliases and cross-file LSP/interface checking remain | High | | [0015](0015-generics-and-variance.md) | Generics with `in`/`out` variance & generic effects | frontend/types/codegen (both flavors) | Core + generic-fn-values landed; turbofish + static seam remain | Mostly done | | [0016](0016-algebraic-effects-and-handlers.md) | Algebraic effects roadmap (resume/handler-values/multi-shot) | effects/types/codegen/runtime | Tail + single-shot resume + generic effects + multi-shot rejection + fiber-perform race fix + lambda-resume type error done; handler values, effect rows (incl. static unhandled-effect checks), wasm effects remain | High | diff --git a/docs/specs/0024-MLFlavorSyntax.md b/docs/specs/0024-MLFlavorSyntax.md index 0d0921e0..aa500a64 100644 --- a/docs/specs/0024-MLFlavorSyntax.md +++ b/docs/specs/0024-MLFlavorSyntax.md @@ -19,6 +19,7 @@ subordinate to that contract. Implementation is tracked in - [Bindings and Mutation](#bindings-and-mutation) - [Functions and Currying](#functions-and-currying) - [Function Calls](#function-calls) +- [Modules and Namespaces](#modules-and-namespaces) - [Effects](#effects) - [Handlers](#handlers) - [Match](#match) @@ -52,8 +53,13 @@ subordinate to that contract. Implementation is tracked in precedence-climbing) parser in [`crates/osprey-syntax/src/ml/`](../../crates/osprey-syntax/src/ml/) (see [`[FLAVOR-ML-LAYOUT]`](#layout-model)). -- **Phase 0 — first-class handler values + effects: deferred.** ML - handler/effect syntax errors loudly until this shared-core feature lands. +- **Modules and namespaces: implemented.** File/block namespaces, layout + modules and signatures, concise state modules, explicit exports, layout + imports, and `::` symbol paths lower to the shared module AST specified by + [Modules and Namespaces](0025-ModulesAndNamespaces.md). +- **First-class handler values: deferred.** ML effect declarations, + `perform`, and the existing fused `handle ... in ...` form are implemented; + only reusable handler values/installers await the shared-core feature. The parsing techniques and the offside rule are cited in the [References](#references) section. @@ -272,6 +278,127 @@ Lowering: whitespace application `f a b` → nested `Expr::Call`, one argument e `f(x: a, y: b)`); a single parenthesised expression `f (a)` is just grouping and lowers to `Call(f, [a])`. +## Modules and Namespaces + +`[FLAVOR-ML-MODULES]` Module semantics are defined by +[Modules and Namespaces](0025-ModulesAndNamespaces.md). This section defines +only the ML projection: layout supplies every body boundary, `::` qualifies +logical symbols, and visibility is written exactly once. + +```ebnf +namespaceDecl ::= "namespace" namespaceName (INDENT item+ DEDENT)? +namespaceName ::= ID | STRING +moduleDecl ::= "module" symbolPath (":" symbolPath)? INDENT item+ DEDENT +stateDecl ::= "state" symbolPath (":" symbolPath)? INDENT item+ DEDENT +signatureDecl ::= "signature" ID INDENT signatureItem+ DEDENT +symbolPath ::= ID ("::" ID)* +``` + +A namespace header without an indented body is file-scoped. An indented body is +one block contribution to the open namespace: + +```osprey-ml +namespace billing + +module Tax + ... +``` + +```osprey-ml +namespace billing + module Tax + ... +``` + +A named signature is the whole public contract of an ascribed module. Signature +items are public by definition, and implementation declarations do not repeat +`export`: + +```osprey-ml +signature TaxApi + type Money + type Rate = int + addTax : Money -> Money + +module Tax : TaxApi + type Money = int + type Rate = int + + addTax cents = cents +``` + +In a signature, bare `type T` is abstract; `type T = R` is manifest. Writing +`opaque type T` there is redundant and rejected. An ascribed module exports +exactly its signature, so any explicit `export` inside it is also rejected. + +An un-ascribed module marks each public declaration group exactly once. The +inference-first form exports the definition directly; when a type contract is +genuinely load-bearing, an exported value signature transfers visibility to +the immediately following same-name bare definition: + +```osprey-ml +module Tax + defaultRate = 10 + + export addTax cents = + cents + cents * defaultRate / 100 + + export zero cents = cents + export opaque type UserId = int +``` + +Prefixing both a signature and its definition with `export` is an error, as is +an orphan signature. `export mut` is always an error: module-owned cells are +private. + +The state-owning form is deliberately `state Name`, never the redundant +`state module Name`: + +```osprey-ml +state Counter + mut count = 0 + + export effect CounterFx + read : Unit => int + + export run action = + handle CounterFx + read => count + in + action () +``` + +State never leaks through an ordinary accessor. `run` installs the capability; +the private cell is read only inside its handler arm. First-class exported +handler values will provide the still-cleaner factory form described in +[Handlers](#handlers) once that shared-core feature lands. + +Imports use the same logical targets as the shared model, but explicit member +selection is a layout list rather than Default's brace list: + +```ebnf +importDecl ::= "import" importTarget ("as" ID)? + | "import" importTarget INDENT importMember+ DEDENT + | "import" importTarget INDENT "*" DEDENT +importMember ::= ID ("as" ID)? +``` + +```osprey-ml +import billing::Tax +import billing::Tax as T +import billing::Tax + addTax + zero as noTax +import "billing/api" as api + +gross = T::addTax 100 +``` + +`::` is namespace/module/member qualification; `.` remains value field access. +Qualified whitespace application is still curried (`Tax::add 1 2`). Calling a +flat multi-parameter API uses the explicit uncurried form +`Tax::add (1, 2)`, matching Default `Tax::add(1, 2)`. + ## Effects `[FLAVOR-ML-EFFECT]` An effect declaration is a layout block of operation @@ -498,6 +625,12 @@ is in [FLAVOR-LAYER](0023-LanguageFlavors.md#flavor-concern-vs-shared-core-conce | `\x y => e` | curried `Expr::Lambda` chain | | `f a b` | nested one-arg `Expr::Call` — `Call(Call(f,[a]),[b])` | | `f (a, b)` (saturated) | single multi-arg `Expr::Call` — `Call(f, [a, b])` | +| `namespace n` + following declarations | file-scoped `Stmt::Namespace` | +| `module M : S` + layout body | `Stmt::Module { kind: Plain, signature: S }` | +| `state M` + layout body | `Stmt::Module { kind: State }` | +| `signature S` + layout items | `Stmt::Signature` | +| layout member import | `Stmt::Import` + explicit `ImportSelection` | +| `A::B::value` | `Expr::Path(SymbolPath)` | | `type T =` + variant/field layout | `Stmt::Type` + `TypeVariant` | | `[a, b, c]` / `xs[i]` | `Expr::List` / `Expr::Index` | | layout block | `Expr::Block` | @@ -657,4 +790,6 @@ layout lexer. contract, currying canonicalisation, and shared-core handler-value feature. - [Algebraic Effects](0017-AlgebraicEffects.md) — effect semantics shared by both flavors. +- [Modules and Namespaces](0025-ModulesAndNamespaces.md) — shared namespace, + module, signature, import, export, and state-ownership semantics. - [Plan 0013 — ML Flavor Frontend](../plans/0013-ml-flavor-frontend.md). diff --git a/docs/specs/0025-ModulesAndNamespaces.md b/docs/specs/0025-ModulesAndNamespaces.md index 1c5f0eda..54cab00a 100644 --- a/docs/specs/0025-ModulesAndNamespaces.md +++ b/docs/specs/0025-ModulesAndNamespaces.md @@ -15,13 +15,23 @@ it belongs to a project; it does **not** decide the names it exports. ## Status `[MODULES-STATUS]` -The Default frontend currently parses only stub forms of dotted `import` and -`module Name { ... }`; the ML frontend has neither form yet. The stubs do not -resolve imports, expose module members, enforce privacy, or reach codegen. -Cross-file resolution, namespaces, exports, signatures, state ownership, and -project assembly therefore remain planned. This chapter is the normative -contract for that implementation and supersedes the -fiber-isolated module sketch in [Fibers and Concurrency](0011-LightweightFibersAndConcurrency.md#fiber-isolated-modules-planned). +The initial module system is implemented end to end in both flavors. The shared +AST, project loader, namespace graph, import/privacy/signature checks, resolved +linkage names, state-owner validation, handler-local state materialization, +type checking, native/LLVM codegen, project CLI, formatter, and same-document +editor features are active. Mixed `.osp`/`.ospml` projects build and run through +the same canonical graph. + +The implementation fails loudly at the remaining semantic boundaries. In +particular, opaque manifest aliases are rejected rather than flattened to their +private representation; owner-transparent/client-nominal alias checking needs a +non-flat interface-aware checker. Separate importer checking, parameterised and +recursive modules, ranked import suggestions, incremental cross-file LSP +indexing, module reference-page generation, and source-name restoration in +native debugger/stack frames remain planned and are unchecked in +[plan 0014](../plans/0014-modules-and-namespaces.md). This chapter remains the +normative contract for those pieces and supersedes the fiber-isolated module +sketch in [Fibers and Concurrency](0011-LightweightFibersAndConcurrency.md#fiber-isolated-modules-planned). ## Research Basis `[MODULES-RESEARCH]` @@ -322,17 +332,18 @@ unascribed module exports only declarations marked `export`; an ascribed module' signature is its complete public surface. ```ebnf -defaultModuleDecl ::= "module" symbolPath signatureAscription? +defaultModuleDecl ::= "module" symbolPath defaultSignatureAscription? "{" defaultModuleItem* "}" -defaultStateDecl ::= "state" "module" symbolPath signatureAscription? +defaultStateDecl ::= "state" "module" symbolPath defaultSignatureAscription? "{" defaultModuleItem* "}" defaultModuleItem ::= "export"? statement -mlModuleDecl ::= "module" symbolPath signatureAscription? +mlModuleDecl ::= "module" symbolPath mlSignatureAscription? NEWLINE INDENT mlModuleItem+ DEDENT -mlStateDecl ::= "state" symbolPath signatureAscription? +mlStateDecl ::= "state" symbolPath mlSignatureAscription? NEWLINE INDENT mlModuleItem+ DEDENT mlModuleItem ::= "export"? statement -signatureAscription ::= ":" symbolPath ("+" "extra")? +defaultSignatureAscription ::= ":" symbolPath ("+" "extra")? +mlSignatureAscription ::= ":" symbolPath ``` Default flavor: @@ -343,7 +354,7 @@ namespace billing; module Tax { let defaultRate = 10 - export fn addTax(cents: int) -> int = + export fn addTax(cents) = cents + cents * defaultRate / 100 } ``` @@ -356,8 +367,7 @@ namespace billing module Tax defaultRate = 10 - export addTax : int -> int - addTax cents = + export addTax cents = cents + cents * defaultRate / 100 ``` @@ -413,7 +423,14 @@ gross = addTax 100 other = Tax::addTax 100 ``` -Resolution rules: +### Name Resolution `[MODULES-RESOLUTION]` + +Resolution is lexical and deterministic: local bindings and declarations win, +then the current module and its parents, imported aliases, imported members, +explicit namespace-qualified paths, and finally built-ins. An import never +silently replaces a nearer declaration. + +Additional import rules: - Identifier namespace labels can be used directly with `::`: `billing::Tax::addTax(100)`. @@ -527,7 +544,8 @@ effectSignatureBody ::= "{" effectOperationSpec* "}" | NEWLINE INDENT effectOperationSpec+ DEDENT effectOperationSpec ::= IDENT ":" typeExpr /* Default fn type */ | IDENT ":" mlType "=>" mlType -signatureAscription ::= ":" symbolPath ("+" "extra")? +defaultSignatureAscription ::= ":" symbolPath ("+" "extra")? +mlSignatureAscription ::= ":" symbolPath ``` Default flavor: @@ -571,7 +589,6 @@ module MemoryStore : StoreSig load : Unit => Store save : Store => Unit - empty : Unit -> Store empty () = Store values = [] @@ -590,9 +607,11 @@ Signature conformance is checked structurally: - Effect operations must match names, parameter types, return types, and effect rows. - Extra private declarations are allowed. -- Other implementation declarations stay private. `: StoreSig + extra` opts - into additionally exporting declarations explicitly marked `export`; without - `+ extra`, such extra exports are rejected. +- Other implementation declarations stay private. In Default, + `: StoreSig + extra` opts into additionally exporting declarations explicitly + marked `export`; without `+ extra`, such extra exports are rejected. ML keeps + ascription exact: extend the named signature or use an unascribed module + instead of adding a redundant `+ extra`/`export` side channel. ### Separate Checking `[MODULES-SEPARATE-CHECKING]` @@ -691,7 +710,6 @@ state Counter : CounterSig next : Unit => int read : Unit => int - run : (Unit -> Unit) -> Unit run action = handle CounterFx next () => @@ -728,9 +746,9 @@ Rules: Pure helpers remain legal when all state arrives through explicit parameters. - A state module must export its effect surface and at least one installer that establishes the owning handler region. -- A namespace may contain at most one unannotated state module. Additional state - owners require `@state_boundary("reason")` and are reported by LSP and docs - tooling as architecture-visible boundaries. +- A namespace may contain at most one state module in the initial module + system. There is no annotation, ordinary-function, or ambient-state escape + hatch; additional owners are a compile-time error. - Cached derived cells are forbidden in Phase 1. Derived values are computed in handler arms or by pure helpers over explicit values. @@ -866,8 +884,8 @@ Module diagnostics must be architecture-facing: - unknown import: show candidate namespaces from the project graph; - ambiguous import: show all providers and suggest aliases; - exported private dependency: show the hidden type/value in the public signature; -- state scatter: show every state module in the namespace and require - `@state_boundary`; +- state scatter: show every state module in the namespace and require the state + to be consolidated behind one algebraic-effect boundary; - top-level mutable state: suggest `state module` or handler-owned state; - path drift: warn, never change semantics. diff --git a/examples/projects/modules/README.md b/examples/projects/modules/README.md new file mode 100644 index 00000000..93d10233 --- /dev/null +++ b/examples/projects/modules/README.md @@ -0,0 +1,23 @@ +# Mixed-flavour modules + +This project exercises Osprey's logical module graph end to end: + +- `"billing/api"::Tax` is written in Default Osprey under the intentionally + unrelated physical path `src/deep/unrelated/tax.osp`; the slash label is one + opaque namespace name, not a folder hierarchy. +- `billing::Greeting` and the signature-ascribed `billing::Counter` state module + are written in the ML flavour; `Greeting` aliases the quoted namespace and + imports Default's `Tax::addTax` through `taxApi::Tax::addTax`. +- the Default entry imports both ML modules, proving interop in both directions + through one shared ABI and namespace model. +- `Counter` state is instantiated by `run` and touched only by `CounterFx` + handler arms. Importing it allocates and mutates nothing. +- `CounterFake` handles the same exported effect without owning mutable state, + so tests can swap the installer while application logic stays unchanged. + +Run it from the repository root: + +```sh +target/release/osprey build examples/projects/modules -o /tmp/osprey-modules +/tmp/osprey-modules +``` diff --git a/examples/projects/modules/expectedoutput b/examples/projects/modules/expectedoutput new file mode 100644 index 00000000..4781b4aa --- /dev/null +++ b/examples/projects/modules/expectedoutput @@ -0,0 +1 @@ +tax=110 counter=1/2 diff --git a/examples/projects/modules/osprey.toml b/examples/projects/modules/osprey.toml new file mode 100644 index 00000000..15bfd5b2 --- /dev/null +++ b/examples/projects/modules/osprey.toml @@ -0,0 +1,8 @@ +[project] +name = "modules" +source_roots = ["src"] +default_namespace = "billing" +entry = "src/main.osp" + +[modules] +allow_wildcard_imports = false diff --git a/examples/projects/modules/src/cream.ospml b/examples/projects/modules/src/cream.ospml new file mode 100644 index 00000000..7d95e5c9 --- /dev/null +++ b/examples/projects/modules/src/cream.ospml @@ -0,0 +1,30 @@ +namespace billing + +import "billing/api" as taxApi + +module Greeting + export label cents = "tax=${taxApi::Tax::addTax cents}" + +signature CounterApi + effect CounterFx + next : Unit => int + run : (Unit -> Unit) -> Unit + +state Counter : CounterApi + mut count = 0 + + effect CounterFx + next : Unit => int + + run action = + handle CounterFx + next => + count := count + 1 + count + in action () + +module CounterFake + export run action = + handle Counter::CounterFx + next => 41 + in action () diff --git a/examples/projects/modules/src/deep/unrelated/tax.osp b/examples/projects/modules/src/deep/unrelated/tax.osp new file mode 100644 index 00000000..e13fc17b --- /dev/null +++ b/examples/projects/modules/src/deep/unrelated/tax.osp @@ -0,0 +1,12 @@ +namespace "billing/api"; + +signature TaxApi { + fn addTax(cents: int) -> int +} + +module Tax : TaxApi { + let defaultRate = 10 + + fn addTax(cents) = + cents + defaultRate +} diff --git a/examples/projects/modules/src/main.osp b/examples/projects/modules/src/main.osp new file mode 100644 index 00000000..bc07936a --- /dev/null +++ b/examples/projects/modules/src/main.osp @@ -0,0 +1,14 @@ +namespace app; + +import billing::Greeting as Greeting +import billing::Counter::{CounterFx, run} + +fn allocate() = + perform CounterFx.next() + +fn main() = + run(action: fn() => { + let first = allocate() + let second = allocate() + print("${Greeting::label(100)} counter=${first}/${second}") + }) diff --git a/tree-sitter-osprey/grammar.js b/tree-sitter-osprey/grammar.js index 46589c66..1607c9e0 100644 --- a/tree-sitter-osprey/grammar.js +++ b/tree-sitter-osprey/grammar.js @@ -44,6 +44,9 @@ module.exports = grammar({ [$.primary_expression, $.type_constructor], [$.primary_expression, $.generic_type], [$.type_identifier, $.type_constructor], + // `import a::b::{x}` must keep both parses alive until the token following + // `::` distinguishes another target segment from an import tail. + [$.import_target], // `ID {` — bare variable ref vs type-constructor vs record update. [$.primary_expression, $.type_constructor, $.update_expression], // `{` opens a block, a map literal, or an object literal; brace body decides. @@ -68,11 +71,9 @@ module.exports = grammar({ // A single bare identifier remains an identifier; qualified paths require // at least one `::`, so these only overlap while the lexer has not yet seen // the separator. - [$.qualified_path, $.primary_expression], // `type Alias = Name` is intentionally kept as the historical one-variant // union spelling. Unambiguous function/generic/array aliases use type_alias; // opaque aliases are disambiguated by their module-item prefix. - [$.union_type, $.type_alias], ], rules: { @@ -112,11 +113,9 @@ module.exports = grammar({ seq($.identifier, repeat1(seq('.', $.identifier))), import_target: ($) => - prec.right( - seq( - field('namespace', $.namespace_name), - repeat(seq('::', field('segment', $.identifier))), - ), + seq( + field('namespace', $.namespace_name), + repeat(seq('::', field('segment', $.identifier))), ), import_tail: ($) => @@ -138,7 +137,7 @@ module.exports = grammar({ namespace_declaration: ($) => seq( optional($.doc_comment), - 'namespace', + field('keyword', 'namespace'), field('name', $.namespace_name), choice(';', field('body', $.namespace_body)), ), @@ -507,7 +506,7 @@ module.exports = grammar({ seq( optional($.doc_comment), optional(field('state', 'state')), - 'module', + field('keyword', 'module'), field('path', $.symbol_path), optional(field('signature', $.signature_ascription)), '{', @@ -550,7 +549,7 @@ module.exports = grammar({ signature_declaration: ($) => seq( optional($.doc_comment), - 'signature', + field('keyword', 'signature'), field('name', $.identifier), '{', repeat($.signature_item), diff --git a/tree-sitter-osprey/queries/folds.scm b/tree-sitter-osprey/queries/folds.scm index 99e45a11..844699e5 100644 --- a/tree-sitter-osprey/queries/folds.scm +++ b/tree-sitter-osprey/queries/folds.scm @@ -5,6 +5,8 @@ (union_type) @fold (effect_declaration) @fold (module_declaration) @fold +(namespace_declaration body: (namespace_body) @fold) +(signature_declaration) @fold (match_expression) @fold (select_expression) @fold (object_literal) @fold diff --git a/tree-sitter-osprey/queries/highlights.scm b/tree-sitter-osprey/queries/highlights.scm index 65bfffb4..4c376bfa 100644 --- a/tree-sitter-osprey/queries/highlights.scm +++ b/tree-sitter-osprey/queries/highlights.scm @@ -16,6 +16,7 @@ ; --- Keywords --- [ "let" "mut" "fn" "extern" "type" "module" "import" + "namespace" "signature" "export" "opaque" "state" "as" "extra" "effect" "perform" "handle" "in" "match" "select" "where" "if" "else" ] @keyword @@ -26,14 +27,14 @@ ; --- Operators --- [ - "=" "->" "=>" "|>" "?" ":" + "=" "->" "=>" "|>" "?" ":" "::" "==" "!=" "<" ">" "<=" ">=" "&&" "||" "!" "%" "+" "-" "*" "/" ] @operator ; --- Punctuation --- [ "(" ")" "{" "}" "[" "]" ] @punctuation.bracket -[ "," "." "|" ] @punctuation.delimiter +[ "," "." ";" "|" ] @punctuation.delimiter ; --- Declarations & names --- (function_declaration name: (identifier) @function) @@ -43,6 +44,12 @@ (let_declaration name: (identifier) @variable) (effect_declaration name: (identifier) @type) (operation_declaration name: (identifier) @function.method) +(namespace_declaration name: (namespace_name (identifier) @namespace)) +(namespace_declaration name: (namespace_name (string) @string.special)) +(module_declaration path: (symbol_path (identifier) @namespace)) +(signature_declaration name: (identifier) @type) +(signature_module path: (symbol_path (identifier) @namespace)) +(qualified_path (identifier) @namespace) ; --- Types --- (type_declaration name: (identifier) @type) diff --git a/tree-sitter-osprey/queries/locals.scm b/tree-sitter-osprey/queries/locals.scm index db5baf57..27ea92da 100644 --- a/tree-sitter-osprey/queries/locals.scm +++ b/tree-sitter-osprey/queries/locals.scm @@ -6,10 +6,13 @@ (match_arm) @local.scope (handler_expression) @local.scope (module_declaration) @local.scope +(namespace_declaration) @local.scope +(signature_declaration) @local.scope (let_declaration name: (identifier) @local.definition) (parameter name: (identifier) @local.definition) (extern_parameter name: (identifier) @local.definition) (field_pattern (identifier) @local.definition) +(signature_value name: (identifier) @local.definition) (primary_expression (identifier) @local.reference) diff --git a/tree-sitter-osprey/src/grammar.json b/tree-sitter-osprey/src/grammar.json index 0d46e20a..74248176 100644 --- a/tree-sitter-osprey/src/grammar.json +++ b/tree-sitter-osprey/src/grammar.json @@ -136,41 +136,37 @@ ] }, "import_target": { - "type": "PREC_RIGHT", - "value": 0, - "content": { - "type": "SEQ", - "members": [ - { - "type": "FIELD", - "name": "namespace", - "content": { - "type": "SYMBOL", - "name": "namespace_name" - } - }, - { - "type": "REPEAT", - "content": { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "::" - }, - { - "type": "FIELD", - "name": "segment", - "content": { - "type": "SYMBOL", - "name": "identifier" - } + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "namespace", + "content": { + "type": "SYMBOL", + "name": "namespace_name" + } + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "::" + }, + { + "type": "FIELD", + "name": "segment", + "content": { + "type": "SYMBOL", + "name": "identifier" } - ] - } + } + ] } - ] - } + } + ] }, "import_tail": { "type": "CHOICE", @@ -328,8 +324,12 @@ ] }, { - "type": "STRING", - "value": "namespace" + "type": "FIELD", + "name": "keyword", + "content": { + "type": "STRING", + "value": "namespace" + } }, { "type": "FIELD", @@ -3849,8 +3849,12 @@ ] }, { - "type": "STRING", - "value": "module" + "type": "FIELD", + "name": "keyword", + "content": { + "type": "STRING", + "value": "module" + } }, { "type": "FIELD", @@ -4052,8 +4056,12 @@ ] }, { - "type": "STRING", - "value": "signature" + "type": "FIELD", + "name": "keyword", + "content": { + "type": "STRING", + "value": "signature" + } }, { "type": "FIELD", @@ -4591,6 +4599,9 @@ "type_identifier", "type_constructor" ], + [ + "import_target" + ], [ "primary_expression", "type_constructor", @@ -4640,14 +4651,6 @@ [ "generic_type", "type_identifier" - ], - [ - "qualified_path", - "primary_expression" - ], - [ - "union_type", - "type_alias" ] ], "precedences": [], diff --git a/tree-sitter-osprey/src/node-types.json b/tree-sitter-osprey/src/node-types.json index c2d80c64..731b48b9 100644 --- a/tree-sitter-osprey/src/node-types.json +++ b/tree-sitter-osprey/src/node-types.json @@ -1439,6 +1439,16 @@ "type": "module_declaration", "named": true, "fields": { + "keyword": { + "multiple": false, + "required": true, + "types": [ + { + "type": "module", + "named": false + } + ] + }, "path": { "multiple": false, "required": true, @@ -1598,6 +1608,16 @@ } ] }, + "keyword": { + "multiple": false, + "required": true, + "types": [ + { + "type": "namespace", + "named": false + } + ] + }, "name": { "multiple": false, "required": true, @@ -2137,6 +2157,16 @@ "type": "signature_declaration", "named": true, "fields": { + "keyword": { + "multiple": false, + "required": true, + "types": [ + { + "type": "signature", + "named": false + } + ] + }, "name": { "multiple": false, "required": true, diff --git a/tree-sitter-osprey/src/parser.c b/tree-sitter-osprey/src/parser.c index c6ddae65..da8aae91 100644 --- a/tree-sitter-osprey/src/parser.c +++ b/tree-sitter-osprey/src/parser.c @@ -13,7 +13,7 @@ #define EXTERNAL_TOKEN_COUNT 0 #define FIELD_COUNT 43 #define MAX_ALIAS_SEQUENCE_LENGTH 14 -#define PRODUCTION_ID_COUNT 163 +#define PRODUCTION_ID_COUNT 167 enum ts_symbol_identifiers { sym_identifier = 1, @@ -1506,161 +1506,165 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [5] = {.index = 4, .length = 2}, [6] = {.index = 6, .length = 2}, [7] = {.index = 8, .length = 2}, - [8] = {.index = 10, .length = 1}, - [9] = {.index = 11, .length = 2}, - [10] = {.index = 13, .length = 2}, - [11] = {.index = 15, .length = 2}, - [12] = {.index = 17, .length = 3}, - [13] = {.index = 20, .length = 1}, - [14] = {.index = 21, .length = 2}, - [15] = {.index = 23, .length = 1}, - [16] = {.index = 24, .length = 1}, - [17] = {.index = 25, .length = 2}, - [18] = {.index = 27, .length = 2}, - [19] = {.index = 29, .length = 3}, - [20] = {.index = 32, .length = 2}, - [21] = {.index = 34, .length = 1}, - [22] = {.index = 35, .length = 2}, - [23] = {.index = 37, .length = 1}, - [24] = {.index = 38, .length = 1}, - [25] = {.index = 39, .length = 2}, - [26] = {.index = 41, .length = 1}, - [27] = {.index = 42, .length = 1}, - [28] = {.index = 43, .length = 1}, - [29] = {.index = 44, .length = 2}, - [30] = {.index = 46, .length = 2}, - [31] = {.index = 48, .length = 1}, - [32] = {.index = 49, .length = 2}, - [33] = {.index = 51, .length = 1}, - [34] = {.index = 52, .length = 2}, - [35] = {.index = 54, .length = 2}, - [36] = {.index = 56, .length = 2}, - [37] = {.index = 58, .length = 2}, - [38] = {.index = 60, .length = 1}, - [39] = {.index = 61, .length = 2}, - [40] = {.index = 63, .length = 2}, - [41] = {.index = 65, .length = 1}, - [42] = {.index = 66, .length = 2}, - [43] = {.index = 68, .length = 3}, - [44] = {.index = 71, .length = 3}, - [45] = {.index = 74, .length = 2}, - [46] = {.index = 76, .length = 1}, - [47] = {.index = 77, .length = 4}, - [48] = {.index = 81, .length = 1}, - [49] = {.index = 82, .length = 2}, - [50] = {.index = 84, .length = 3}, - [51] = {.index = 87, .length = 3}, - [52] = {.index = 90, .length = 2}, - [53] = {.index = 92, .length = 2}, - [54] = {.index = 94, .length = 2}, - [55] = {.index = 96, .length = 2}, - [56] = {.index = 98, .length = 2}, - [57] = {.index = 100, .length = 3}, - [58] = {.index = 103, .length = 2}, - [59] = {.index = 105, .length = 1}, - [60] = {.index = 106, .length = 2}, - [61] = {.index = 108, .length = 2}, - [62] = {.index = 110, .length = 2}, - [63] = {.index = 112, .length = 1}, - [64] = {.index = 113, .length = 2}, - [65] = {.index = 115, .length = 2}, - [66] = {.index = 117, .length = 2}, - [67] = {.index = 119, .length = 1}, - [68] = {.index = 120, .length = 3}, - [69] = {.index = 123, .length = 3}, - [70] = {.index = 126, .length = 3}, - [71] = {.index = 129, .length = 4}, - [72] = {.index = 133, .length = 2}, - [73] = {.index = 135, .length = 3}, - [74] = {.index = 138, .length = 2}, - [75] = {.index = 140, .length = 3}, - [76] = {.index = 143, .length = 2}, - [77] = {.index = 145, .length = 2}, - [78] = {.index = 147, .length = 4}, - [79] = {.index = 151, .length = 2}, - [80] = {.index = 153, .length = 3}, - [81] = {.index = 156, .length = 3}, - [82] = {.index = 159, .length = 2}, - [83] = {.index = 161, .length = 3}, - [84] = {.index = 164, .length = 1}, - [85] = {.index = 165, .length = 3}, - [86] = {.index = 168, .length = 3}, - [87] = {.index = 171, .length = 4}, - [88] = {.index = 175, .length = 4}, - [89] = {.index = 179, .length = 4}, - [90] = {.index = 183, .length = 3}, - [91] = {.index = 186, .length = 2}, - [92] = {.index = 188, .length = 2}, - [93] = {.index = 190, .length = 2}, - [94] = {.index = 192, .length = 3}, - [95] = {.index = 195, .length = 1}, - [96] = {.index = 196, .length = 3}, - [97] = {.index = 199, .length = 3}, - [98] = {.index = 202, .length = 3}, - [99] = {.index = 205, .length = 4}, - [100] = {.index = 209, .length = 2}, - [101] = {.index = 211, .length = 3}, - [102] = {.index = 214, .length = 2}, - [103] = {.index = 216, .length = 3}, - [104] = {.index = 219, .length = 4}, - [105] = {.index = 223, .length = 4}, - [106] = {.index = 227, .length = 4}, - [107] = {.index = 231, .length = 4}, - [108] = {.index = 235, .length = 5}, - [109] = {.index = 240, .length = 3}, - [110] = {.index = 243, .length = 3}, - [111] = {.index = 246, .length = 2}, - [112] = {.index = 248, .length = 3}, - [113] = {.index = 251, .length = 3}, - [114] = {.index = 254, .length = 3}, - [115] = {.index = 257, .length = 3}, - [116] = {.index = 260, .length = 4}, - [117] = {.index = 264, .length = 4}, - [118] = {.index = 268, .length = 4}, - [119] = {.index = 272, .length = 3}, - [120] = {.index = 275, .length = 4}, - [121] = {.index = 279, .length = 4}, - [122] = {.index = 283, .length = 4}, - [123] = {.index = 287, .length = 5}, - [124] = {.index = 292, .length = 5}, - [125] = {.index = 297, .length = 3}, - [126] = {.index = 300, .length = 3}, - [127] = {.index = 303, .length = 3}, - [128] = {.index = 306, .length = 4}, - [129] = {.index = 310, .length = 4}, - [130] = {.index = 314, .length = 4}, - [131] = {.index = 318, .length = 4}, - [132] = {.index = 322, .length = 5}, + [8] = {.index = 10, .length = 2}, + [9] = {.index = 12, .length = 3}, + [10] = {.index = 15, .length = 2}, + [11] = {.index = 17, .length = 2}, + [12] = {.index = 19, .length = 3}, + [13] = {.index = 22, .length = 1}, + [14] = {.index = 23, .length = 2}, + [15] = {.index = 25, .length = 1}, + [16] = {.index = 26, .length = 1}, + [17] = {.index = 27, .length = 2}, + [18] = {.index = 29, .length = 2}, + [19] = {.index = 31, .length = 3}, + [20] = {.index = 34, .length = 2}, + [21] = {.index = 36, .length = 1}, + [22] = {.index = 37, .length = 2}, + [23] = {.index = 39, .length = 1}, + [24] = {.index = 40, .length = 1}, + [25] = {.index = 41, .length = 1}, + [26] = {.index = 42, .length = 2}, + [27] = {.index = 44, .length = 1}, + [28] = {.index = 45, .length = 2}, + [29] = {.index = 47, .length = 1}, + [30] = {.index = 48, .length = 1}, + [31] = {.index = 49, .length = 2}, + [32] = {.index = 51, .length = 2}, + [33] = {.index = 53, .length = 2}, + [34] = {.index = 55, .length = 3}, + [35] = {.index = 58, .length = 1}, + [36] = {.index = 59, .length = 2}, + [37] = {.index = 61, .length = 2}, + [38] = {.index = 63, .length = 1}, + [39] = {.index = 64, .length = 2}, + [40] = {.index = 66, .length = 2}, + [41] = {.index = 68, .length = 1}, + [42] = {.index = 69, .length = 2}, + [43] = {.index = 71, .length = 3}, + [44] = {.index = 74, .length = 1}, + [45] = {.index = 75, .length = 3}, + [46] = {.index = 78, .length = 3}, + [47] = {.index = 81, .length = 3}, + [48] = {.index = 84, .length = 2}, + [49] = {.index = 86, .length = 2}, + [50] = {.index = 88, .length = 4}, + [51] = {.index = 92, .length = 1}, + [52] = {.index = 93, .length = 2}, + [53] = {.index = 95, .length = 3}, + [54] = {.index = 98, .length = 3}, + [55] = {.index = 101, .length = 2}, + [56] = {.index = 103, .length = 2}, + [57] = {.index = 105, .length = 2}, + [58] = {.index = 107, .length = 2}, + [59] = {.index = 109, .length = 2}, + [60] = {.index = 111, .length = 4}, + [61] = {.index = 115, .length = 2}, + [62] = {.index = 117, .length = 1}, + [63] = {.index = 118, .length = 2}, + [64] = {.index = 120, .length = 2}, + [65] = {.index = 122, .length = 2}, + [66] = {.index = 124, .length = 2}, + [67] = {.index = 126, .length = 1}, + [68] = {.index = 127, .length = 3}, + [69] = {.index = 130, .length = 3}, + [70] = {.index = 133, .length = 2}, + [71] = {.index = 135, .length = 1}, + [72] = {.index = 136, .length = 3}, + [73] = {.index = 139, .length = 3}, + [74] = {.index = 142, .length = 3}, + [75] = {.index = 145, .length = 4}, + [76] = {.index = 149, .length = 2}, + [77] = {.index = 151, .length = 3}, + [78] = {.index = 154, .length = 2}, + [79] = {.index = 156, .length = 3}, + [80] = {.index = 159, .length = 2}, + [81] = {.index = 161, .length = 2}, + [82] = {.index = 163, .length = 4}, + [83] = {.index = 167, .length = 2}, + [84] = {.index = 169, .length = 3}, + [85] = {.index = 172, .length = 3}, + [86] = {.index = 175, .length = 2}, + [87] = {.index = 177, .length = 4}, + [88] = {.index = 181, .length = 1}, + [89] = {.index = 182, .length = 3}, + [90] = {.index = 185, .length = 3}, + [91] = {.index = 188, .length = 4}, + [92] = {.index = 192, .length = 4}, + [93] = {.index = 196, .length = 4}, + [94] = {.index = 200, .length = 3}, + [95] = {.index = 203, .length = 2}, + [96] = {.index = 205, .length = 2}, + [97] = {.index = 207, .length = 2}, + [98] = {.index = 209, .length = 3}, + [99] = {.index = 212, .length = 1}, + [100] = {.index = 213, .length = 3}, + [101] = {.index = 216, .length = 3}, + [102] = {.index = 219, .length = 3}, + [103] = {.index = 222, .length = 4}, + [104] = {.index = 226, .length = 2}, + [105] = {.index = 228, .length = 3}, + [106] = {.index = 231, .length = 2}, + [107] = {.index = 233, .length = 3}, + [108] = {.index = 236, .length = 4}, + [109] = {.index = 240, .length = 4}, + [110] = {.index = 244, .length = 4}, + [111] = {.index = 248, .length = 4}, + [112] = {.index = 252, .length = 5}, + [113] = {.index = 257, .length = 3}, + [114] = {.index = 260, .length = 3}, + [115] = {.index = 263, .length = 2}, + [116] = {.index = 265, .length = 3}, + [117] = {.index = 268, .length = 3}, + [118] = {.index = 271, .length = 3}, + [119] = {.index = 274, .length = 3}, + [120] = {.index = 277, .length = 4}, + [121] = {.index = 281, .length = 4}, + [122] = {.index = 285, .length = 4}, + [123] = {.index = 289, .length = 3}, + [124] = {.index = 292, .length = 4}, + [125] = {.index = 296, .length = 4}, + [126] = {.index = 300, .length = 4}, + [127] = {.index = 304, .length = 5}, + [128] = {.index = 309, .length = 5}, + [129] = {.index = 314, .length = 3}, + [130] = {.index = 317, .length = 3}, + [131] = {.index = 320, .length = 3}, + [132] = {.index = 323, .length = 4}, [133] = {.index = 327, .length = 4}, - [134] = {.index = 331, .length = 5}, - [135] = {.index = 336, .length = 5}, - [136] = {.index = 341, .length = 5}, - [137] = {.index = 346, .length = 3}, - [138] = {.index = 349, .length = 3}, - [139] = {.index = 352, .length = 4}, - [140] = {.index = 356, .length = 4}, - [141] = {.index = 360, .length = 4}, - [142] = {.index = 364, .length = 4}, - [143] = {.index = 368, .length = 4}, - [144] = {.index = 372, .length = 5}, - [145] = {.index = 377, .length = 5}, - [146] = {.index = 382, .length = 5}, - [147] = {.index = 387, .length = 5}, - [148] = {.index = 392, .length = 6}, - [149] = {.index = 398, .length = 3}, - [150] = {.index = 401, .length = 4}, - [151] = {.index = 405, .length = 4}, - [152] = {.index = 409, .length = 5}, - [153] = {.index = 414, .length = 5}, - [154] = {.index = 419, .length = 5}, - [155] = {.index = 424, .length = 6}, - [156] = {.index = 430, .length = 4}, - [157] = {.index = 434, .length = 4}, - [158] = {.index = 438, .length = 5}, - [159] = {.index = 443, .length = 5}, - [160] = {.index = 448, .length = 6}, - [161] = {.index = 454, .length = 5}, - [162] = {.index = 459, .length = 6}, + [134] = {.index = 331, .length = 4}, + [135] = {.index = 335, .length = 4}, + [136] = {.index = 339, .length = 5}, + [137] = {.index = 344, .length = 4}, + [138] = {.index = 348, .length = 5}, + [139] = {.index = 353, .length = 5}, + [140] = {.index = 358, .length = 5}, + [141] = {.index = 363, .length = 3}, + [142] = {.index = 366, .length = 3}, + [143] = {.index = 369, .length = 4}, + [144] = {.index = 373, .length = 4}, + [145] = {.index = 377, .length = 4}, + [146] = {.index = 381, .length = 4}, + [147] = {.index = 385, .length = 4}, + [148] = {.index = 389, .length = 5}, + [149] = {.index = 394, .length = 5}, + [150] = {.index = 399, .length = 5}, + [151] = {.index = 404, .length = 5}, + [152] = {.index = 409, .length = 6}, + [153] = {.index = 415, .length = 3}, + [154] = {.index = 418, .length = 4}, + [155] = {.index = 422, .length = 4}, + [156] = {.index = 426, .length = 5}, + [157] = {.index = 431, .length = 5}, + [158] = {.index = 436, .length = 5}, + [159] = {.index = 441, .length = 6}, + [160] = {.index = 447, .length = 4}, + [161] = {.index = 451, .length = 4}, + [162] = {.index = 455, .length = 5}, + [163] = {.index = 460, .length = 5}, + [164] = {.index = 465, .length = 6}, + [165] = {.index = 471, .length = 5}, + [166] = {.index = 476, .length = 6}, }; static const TSFieldMapEntry ts_field_map_entries[] = { @@ -1682,609 +1686,630 @@ static const TSFieldMapEntry ts_field_map_entries[] = { {field_namespace, 0}, {field_segment, 1, .inherited = true}, [10] = + {field_keyword, 0}, {field_name, 1}, - [11] = + [12] = {field_body, 2}, + {field_keyword, 0}, {field_name, 1}, - [13] = + [15] = {field_name, 0}, {field_value, 2}, - [15] = + [17] = {field_callee, 0}, {field_member, 2}, - [17] = + [19] = {field_left, 0}, {field_operator, 1}, {field_right, 2}, - [20] = + [22] = {field_callee, 0}, - [21] = + [23] = {field_left, 0}, {field_right, 2}, - [23] = + [25] = {field_alias, 1}, - [24] = + [26] = {field_segment, 1}, - [25] = + [27] = {field_segment, 0, .inherited = true}, {field_segment, 1, .inherited = true}, - [27] = + [29] = {field_key, 0}, {field_value, 2}, - [29] = + [31] = {field_keyword, 0}, {field_name, 1}, {field_value, 3}, - [32] = + [34] = {field_definition, 3}, {field_name, 1}, - [34] = + [36] = {field_body, 3}, - [35] = + [37] = {field_name, 0}, {field_type, 2}, - [37] = + [39] = + {field_name, 1}, + [40] = {field_value, 1}, - [38] = + [41] = {field_operator, 0}, - [39] = + [42] = {field_binding, 1}, {field_name, 0}, - [41] = + [44] = {field_value, 2}, - [42] = + [45] = + {field_keyword, 0}, {field_path, 1}, - [43] = + [47] = + {field_path, 1}, + [48] = {field_record, 0}, - [44] = + [49] = {field_condition, 0}, {field_else, 3}, - [46] = + [51] = {field_callee, 0}, {field_index, 2}, - [48] = + [53] = + {field_keyword, 1}, {field_name, 2}, - [49] = + [55] = {field_body, 3}, + {field_keyword, 1}, {field_name, 2}, - [51] = + [58] = {field_body, 4}, - [52] = + [59] = {field_name, 1}, {field_variance, 0}, - [54] = + [61] = {field_body, 4}, {field_name, 1}, - [56] = + [63] = + {field_name, 2}, + [64] = {field_body, 2}, {field_operation, 0}, - [58] = + [66] = {field_body, 4}, {field_effect, 1}, - [60] = + [68] = {field_element, 1}, - [61] = + [69] = {field_body, 2}, {field_pattern, 0}, - [63] = + [71] = + {field_keyword, 1}, {field_path, 2}, {field_state, 0}, - [65] = + [74] = {field_declaration, 1}, - [66] = + [75] = + {field_keyword, 0}, {field_path, 1}, {field_signature, 2}, - [68] = + [78] = {field_condition, 0}, {field_else, 4}, {field_then, 2}, - [71] = + [81] = {field_keyword, 1}, {field_name, 2}, {field_value, 4}, - [74] = + [84] = {field_definition, 4}, {field_name, 2}, - [76] = + [86] = + {field_keyword, 1}, {field_path, 2}, - [77] = + [88] = {field_keyword, 0}, {field_name, 1}, {field_type, 3}, {field_value, 5}, - [81] = + [92] = {field_body, 5}, - [82] = + [93] = {field_body, 5}, {field_name, 1}, - [84] = + [95] = {field_body, 5}, {field_effects, 4}, {field_name, 1}, - [87] = + [98] = {field_body, 5}, {field_name, 1}, {field_parameters, 3}, - [90] = + [101] = {field_name, 2}, {field_parameters, 4}, - [92] = + [103] = {field_body, 3}, {field_operation, 0}, - [94] = + [105] = {field_element, 1}, {field_element, 2, .inherited = true}, - [96] = + [107] = {field_element, 0, .inherited = true}, {field_element, 1, .inherited = true}, - [98] = + [109] = {field_effect, 1}, {field_operation, 3}, - [100] = + [111] = + {field_keyword, 1}, {field_path, 2}, {field_signature, 3}, {field_state, 0}, - [103] = + [115] = {field_declaration, 2}, {field_opaque, 1}, - [105] = + [117] = {field_declaration, 2}, - [106] = + [118] = {field_extra, 3}, {field_path, 1}, - [108] = + [120] = + {field_path, 1}, + {field_signature, 2}, + [122] = {field_name, 2}, {field_opaque, 0}, - [110] = + [124] = {field_body, 5}, {field_name, 2}, - [112] = + [126] = {field_name, 3}, - [113] = + [127] = + {field_keyword, 2}, {field_path, 3}, {field_state, 1}, - [115] = + [130] = + {field_keyword, 1}, {field_path, 2}, {field_signature, 3}, - [117] = + [133] = {field_alias, 2}, {field_name, 0}, - [119] = + [135] = {field_body, 6}, - [120] = + [136] = {field_body, 6}, {field_name, 1}, {field_return_type, 5}, - [123] = + [139] = {field_body, 6}, {field_effects, 4}, {field_name, 1}, - [126] = + [142] = {field_body, 6}, {field_name, 1}, {field_parameters, 3}, - [129] = + [145] = {field_body, 6}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [133] = + [149] = {field_name, 2}, {field_return_type, 6}, - [135] = + [151] = {field_definition, 6}, {field_name, 1}, {field_type_parameters, 3}, - [138] = + [154] = {field_name, 1}, {field_type_parameters, 3}, - [140] = + [156] = {field_alternative, 6}, {field_condition, 1}, {field_consequence, 3}, - [143] = + [159] = {field_declaration, 3}, {field_opaque, 2}, - [145] = + [161] = {field_name, 1}, {field_type, 3}, - [147] = + [163] = {field_keyword, 1}, {field_name, 2}, {field_type, 4}, {field_value, 6}, - [151] = + [167] = {field_body, 6}, {field_name, 2}, - [153] = + [169] = {field_body, 6}, {field_effects, 5}, {field_name, 2}, - [156] = + [172] = {field_body, 6}, {field_name, 2}, {field_parameters, 4}, - [159] = + [175] = {field_name, 3}, {field_parameters, 5}, - [161] = + [177] = + {field_keyword, 2}, {field_path, 3}, {field_signature, 4}, {field_state, 1}, - [164] = + [181] = {field_body, 7}, - [165] = + [182] = {field_body, 7}, {field_name, 1}, {field_type_parameters, 3}, - [168] = + [185] = {field_body, 7}, {field_name, 1}, {field_return_type, 5}, - [171] = + [188] = {field_body, 7}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [175] = + [192] = {field_body, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [179] = + [196] = {field_body, 7}, {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [183] = + [200] = {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [186] = + [203] = {field_element, 1}, {field_rest, 4}, - [188] = + [205] = {field_effects, 4}, {field_name, 1}, - [190] = + [207] = {field_name, 1}, {field_parameters, 3}, - [192] = + [209] = {field_definition, 4}, {field_name, 2}, {field_opaque, 0}, - [195] = + [212] = {field_condition, 0}, - [196] = + [213] = {field_body, 7}, {field_name, 2}, {field_return_type, 6}, - [199] = + [216] = {field_body, 7}, {field_effects, 5}, {field_name, 2}, - [202] = + [219] = {field_body, 7}, {field_name, 2}, {field_parameters, 4}, - [205] = + [222] = {field_body, 7}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [209] = + [226] = {field_name, 3}, {field_return_type, 7}, - [211] = + [228] = {field_definition, 7}, {field_name, 2}, {field_type_parameters, 4}, - [214] = + [231] = {field_name, 2}, {field_type_parameters, 4}, - [216] = + [233] = {field_body, 8}, {field_name, 1}, {field_type_parameters, 3}, - [219] = + [236] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [223] = + [240] = {field_body, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [227] = + [244] = {field_body, 8}, {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [231] = + [248] = {field_body, 8}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [235] = + [252] = {field_body, 8}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [240] = + [257] = {field_alternative, 7}, {field_condition, 1}, {field_consequence, 3}, - [243] = + [260] = {field_element, 1}, {field_element, 2, .inherited = true}, {field_rest, 5}, - [246] = + [263] = {field_name, 1}, {field_return_type, 5}, - [248] = + [265] = {field_effects, 5}, {field_name, 1}, {field_parameters, 3}, - [251] = + [268] = {field_name, 2}, {field_opaque, 0}, {field_type_parameters, 4}, - [254] = + [271] = {field_body, 8}, {field_name, 2}, {field_type_parameters, 4}, - [257] = + [274] = {field_body, 8}, {field_name, 2}, {field_return_type, 6}, - [260] = + [277] = {field_body, 8}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [264] = + [281] = {field_body, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [268] = + [285] = {field_body, 8}, {field_effects, 6}, {field_name, 2}, {field_parameters, 4}, - [272] = + [289] = {field_name, 3}, {field_parameters, 5}, {field_return_type, 8}, - [275] = + [292] = {field_body, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [279] = + [296] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [283] = + [300] = {field_body, 9}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [287] = + [304] = {field_body, 9}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [292] = + [309] = {field_body, 9}, {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [297] = + [314] = {field_effects, 6}, {field_name, 1}, {field_return_type, 5}, - [300] = + [317] = {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [303] = + [320] = {field_body, 9}, {field_name, 2}, {field_type_parameters, 4}, - [306] = + [323] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [310] = + [327] = {field_body, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [314] = + [331] = {field_body, 9}, {field_effects, 7}, {field_name, 2}, {field_return_type, 6}, - [318] = + [335] = {field_body, 9}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [322] = + [339] = {field_body, 9}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [327] = + [344] = {field_body, 10}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [331] = + [348] = {field_body, 10}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [336] = + [353] = {field_body, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [341] = + [358] = {field_body, 10}, {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [346] = + [363] = {field_effects, 7}, {field_name, 1}, {field_type_parameters, 3}, - [349] = + [366] = {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [352] = + [369] = {field_effects, 7}, {field_name, 1}, {field_parameters, 3}, {field_return_type, 6}, - [356] = + [373] = {field_definition, 7}, {field_name, 2}, {field_opaque, 0}, {field_type_parameters, 4}, - [360] = + [377] = {field_body, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [364] = + [381] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_type_parameters, 4}, - [368] = + [385] = {field_body, 10}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [372] = + [389] = {field_body, 10}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [377] = + [394] = {field_body, 10}, {field_effects, 8}, {field_name, 2}, {field_parameters, 4}, {field_return_type, 7}, - [382] = + [399] = {field_body, 11}, {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [387] = + [404] = {field_body, 11}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [392] = + [409] = {field_body, 11}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [398] = + [415] = {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [401] = + [418] = {field_effects, 8}, {field_name, 1}, {field_parameters, 6}, {field_type_parameters, 3}, - [405] = + [422] = {field_body, 11}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [409] = + [426] = {field_body, 11}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [414] = + [431] = {field_body, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [419] = + [436] = {field_body, 11}, {field_effects, 9}, {field_name, 2}, {field_parameters, 7}, {field_type_parameters, 4}, - [424] = + [441] = {field_body, 12}, {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [430] = + [447] = {field_effects, 9}, {field_name, 1}, {field_return_type, 8}, {field_type_parameters, 3}, - [434] = + [451] = {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [438] = + [455] = {field_body, 12}, {field_effects, 10}, {field_name, 2}, {field_return_type, 9}, {field_type_parameters, 4}, - [443] = + [460] = {field_body, 12}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [448] = + [465] = {field_body, 12}, {field_effects, 11}, {field_name, 2}, {field_parameters, 7}, {field_return_type, 10}, {field_type_parameters, 4}, - [454] = + [471] = {field_effects, 10}, {field_name, 1}, {field_parameters, 6}, {field_return_type, 9}, {field_type_parameters, 3}, - [459] = + [476] = {field_body, 13}, {field_effects, 11}, {field_name, 2}, @@ -43895,7 +43920,7 @@ static const uint16_t ts_small_parse_table[] = { [43701] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1051), 11, + ACTIONS(1052), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -43907,7 +43932,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1053), 30, + ACTIONS(1054), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -43941,11 +43966,11 @@ static const uint16_t ts_small_parse_table[] = { [43750] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1059), 1, + ACTIONS(1060), 1, anon_sym_COLON_COLON, STATE(494), 1, aux_sym_import_target_repeat1, - ACTIONS(1055), 10, + ACTIONS(1056), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -43956,7 +43981,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1057), 29, + ACTIONS(1058), 29, anon_sym_import, anon_sym_as, anon_sym_namespace, @@ -43989,11 +44014,11 @@ static const uint16_t ts_small_parse_table[] = { [43803] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1062), 1, + ACTIONS(1063), 1, anon_sym_COLON_COLON, STATE(495), 1, aux_sym_import_target_repeat1, - ACTIONS(1055), 10, + ACTIONS(1056), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -44004,7 +44029,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1057), 29, + ACTIONS(1058), 29, anon_sym_import, anon_sym_as, anon_sym_namespace, @@ -44037,7 +44062,7 @@ static const uint16_t ts_small_parse_table[] = { [43856] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1065), 11, + ACTIONS(1066), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44049,7 +44074,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1067), 30, + ACTIONS(1068), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44083,11 +44108,11 @@ static const uint16_t ts_small_parse_table[] = { [43905] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1049), 1, + ACTIONS(1074), 1, anon_sym_COLON_COLON, STATE(494), 1, aux_sym_import_target_repeat1, - ACTIONS(1069), 10, + ACTIONS(1070), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -44098,7 +44123,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1071), 29, + ACTIONS(1072), 29, anon_sym_import, anon_sym_as, anon_sym_namespace, @@ -44177,7 +44202,7 @@ static const uint16_t ts_small_parse_table[] = { [44007] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1073), 11, + ACTIONS(1077), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44189,7 +44214,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1075), 30, + ACTIONS(1079), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44223,11 +44248,11 @@ static const uint16_t ts_small_parse_table[] = { [44056] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1077), 1, + ACTIONS(1081), 1, anon_sym_COLON_COLON, STATE(495), 1, aux_sym_import_target_repeat1, - ACTIONS(1069), 10, + ACTIONS(1070), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -44238,7 +44263,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1071), 29, + ACTIONS(1072), 29, anon_sym_import, anon_sym_as, anon_sym_namespace, @@ -44366,7 +44391,7 @@ static const uint16_t ts_small_parse_table[] = { [44213] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1079), 11, + ACTIONS(1084), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44378,7 +44403,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1081), 30, + ACTIONS(1086), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44412,7 +44437,7 @@ static const uint16_t ts_small_parse_table[] = { [44262] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1083), 11, + ACTIONS(1088), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44424,7 +44449,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1085), 30, + ACTIONS(1090), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44458,7 +44483,7 @@ static const uint16_t ts_small_parse_table[] = { [44311] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1087), 11, + ACTIONS(1092), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44470,7 +44495,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1089), 30, + ACTIONS(1094), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44504,13 +44529,13 @@ static const uint16_t ts_small_parse_table[] = { [44360] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1095), 1, + ACTIONS(1100), 1, anon_sym_COLON_COLON, - ACTIONS(1097), 1, + ACTIONS(1102), 1, anon_sym_as, STATE(642), 1, sym_import_tail, - ACTIONS(1091), 10, + ACTIONS(1096), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -44521,7 +44546,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1093), 28, + ACTIONS(1098), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44553,7 +44578,7 @@ static const uint16_t ts_small_parse_table[] = { [44415] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1099), 11, + ACTIONS(1104), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44565,7 +44590,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1101), 30, + ACTIONS(1106), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44599,13 +44624,13 @@ static const uint16_t ts_small_parse_table[] = { [44464] = 6, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1103), 1, + ACTIONS(1108), 1, anon_sym_COLON_COLON, - ACTIONS(1105), 1, + ACTIONS(1110), 1, anon_sym_as, STATE(624), 1, sym_import_tail, - ACTIONS(1091), 10, + ACTIONS(1096), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -44616,7 +44641,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1093), 28, + ACTIONS(1098), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44648,7 +44673,7 @@ static const uint16_t ts_small_parse_table[] = { [44519] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1077), 1, + ACTIONS(1112), 1, anon_sym_COLON_COLON, STATE(500), 1, aux_sym_import_target_repeat1, @@ -44743,7 +44768,7 @@ static const uint16_t ts_small_parse_table[] = { [44623] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1107), 11, + ACTIONS(1115), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44755,7 +44780,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1109), 30, + ACTIONS(1117), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44789,7 +44814,7 @@ static const uint16_t ts_small_parse_table[] = { [44672] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1111), 11, + ACTIONS(1119), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44801,7 +44826,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1113), 30, + ACTIONS(1121), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44835,7 +44860,7 @@ static const uint16_t ts_small_parse_table[] = { [44721] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1115), 11, + ACTIONS(1123), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44847,7 +44872,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1117), 30, + ACTIONS(1125), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44881,7 +44906,7 @@ static const uint16_t ts_small_parse_table[] = { [44770] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1119), 11, + ACTIONS(1127), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44893,7 +44918,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1121), 30, + ACTIONS(1129), 30, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44927,7 +44952,7 @@ static const uint16_t ts_small_parse_table[] = { [44819] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1123), 11, + ACTIONS(1131), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44939,7 +44964,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1125), 29, + ACTIONS(1133), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -44972,7 +44997,7 @@ static const uint16_t ts_small_parse_table[] = { [44867] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1127), 11, + ACTIONS(1135), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -44984,7 +45009,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1129), 29, + ACTIONS(1137), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45017,7 +45042,7 @@ static const uint16_t ts_small_parse_table[] = { [44915] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1131), 11, + ACTIONS(1139), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45029,7 +45054,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1133), 29, + ACTIONS(1141), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45062,7 +45087,7 @@ static const uint16_t ts_small_parse_table[] = { [44963] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1135), 11, + ACTIONS(1143), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45074,7 +45099,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1137), 29, + ACTIONS(1145), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45107,7 +45132,7 @@ static const uint16_t ts_small_parse_table[] = { [45011] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1139), 11, + ACTIONS(1147), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45119,7 +45144,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1141), 29, + ACTIONS(1149), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45152,7 +45177,7 @@ static const uint16_t ts_small_parse_table[] = { [45059] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1143), 11, + ACTIONS(1151), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45164,7 +45189,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1145), 29, + ACTIONS(1153), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45197,7 +45222,7 @@ static const uint16_t ts_small_parse_table[] = { [45107] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1147), 1, + ACTIONS(1155), 1, anon_sym_where, STATE(696), 1, sym_type_validation, @@ -45244,7 +45269,7 @@ static const uint16_t ts_small_parse_table[] = { [45159] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1149), 11, + ACTIONS(1157), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45256,7 +45281,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1151), 29, + ACTIONS(1159), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45289,7 +45314,7 @@ static const uint16_t ts_small_parse_table[] = { [45207] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1153), 11, + ACTIONS(1161), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45301,7 +45326,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1155), 29, + ACTIONS(1163), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45334,7 +45359,7 @@ static const uint16_t ts_small_parse_table[] = { [45255] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1157), 11, + ACTIONS(1165), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45346,7 +45371,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1159), 29, + ACTIONS(1167), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45379,7 +45404,7 @@ static const uint16_t ts_small_parse_table[] = { [45303] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1161), 11, + ACTIONS(1169), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45391,7 +45416,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1163), 29, + ACTIONS(1171), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45424,7 +45449,7 @@ static const uint16_t ts_small_parse_table[] = { [45351] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1165), 11, + ACTIONS(1173), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45436,7 +45461,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1167), 29, + ACTIONS(1175), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45469,7 +45494,7 @@ static const uint16_t ts_small_parse_table[] = { [45399] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1169), 11, + ACTIONS(1177), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45481,7 +45506,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1171), 29, + ACTIONS(1179), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45518,7 +45543,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DOT, STATE(565), 1, aux_sym_legacy_import_path_repeat1, - ACTIONS(1175), 10, + ACTIONS(1183), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -45529,7 +45554,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1173), 28, + ACTIONS(1181), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45561,7 +45586,7 @@ static const uint16_t ts_small_parse_table[] = { [45499] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1177), 11, + ACTIONS(1185), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45573,7 +45598,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1179), 29, + ACTIONS(1187), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45606,7 +45631,7 @@ static const uint16_t ts_small_parse_table[] = { [45547] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1181), 11, + ACTIONS(1189), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45618,7 +45643,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1183), 29, + ACTIONS(1191), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45651,7 +45676,7 @@ static const uint16_t ts_small_parse_table[] = { [45595] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1147), 1, + ACTIONS(1155), 1, anon_sym_where, STATE(681), 1, sym_type_validation, @@ -45698,7 +45723,7 @@ static const uint16_t ts_small_parse_table[] = { [45647] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1185), 11, + ACTIONS(1193), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45710,7 +45735,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1187), 29, + ACTIONS(1195), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45743,7 +45768,7 @@ static const uint16_t ts_small_parse_table[] = { [45695] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1189), 11, + ACTIONS(1197), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45755,7 +45780,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1191), 29, + ACTIONS(1199), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45788,7 +45813,7 @@ static const uint16_t ts_small_parse_table[] = { [45743] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1193), 11, + ACTIONS(1201), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45800,7 +45825,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1195), 29, + ACTIONS(1203), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45833,7 +45858,7 @@ static const uint16_t ts_small_parse_table[] = { [45791] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1197), 11, + ACTIONS(1205), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45845,7 +45870,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1199), 29, + ACTIONS(1207), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45925,7 +45950,7 @@ static const uint16_t ts_small_parse_table[] = { [45891] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1201), 11, + ACTIONS(1209), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -45937,7 +45962,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1203), 29, + ACTIONS(1211), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -45970,7 +45995,7 @@ static const uint16_t ts_small_parse_table[] = { [45939] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1205), 1, + ACTIONS(1213), 1, anon_sym_PIPE, STATE(538), 1, aux_sym_union_type_repeat1, @@ -46066,7 +46091,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DOT, STATE(561), 1, aux_sym_legacy_import_path_repeat1, - ACTIONS(1175), 10, + ACTIONS(1183), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -46077,7 +46102,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1173), 28, + ACTIONS(1181), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46156,7 +46181,7 @@ static const uint16_t ts_small_parse_table[] = { [46143] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1208), 11, + ACTIONS(1216), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46168,7 +46193,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1210), 29, + ACTIONS(1218), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46201,7 +46226,7 @@ static const uint16_t ts_small_parse_table[] = { [46191] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1212), 11, + ACTIONS(1220), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46213,7 +46238,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1214), 29, + ACTIONS(1222), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46246,7 +46271,7 @@ static const uint16_t ts_small_parse_table[] = { [46239] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1216), 11, + ACTIONS(1224), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46258,7 +46283,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1218), 29, + ACTIONS(1226), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46291,7 +46316,7 @@ static const uint16_t ts_small_parse_table[] = { [46287] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1220), 11, + ACTIONS(1228), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46303,7 +46328,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1222), 29, + ACTIONS(1230), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46336,7 +46361,7 @@ static const uint16_t ts_small_parse_table[] = { [46335] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1224), 11, + ACTIONS(1232), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46348,7 +46373,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1226), 29, + ACTIONS(1234), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46381,7 +46406,7 @@ static const uint16_t ts_small_parse_table[] = { [46383] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1228), 11, + ACTIONS(1236), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46393,7 +46418,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1230), 29, + ACTIONS(1238), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46426,7 +46451,7 @@ static const uint16_t ts_small_parse_table[] = { [46431] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1232), 11, + ACTIONS(1240), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46438,7 +46463,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1234), 29, + ACTIONS(1242), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46471,7 +46496,7 @@ static const uint16_t ts_small_parse_table[] = { [46479] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1236), 11, + ACTIONS(1244), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46483,7 +46508,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1238), 29, + ACTIONS(1246), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46516,7 +46541,7 @@ static const uint16_t ts_small_parse_table[] = { [46527] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1240), 11, + ACTIONS(1248), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46528,7 +46553,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1242), 29, + ACTIONS(1250), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46561,7 +46586,7 @@ static const uint16_t ts_small_parse_table[] = { [46575] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1244), 1, + ACTIONS(1252), 1, anon_sym_PIPE, STATE(538), 1, aux_sym_union_type_repeat1, @@ -46608,7 +46633,7 @@ static const uint16_t ts_small_parse_table[] = { [46627] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1246), 11, + ACTIONS(1254), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46620,7 +46645,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1248), 29, + ACTIONS(1256), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46653,7 +46678,7 @@ static const uint16_t ts_small_parse_table[] = { [46675] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1250), 11, + ACTIONS(1258), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46665,7 +46690,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1252), 29, + ACTIONS(1260), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46698,7 +46723,7 @@ static const uint16_t ts_small_parse_table[] = { [46723] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1254), 11, + ACTIONS(1262), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46710,7 +46735,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1256), 29, + ACTIONS(1264), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46743,7 +46768,7 @@ static const uint16_t ts_small_parse_table[] = { [46771] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1258), 11, + ACTIONS(1266), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46755,7 +46780,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1260), 29, + ACTIONS(1268), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46788,7 +46813,7 @@ static const uint16_t ts_small_parse_table[] = { [46819] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1262), 11, + ACTIONS(1270), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46800,7 +46825,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1264), 29, + ACTIONS(1272), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46878,7 +46903,7 @@ static const uint16_t ts_small_parse_table[] = { [46915] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1266), 11, + ACTIONS(1274), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46890,7 +46915,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1268), 29, + ACTIONS(1276), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46923,7 +46948,7 @@ static const uint16_t ts_small_parse_table[] = { [46963] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1270), 11, + ACTIONS(1278), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46935,7 +46960,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1272), 29, + ACTIONS(1280), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -46968,7 +46993,7 @@ static const uint16_t ts_small_parse_table[] = { [47011] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1274), 11, + ACTIONS(1282), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -46980,7 +47005,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1276), 29, + ACTIONS(1284), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47013,11 +47038,11 @@ static const uint16_t ts_small_parse_table[] = { [47059] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1282), 1, + ACTIONS(1290), 1, anon_sym_DOT, STATE(561), 1, aux_sym_legacy_import_path_repeat1, - ACTIONS(1278), 10, + ACTIONS(1286), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -47028,7 +47053,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1280), 28, + ACTIONS(1288), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47060,7 +47085,7 @@ static const uint16_t ts_small_parse_table[] = { [47111] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1285), 11, + ACTIONS(1293), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47072,7 +47097,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1287), 29, + ACTIONS(1295), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47105,7 +47130,7 @@ static const uint16_t ts_small_parse_table[] = { [47159] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1289), 11, + ACTIONS(1297), 11, ts_builtin_sym_end, anon_sym_COLON_COLON, anon_sym_LBRACE, @@ -47117,7 +47142,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1291), 29, + ACTIONS(1299), 29, anon_sym_import, anon_sym_as, anon_sym_namespace, @@ -47150,7 +47175,7 @@ static const uint16_t ts_small_parse_table[] = { [47207] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1293), 11, + ACTIONS(1301), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47162,7 +47187,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1295), 29, + ACTIONS(1303), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47195,11 +47220,11 @@ static const uint16_t ts_small_parse_table[] = { [47255] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1297), 1, + ACTIONS(1305), 1, anon_sym_DOT, STATE(565), 1, aux_sym_legacy_import_path_repeat1, - ACTIONS(1278), 10, + ACTIONS(1286), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -47210,7 +47235,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1280), 28, + ACTIONS(1288), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47242,7 +47267,7 @@ static const uint16_t ts_small_parse_table[] = { [47307] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1289), 11, + ACTIONS(1297), 11, anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47254,7 +47279,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1291), 29, + ACTIONS(1299), 29, anon_sym_import, anon_sym_as, anon_sym_namespace, @@ -47287,7 +47312,7 @@ static const uint16_t ts_small_parse_table[] = { [47355] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1300), 11, + ACTIONS(1308), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47299,7 +47324,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1302), 29, + ACTIONS(1310), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47332,7 +47357,7 @@ static const uint16_t ts_small_parse_table[] = { [47403] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1304), 11, + ACTIONS(1312), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47344,7 +47369,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1306), 29, + ACTIONS(1314), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47377,7 +47402,7 @@ static const uint16_t ts_small_parse_table[] = { [47451] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1308), 11, + ACTIONS(1316), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47389,7 +47414,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1310), 29, + ACTIONS(1318), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47422,7 +47447,7 @@ static const uint16_t ts_small_parse_table[] = { [47499] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1147), 1, + ACTIONS(1155), 1, anon_sym_where, STATE(661), 1, sym_type_validation, @@ -47469,7 +47494,7 @@ static const uint16_t ts_small_parse_table[] = { [47551] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1312), 11, + ACTIONS(1320), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47481,7 +47506,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1314), 29, + ACTIONS(1322), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47514,7 +47539,7 @@ static const uint16_t ts_small_parse_table[] = { [47599] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1316), 11, + ACTIONS(1324), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47526,7 +47551,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1318), 29, + ACTIONS(1326), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47559,7 +47584,7 @@ static const uint16_t ts_small_parse_table[] = { [47647] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1320), 11, + ACTIONS(1328), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47571,7 +47596,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1322), 29, + ACTIONS(1330), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47604,7 +47629,7 @@ static const uint16_t ts_small_parse_table[] = { [47695] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1324), 11, + ACTIONS(1332), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47616,7 +47641,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1326), 29, + ACTIONS(1334), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47649,7 +47674,7 @@ static const uint16_t ts_small_parse_table[] = { [47743] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1328), 11, + ACTIONS(1336), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47661,7 +47686,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1330), 29, + ACTIONS(1338), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47741,7 +47766,7 @@ static const uint16_t ts_small_parse_table[] = { [47843] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1147), 1, + ACTIONS(1155), 1, anon_sym_where, STATE(643), 1, sym_type_validation, @@ -47788,7 +47813,7 @@ static const uint16_t ts_small_parse_table[] = { [47895] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1244), 1, + ACTIONS(1252), 1, anon_sym_PIPE, STATE(551), 1, aux_sym_union_type_repeat1, @@ -47882,7 +47907,7 @@ static const uint16_t ts_small_parse_table[] = { [47999] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1332), 11, + ACTIONS(1340), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47894,7 +47919,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1334), 29, + ACTIONS(1342), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47927,7 +47952,7 @@ static const uint16_t ts_small_parse_table[] = { [48047] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1336), 11, + ACTIONS(1344), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47939,7 +47964,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1338), 29, + ACTIONS(1346), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -47972,7 +47997,7 @@ static const uint16_t ts_small_parse_table[] = { [48095] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1340), 11, + ACTIONS(1348), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -47984,7 +48009,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1342), 29, + ACTIONS(1350), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48017,7 +48042,7 @@ static const uint16_t ts_small_parse_table[] = { [48143] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1344), 11, + ACTIONS(1352), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48029,7 +48054,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1346), 29, + ACTIONS(1354), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48062,7 +48087,7 @@ static const uint16_t ts_small_parse_table[] = { [48191] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1348), 11, + ACTIONS(1356), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48074,7 +48099,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1350), 29, + ACTIONS(1358), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48107,7 +48132,7 @@ static const uint16_t ts_small_parse_table[] = { [48239] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1352), 11, + ACTIONS(1360), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48119,7 +48144,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1354), 29, + ACTIONS(1362), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48152,7 +48177,7 @@ static const uint16_t ts_small_parse_table[] = { [48287] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1356), 11, + ACTIONS(1364), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48164,7 +48189,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1358), 29, + ACTIONS(1366), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48197,7 +48222,7 @@ static const uint16_t ts_small_parse_table[] = { [48335] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1360), 11, + ACTIONS(1368), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48209,7 +48234,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1362), 29, + ACTIONS(1370), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48242,7 +48267,7 @@ static const uint16_t ts_small_parse_table[] = { [48383] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1364), 11, + ACTIONS(1372), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48254,7 +48279,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1366), 29, + ACTIONS(1374), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48287,7 +48312,7 @@ static const uint16_t ts_small_parse_table[] = { [48431] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1368), 11, + ACTIONS(1376), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48299,7 +48324,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1370), 29, + ACTIONS(1378), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48332,7 +48357,7 @@ static const uint16_t ts_small_parse_table[] = { [48479] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1372), 11, + ACTIONS(1380), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48344,7 +48369,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1374), 29, + ACTIONS(1382), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48377,7 +48402,7 @@ static const uint16_t ts_small_parse_table[] = { [48527] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1376), 11, + ACTIONS(1384), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48389,7 +48414,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1378), 29, + ACTIONS(1386), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48422,7 +48447,7 @@ static const uint16_t ts_small_parse_table[] = { [48575] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1380), 11, + ACTIONS(1388), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48434,7 +48459,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1382), 29, + ACTIONS(1390), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48467,7 +48492,7 @@ static const uint16_t ts_small_parse_table[] = { [48623] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1384), 11, + ACTIONS(1392), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48479,7 +48504,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1386), 29, + ACTIONS(1394), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48512,7 +48537,7 @@ static const uint16_t ts_small_parse_table[] = { [48671] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1388), 11, + ACTIONS(1396), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48524,7 +48549,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1390), 29, + ACTIONS(1398), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48557,7 +48582,7 @@ static const uint16_t ts_small_parse_table[] = { [48719] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1392), 11, + ACTIONS(1400), 11, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_RBRACE, @@ -48569,7 +48594,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1394), 29, + ACTIONS(1402), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48646,7 +48671,7 @@ static const uint16_t ts_small_parse_table[] = { [48814] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1278), 11, + ACTIONS(1286), 11, ts_builtin_sym_end, anon_sym_DOT, anon_sym_LBRACE, @@ -48658,7 +48683,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1280), 28, + ACTIONS(1288), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48690,9 +48715,9 @@ static const uint16_t ts_small_parse_table[] = { [48861] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1400), 1, + ACTIONS(1408), 1, anon_sym_DASH_GT, - ACTIONS(1396), 9, + ACTIONS(1404), 9, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -48702,7 +48727,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, sym_float, sym__doc_comment_line, - ACTIONS(1398), 29, + ACTIONS(1406), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48735,9 +48760,9 @@ static const uint16_t ts_small_parse_table[] = { [48910] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1406), 1, + ACTIONS(1414), 1, anon_sym_DASH_GT, - ACTIONS(1404), 9, + ACTIONS(1412), 9, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -48747,7 +48772,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, sym_float, sym__doc_comment_line, - ACTIONS(1402), 29, + ACTIONS(1410), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48824,9 +48849,9 @@ static const uint16_t ts_small_parse_table[] = { [49006] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1412), 1, + ACTIONS(1420), 1, anon_sym_DASH_GT, - ACTIONS(1410), 9, + ACTIONS(1418), 9, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -48836,7 +48861,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, sym_float, sym__doc_comment_line, - ACTIONS(1408), 29, + ACTIONS(1416), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -48869,9 +48894,9 @@ static const uint16_t ts_small_parse_table[] = { [49055] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1414), 1, + ACTIONS(1422), 1, anon_sym_DASH_GT, - ACTIONS(1404), 9, + ACTIONS(1412), 9, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -48881,7 +48906,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, sym_float, sym__doc_comment_line, - ACTIONS(1402), 29, + ACTIONS(1410), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49002,7 +49027,7 @@ static const uint16_t ts_small_parse_table[] = { [49198] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1278), 11, + ACTIONS(1286), 11, anon_sym_DOT, anon_sym_LBRACE, anon_sym_RBRACE, @@ -49014,7 +49039,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1280), 28, + ACTIONS(1288), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49091,7 +49116,7 @@ static const uint16_t ts_small_parse_table[] = { [49294] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1099), 10, + ACTIONS(1104), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49102,7 +49127,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1101), 29, + ACTIONS(1106), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49179,9 +49204,9 @@ static const uint16_t ts_small_parse_table[] = { [49388] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1416), 1, + ACTIONS(1424), 1, anon_sym_DASH_GT, - ACTIONS(1396), 9, + ACTIONS(1404), 9, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49191,7 +49216,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, sym_float, sym__doc_comment_line, - ACTIONS(1398), 29, + ACTIONS(1406), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49224,9 +49249,9 @@ static const uint16_t ts_small_parse_table[] = { [49437] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1418), 1, + ACTIONS(1426), 1, anon_sym_DASH_GT, - ACTIONS(1410), 9, + ACTIONS(1418), 9, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49236,7 +49261,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, sym_float, sym__doc_comment_line, - ACTIONS(1408), 29, + ACTIONS(1416), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49313,9 +49338,9 @@ static const uint16_t ts_small_parse_table[] = { [49533] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1424), 1, + ACTIONS(1432), 1, anon_sym_DASH_GT, - ACTIONS(1420), 9, + ACTIONS(1428), 9, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49325,7 +49350,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, sym_float, sym__doc_comment_line, - ACTIONS(1422), 29, + ACTIONS(1430), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49358,7 +49383,7 @@ static const uint16_t ts_small_parse_table[] = { [49582] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1079), 10, + ACTIONS(1084), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49369,7 +49394,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1081), 29, + ACTIONS(1086), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49402,9 +49427,9 @@ static const uint16_t ts_small_parse_table[] = { [49629] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1426), 1, + ACTIONS(1434), 1, anon_sym_DASH_GT, - ACTIONS(1420), 9, + ACTIONS(1428), 9, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49414,7 +49439,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, sym_float, sym__doc_comment_line, - ACTIONS(1422), 29, + ACTIONS(1430), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49447,7 +49472,7 @@ static const uint16_t ts_small_parse_table[] = { [49678] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1083), 10, + ACTIONS(1088), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49458,7 +49483,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1085), 29, + ACTIONS(1090), 29, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49491,7 +49516,7 @@ static const uint16_t ts_small_parse_table[] = { [49725] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1428), 10, + ACTIONS(1436), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49502,7 +49527,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1430), 28, + ACTIONS(1438), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49534,7 +49559,7 @@ static const uint16_t ts_small_parse_table[] = { [49771] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1432), 10, + ACTIONS(1440), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49545,7 +49570,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1434), 28, + ACTIONS(1442), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49577,7 +49602,7 @@ static const uint16_t ts_small_parse_table[] = { [49817] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1436), 10, + ACTIONS(1444), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49588,7 +49613,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1438), 28, + ACTIONS(1446), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49620,7 +49645,7 @@ static const uint16_t ts_small_parse_table[] = { [49863] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1440), 10, + ACTIONS(1448), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49631,7 +49656,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1442), 28, + ACTIONS(1450), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49663,7 +49688,7 @@ static const uint16_t ts_small_parse_table[] = { [49909] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1444), 10, + ACTIONS(1452), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49674,7 +49699,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1446), 28, + ACTIONS(1454), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49706,7 +49731,7 @@ static const uint16_t ts_small_parse_table[] = { [49955] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1448), 10, + ACTIONS(1456), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49717,7 +49742,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1450), 28, + ACTIONS(1458), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49749,7 +49774,7 @@ static const uint16_t ts_small_parse_table[] = { [50001] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1432), 10, + ACTIONS(1440), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49760,7 +49785,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1434), 28, + ACTIONS(1442), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49792,7 +49817,7 @@ static const uint16_t ts_small_parse_table[] = { [50047] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1448), 10, + ACTIONS(1456), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49803,7 +49828,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1450), 28, + ACTIONS(1458), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49835,7 +49860,7 @@ static const uint16_t ts_small_parse_table[] = { [50093] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1454), 10, + ACTIONS(1462), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49846,7 +49871,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1452), 28, + ACTIONS(1460), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49878,7 +49903,7 @@ static const uint16_t ts_small_parse_table[] = { [50139] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1428), 10, + ACTIONS(1436), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49889,7 +49914,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1430), 28, + ACTIONS(1438), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49921,7 +49946,7 @@ static const uint16_t ts_small_parse_table[] = { [50185] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1458), 10, + ACTIONS(1466), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -49932,7 +49957,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1456), 28, + ACTIONS(1464), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -49964,7 +49989,7 @@ static const uint16_t ts_small_parse_table[] = { [50231] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1460), 10, + ACTIONS(1468), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -49975,7 +50000,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1462), 28, + ACTIONS(1470), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50007,7 +50032,7 @@ static const uint16_t ts_small_parse_table[] = { [50277] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1464), 10, + ACTIONS(1472), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -50018,7 +50043,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1466), 28, + ACTIONS(1474), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50050,7 +50075,7 @@ static const uint16_t ts_small_parse_table[] = { [50323] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1436), 10, + ACTIONS(1444), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50061,7 +50086,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1438), 28, + ACTIONS(1446), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50093,7 +50118,7 @@ static const uint16_t ts_small_parse_table[] = { [50369] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1440), 10, + ACTIONS(1448), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50104,7 +50129,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1442), 28, + ACTIONS(1450), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50136,7 +50161,7 @@ static const uint16_t ts_small_parse_table[] = { [50415] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1444), 10, + ACTIONS(1452), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50147,7 +50172,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1446), 28, + ACTIONS(1454), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50179,7 +50204,7 @@ static const uint16_t ts_small_parse_table[] = { [50461] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1468), 10, + ACTIONS(1476), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -50190,7 +50215,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1470), 28, + ACTIONS(1478), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50222,7 +50247,7 @@ static const uint16_t ts_small_parse_table[] = { [50507] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1111), 10, + ACTIONS(1119), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50233,7 +50258,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1113), 28, + ACTIONS(1121), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50265,7 +50290,7 @@ static const uint16_t ts_small_parse_table[] = { [50553] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1472), 10, + ACTIONS(1480), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -50276,7 +50301,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1474), 28, + ACTIONS(1482), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50308,7 +50333,7 @@ static const uint16_t ts_small_parse_table[] = { [50599] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1274), 10, + ACTIONS(1282), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50319,7 +50344,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1276), 28, + ACTIONS(1284), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50351,7 +50376,7 @@ static const uint16_t ts_small_parse_table[] = { [50645] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1212), 10, + ACTIONS(1220), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50362,7 +50387,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1214), 28, + ACTIONS(1222), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50394,7 +50419,7 @@ static const uint16_t ts_small_parse_table[] = { [50691] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1460), 10, + ACTIONS(1468), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50405,7 +50430,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1462), 28, + ACTIONS(1470), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50437,7 +50462,7 @@ static const uint16_t ts_small_parse_table[] = { [50737] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1464), 10, + ACTIONS(1472), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50448,7 +50473,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1466), 28, + ACTIONS(1474), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50480,7 +50505,7 @@ static const uint16_t ts_small_parse_table[] = { [50783] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1468), 10, + ACTIONS(1476), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50491,7 +50516,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1470), 28, + ACTIONS(1478), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50523,7 +50548,7 @@ static const uint16_t ts_small_parse_table[] = { [50829] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1472), 10, + ACTIONS(1480), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50534,7 +50559,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1474), 28, + ACTIONS(1482), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50566,7 +50591,7 @@ static const uint16_t ts_small_parse_table[] = { [50875] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1344), 10, + ACTIONS(1352), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50577,7 +50602,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1346), 28, + ACTIONS(1354), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50609,7 +50634,7 @@ static const uint16_t ts_small_parse_table[] = { [50921] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1454), 10, + ACTIONS(1462), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -50620,7 +50645,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1452), 28, + ACTIONS(1460), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50652,7 +50677,7 @@ static const uint16_t ts_small_parse_table[] = { [50967] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1131), 10, + ACTIONS(1139), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50663,7 +50688,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1133), 28, + ACTIONS(1141), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50695,7 +50720,7 @@ static const uint16_t ts_small_parse_table[] = { [51013] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1065), 10, + ACTIONS(1066), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50706,7 +50731,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1067), 28, + ACTIONS(1068), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50738,7 +50763,7 @@ static const uint16_t ts_small_parse_table[] = { [51059] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1392), 10, + ACTIONS(1400), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50749,7 +50774,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1394), 28, + ACTIONS(1402), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50781,7 +50806,7 @@ static const uint16_t ts_small_parse_table[] = { [51105] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1300), 10, + ACTIONS(1308), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50792,7 +50817,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1302), 28, + ACTIONS(1310), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50824,7 +50849,7 @@ static const uint16_t ts_small_parse_table[] = { [51151] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1348), 10, + ACTIONS(1356), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50835,7 +50860,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1350), 28, + ACTIONS(1358), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50867,7 +50892,7 @@ static const uint16_t ts_small_parse_table[] = { [51197] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1360), 10, + ACTIONS(1368), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50878,7 +50903,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1362), 28, + ACTIONS(1370), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50910,7 +50935,7 @@ static const uint16_t ts_small_parse_table[] = { [51243] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1073), 10, + ACTIONS(1077), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50921,7 +50946,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1075), 28, + ACTIONS(1079), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50953,7 +50978,7 @@ static const uint16_t ts_small_parse_table[] = { [51289] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1177), 10, + ACTIONS(1185), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -50964,7 +50989,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1179), 28, + ACTIONS(1187), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -50996,7 +51021,7 @@ static const uint16_t ts_small_parse_table[] = { [51335] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1232), 10, + ACTIONS(1240), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51007,7 +51032,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1234), 28, + ACTIONS(1242), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51039,7 +51064,7 @@ static const uint16_t ts_small_parse_table[] = { [51381] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1478), 10, + ACTIONS(1486), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51050,7 +51075,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1476), 28, + ACTIONS(1484), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51082,7 +51107,7 @@ static const uint16_t ts_small_parse_table[] = { [51427] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1216), 10, + ACTIONS(1224), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51093,7 +51118,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1218), 28, + ACTIONS(1226), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51125,7 +51150,7 @@ static const uint16_t ts_small_parse_table[] = { [51473] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1181), 10, + ACTIONS(1189), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51136,7 +51161,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1183), 28, + ACTIONS(1191), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51168,7 +51193,7 @@ static const uint16_t ts_small_parse_table[] = { [51519] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1220), 10, + ACTIONS(1228), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51179,7 +51204,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1222), 28, + ACTIONS(1230), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51211,7 +51236,7 @@ static const uint16_t ts_small_parse_table[] = { [51565] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1262), 10, + ACTIONS(1270), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51222,7 +51247,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1264), 28, + ACTIONS(1272), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51254,7 +51279,7 @@ static const uint16_t ts_small_parse_table[] = { [51611] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1380), 10, + ACTIONS(1388), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51265,7 +51290,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1382), 28, + ACTIONS(1390), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51297,7 +51322,7 @@ static const uint16_t ts_small_parse_table[] = { [51657] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1388), 10, + ACTIONS(1396), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51308,7 +51333,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1390), 28, + ACTIONS(1398), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51340,7 +51365,7 @@ static const uint16_t ts_small_parse_table[] = { [51703] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1127), 10, + ACTIONS(1135), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51351,7 +51376,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1129), 28, + ACTIONS(1137), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51383,7 +51408,7 @@ static const uint16_t ts_small_parse_table[] = { [51749] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1139), 10, + ACTIONS(1147), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51394,7 +51419,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1141), 28, + ACTIONS(1149), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51426,7 +51451,7 @@ static const uint16_t ts_small_parse_table[] = { [51795] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1143), 10, + ACTIONS(1151), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51437,7 +51462,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1145), 28, + ACTIONS(1153), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51469,7 +51494,7 @@ static const uint16_t ts_small_parse_table[] = { [51841] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1119), 10, + ACTIONS(1127), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51480,7 +51505,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1121), 28, + ACTIONS(1129), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51512,7 +51537,7 @@ static const uint16_t ts_small_parse_table[] = { [51887] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1149), 10, + ACTIONS(1157), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51523,7 +51548,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1151), 28, + ACTIONS(1159), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51555,7 +51580,7 @@ static const uint16_t ts_small_parse_table[] = { [51933] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1153), 10, + ACTIONS(1161), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51566,7 +51591,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1155), 28, + ACTIONS(1163), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51598,7 +51623,7 @@ static const uint16_t ts_small_parse_table[] = { [51979] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1157), 10, + ACTIONS(1165), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51609,7 +51634,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1159), 28, + ACTIONS(1167), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51641,7 +51666,7 @@ static const uint16_t ts_small_parse_table[] = { [52025] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1161), 10, + ACTIONS(1169), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51652,7 +51677,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1163), 28, + ACTIONS(1171), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51684,7 +51709,7 @@ static const uint16_t ts_small_parse_table[] = { [52071] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1169), 10, + ACTIONS(1177), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51695,7 +51720,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1171), 28, + ACTIONS(1179), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51727,7 +51752,7 @@ static const uint16_t ts_small_parse_table[] = { [52117] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1185), 10, + ACTIONS(1193), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51738,7 +51763,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1187), 28, + ACTIONS(1195), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51770,7 +51795,7 @@ static const uint16_t ts_small_parse_table[] = { [52163] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1189), 10, + ACTIONS(1197), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51781,7 +51806,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1191), 28, + ACTIONS(1199), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51813,7 +51838,7 @@ static const uint16_t ts_small_parse_table[] = { [52209] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1107), 10, + ACTIONS(1115), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51824,7 +51849,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1109), 28, + ACTIONS(1117), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51856,7 +51881,7 @@ static const uint16_t ts_small_parse_table[] = { [52255] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1250), 10, + ACTIONS(1258), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51867,7 +51892,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1252), 28, + ACTIONS(1260), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51942,7 +51967,7 @@ static const uint16_t ts_small_parse_table[] = { [52347] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1304), 10, + ACTIONS(1312), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51953,7 +51978,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1306), 28, + ACTIONS(1314), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -51985,7 +52010,7 @@ static const uint16_t ts_small_parse_table[] = { [52393] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1332), 10, + ACTIONS(1340), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -51996,7 +52021,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1334), 28, + ACTIONS(1342), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52028,7 +52053,7 @@ static const uint16_t ts_small_parse_table[] = { [52439] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1336), 10, + ACTIONS(1344), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52039,7 +52064,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1338), 28, + ACTIONS(1346), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52071,7 +52096,7 @@ static const uint16_t ts_small_parse_table[] = { [52485] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1340), 10, + ACTIONS(1348), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52082,7 +52107,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1342), 28, + ACTIONS(1350), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52114,7 +52139,7 @@ static const uint16_t ts_small_parse_table[] = { [52531] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1352), 10, + ACTIONS(1360), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52125,7 +52150,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1354), 28, + ACTIONS(1362), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52157,7 +52182,7 @@ static const uint16_t ts_small_parse_table[] = { [52577] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1364), 10, + ACTIONS(1372), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52168,7 +52193,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1366), 28, + ACTIONS(1374), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52200,7 +52225,7 @@ static const uint16_t ts_small_parse_table[] = { [52623] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1372), 10, + ACTIONS(1380), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52211,7 +52236,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1374), 28, + ACTIONS(1382), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52243,7 +52268,7 @@ static const uint16_t ts_small_parse_table[] = { [52669] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1376), 10, + ACTIONS(1384), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52254,7 +52279,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1378), 28, + ACTIONS(1386), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52286,7 +52311,7 @@ static const uint16_t ts_small_parse_table[] = { [52715] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1384), 10, + ACTIONS(1392), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52297,7 +52322,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1386), 28, + ACTIONS(1394), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52329,7 +52354,7 @@ static const uint16_t ts_small_parse_table[] = { [52761] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1115), 10, + ACTIONS(1123), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52340,7 +52365,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1117), 28, + ACTIONS(1125), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52372,7 +52397,7 @@ static const uint16_t ts_small_parse_table[] = { [52807] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1266), 10, + ACTIONS(1274), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52383,7 +52408,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1268), 28, + ACTIONS(1276), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52415,7 +52440,7 @@ static const uint16_t ts_small_parse_table[] = { [52853] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1254), 10, + ACTIONS(1262), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52426,7 +52451,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1256), 28, + ACTIONS(1264), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52458,7 +52483,7 @@ static const uint16_t ts_small_parse_table[] = { [52899] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1240), 10, + ACTIONS(1248), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52469,7 +52494,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1242), 28, + ACTIONS(1250), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52501,7 +52526,7 @@ static const uint16_t ts_small_parse_table[] = { [52945] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1087), 10, + ACTIONS(1092), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52512,7 +52537,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1089), 28, + ACTIONS(1094), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52544,7 +52569,7 @@ static const uint16_t ts_small_parse_table[] = { [52991] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1324), 10, + ACTIONS(1332), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52555,7 +52580,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1326), 28, + ACTIONS(1334), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52587,7 +52612,7 @@ static const uint16_t ts_small_parse_table[] = { [53037] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1312), 10, + ACTIONS(1320), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52598,7 +52623,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1314), 28, + ACTIONS(1322), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52630,7 +52655,7 @@ static const uint16_t ts_small_parse_table[] = { [53083] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1356), 10, + ACTIONS(1364), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52641,7 +52666,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1358), 28, + ACTIONS(1366), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52673,7 +52698,7 @@ static const uint16_t ts_small_parse_table[] = { [53129] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1197), 10, + ACTIONS(1205), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52684,7 +52709,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1199), 28, + ACTIONS(1207), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52716,7 +52741,7 @@ static const uint16_t ts_small_parse_table[] = { [53175] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1246), 10, + ACTIONS(1254), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52727,7 +52752,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1248), 28, + ACTIONS(1256), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52759,7 +52784,7 @@ static const uint16_t ts_small_parse_table[] = { [53221] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1285), 10, + ACTIONS(1293), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52770,7 +52795,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1287), 28, + ACTIONS(1295), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52802,7 +52827,7 @@ static const uint16_t ts_small_parse_table[] = { [53267] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1316), 10, + ACTIONS(1324), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52813,7 +52838,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1318), 28, + ACTIONS(1326), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52845,7 +52870,7 @@ static const uint16_t ts_small_parse_table[] = { [53313] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1458), 10, + ACTIONS(1466), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -52856,7 +52881,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1456), 28, + ACTIONS(1464), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52888,7 +52913,7 @@ static const uint16_t ts_small_parse_table[] = { [53359] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1368), 10, + ACTIONS(1376), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52899,7 +52924,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1370), 28, + ACTIONS(1378), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52931,7 +52956,7 @@ static const uint16_t ts_small_parse_table[] = { [53405] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1135), 10, + ACTIONS(1143), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52942,7 +52967,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1137), 28, + ACTIONS(1145), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -52974,7 +52999,7 @@ static const uint16_t ts_small_parse_table[] = { [53451] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1051), 10, + ACTIONS(1052), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -52985,7 +53010,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1053), 28, + ACTIONS(1054), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53017,7 +53042,7 @@ static const uint16_t ts_small_parse_table[] = { [53497] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1193), 10, + ACTIONS(1201), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53028,7 +53053,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1195), 28, + ACTIONS(1203), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53060,7 +53085,7 @@ static const uint16_t ts_small_parse_table[] = { [53543] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1228), 10, + ACTIONS(1236), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53071,7 +53096,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1230), 28, + ACTIONS(1238), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53103,7 +53128,7 @@ static const uint16_t ts_small_parse_table[] = { [53589] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1308), 10, + ACTIONS(1316), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53114,7 +53139,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1310), 28, + ACTIONS(1318), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53146,7 +53171,7 @@ static const uint16_t ts_small_parse_table[] = { [53635] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1328), 10, + ACTIONS(1336), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53157,7 +53182,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1330), 28, + ACTIONS(1338), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53189,7 +53214,7 @@ static const uint16_t ts_small_parse_table[] = { [53681] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1165), 10, + ACTIONS(1173), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53200,7 +53225,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1167), 28, + ACTIONS(1175), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53232,7 +53257,7 @@ static const uint16_t ts_small_parse_table[] = { [53727] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1201), 10, + ACTIONS(1209), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53243,7 +53268,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1203), 28, + ACTIONS(1211), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53275,7 +53300,7 @@ static const uint16_t ts_small_parse_table[] = { [53773] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1208), 10, + ACTIONS(1216), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53286,7 +53311,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1210), 28, + ACTIONS(1218), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53318,7 +53343,7 @@ static const uint16_t ts_small_parse_table[] = { [53819] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1224), 10, + ACTIONS(1232), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53329,7 +53354,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1226), 28, + ACTIONS(1234), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53361,7 +53386,7 @@ static const uint16_t ts_small_parse_table[] = { [53865] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1236), 10, + ACTIONS(1244), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53372,7 +53397,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1238), 28, + ACTIONS(1246), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53404,7 +53429,7 @@ static const uint16_t ts_small_parse_table[] = { [53911] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1478), 10, + ACTIONS(1486), 10, ts_builtin_sym_end, anon_sym_LBRACE, anon_sym_LPAREN, @@ -53415,7 +53440,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1476), 28, + ACTIONS(1484), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53447,7 +53472,7 @@ static const uint16_t ts_small_parse_table[] = { [53957] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1258), 10, + ACTIONS(1266), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53458,7 +53483,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1260), 28, + ACTIONS(1268), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53490,7 +53515,7 @@ static const uint16_t ts_small_parse_table[] = { [54003] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1123), 10, + ACTIONS(1131), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53501,7 +53526,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1125), 28, + ACTIONS(1133), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53533,7 +53558,7 @@ static const uint16_t ts_small_parse_table[] = { [54049] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1270), 10, + ACTIONS(1278), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53544,7 +53569,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1272), 28, + ACTIONS(1280), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53576,7 +53601,7 @@ static const uint16_t ts_small_parse_table[] = { [54095] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1320), 10, + ACTIONS(1328), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53587,7 +53612,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1322), 28, + ACTIONS(1330), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53748,7 +53773,7 @@ static const uint16_t ts_small_parse_table[] = { [54279] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1293), 10, + ACTIONS(1301), 10, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_LPAREN, @@ -53759,7 +53784,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH, sym_float, sym__doc_comment_line, - ACTIONS(1295), 28, + ACTIONS(1303), 28, anon_sym_import, anon_sym_namespace, anon_sym_let, @@ -53791,7 +53816,7 @@ static const uint16_t ts_small_parse_table[] = { [54325] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, STATE(717), 1, aux_sym_qualified_path_repeat1, @@ -53835,7 +53860,7 @@ static const uint16_t ts_small_parse_table[] = { [54374] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1482), 1, + ACTIONS(1490), 1, anon_sym_COLON_COLON, STATE(717), 1, aux_sym_qualified_path_repeat1, @@ -53881,9 +53906,9 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(462), 1, anon_sym_LT, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(1485), 1, + ACTIONS(1493), 1, anon_sym_LBRACE, STATE(716), 1, aux_sym_qualified_path_repeat1, @@ -54009,7 +54034,7 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(462), 1, anon_sym_LT, - ACTIONS(1488), 1, + ACTIONS(1496), 1, anon_sym_LBRACE, STATE(1736), 1, sym_type_arguments, @@ -54050,20 +54075,20 @@ static const uint16_t ts_small_parse_table[] = { [54614] = 10, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, ACTIONS(711), 11, @@ -54213,13 +54238,13 @@ static const uint16_t ts_small_parse_table[] = { [54796] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, ACTIONS(697), 12, anon_sym_LT, @@ -54295,34 +54320,34 @@ static const uint16_t ts_small_parse_table[] = { [54888] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -54347,34 +54372,34 @@ static const uint16_t ts_small_parse_table[] = { [54956] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -54672,13 +54697,13 @@ static const uint16_t ts_small_parse_table[] = { [55318] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, ACTIONS(711), 12, anon_sym_LT, @@ -54754,28 +54779,28 @@ static const uint16_t ts_small_parse_table[] = { [55410] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -54803,26 +54828,26 @@ static const uint16_t ts_small_parse_table[] = { [55472] = 12, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -54851,17 +54876,17 @@ static const uint16_t ts_small_parse_table[] = { [55532] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, ACTIONS(711), 11, @@ -54896,11 +54921,11 @@ static const uint16_t ts_small_parse_table[] = { [55586] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, - anon_sym_LPAREN, ACTIONS(1503), 1, + anon_sym_LPAREN, + ACTIONS(1511), 1, anon_sym_LBRACK2, ACTIONS(604), 12, anon_sym_LT, @@ -55016,34 +55041,34 @@ static const uint16_t ts_small_parse_table[] = { [55718] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -55380,34 +55405,34 @@ static const uint16_t ts_small_parse_table[] = { [56122] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -55510,34 +55535,34 @@ static const uint16_t ts_small_parse_table[] = { [56274] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -55601,34 +55626,34 @@ static const uint16_t ts_small_parse_table[] = { [56384] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -55692,34 +55717,34 @@ static const uint16_t ts_small_parse_table[] = { [56494] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -55744,34 +55769,34 @@ static const uint16_t ts_small_parse_table[] = { [56562] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -55874,34 +55899,34 @@ static const uint16_t ts_small_parse_table[] = { [56714] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56004,34 +56029,34 @@ static const uint16_t ts_small_parse_table[] = { [56866] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56056,34 +56081,34 @@ static const uint16_t ts_small_parse_table[] = { [56934] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56192,28 +56217,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56240,28 +56265,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56288,28 +56313,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56336,28 +56361,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56384,28 +56409,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56432,28 +56457,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56480,28 +56505,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56528,28 +56553,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56576,28 +56601,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56624,28 +56649,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56672,28 +56697,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56720,28 +56745,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56768,28 +56793,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56816,28 +56841,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56864,28 +56889,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56912,28 +56937,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -56960,28 +56985,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57008,28 +57033,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57056,28 +57081,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57104,28 +57129,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57152,28 +57177,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57200,28 +57225,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57248,28 +57273,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57296,28 +57321,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57344,28 +57369,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57392,28 +57417,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57440,28 +57465,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57488,28 +57513,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57536,28 +57561,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57584,28 +57609,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57632,28 +57657,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57680,28 +57705,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57728,28 +57753,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57776,28 +57801,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57824,28 +57849,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57872,28 +57897,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57920,28 +57945,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -57968,7 +57993,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, ACTIONS(711), 3, anon_sym_LT, @@ -58008,17 +58033,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, ACTIONS(711), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, ACTIONS(713), 20, @@ -58051,22 +58076,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58096,20 +58121,20 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58140,14 +58165,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, ACTIONS(711), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, ACTIONS(713), 22, @@ -58182,28 +58207,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58230,28 +58255,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58278,28 +58303,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58326,28 +58351,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58374,28 +58399,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58422,28 +58447,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58470,28 +58495,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58518,28 +58543,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58566,28 +58591,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58614,7 +58639,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, ACTIONS(697), 3, anon_sym_LT, @@ -58654,28 +58679,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(610), 1, anon_sym_LBRACK2, - ACTIONS(1517), 1, + ACTIONS(1525), 1, anon_sym_LBRACE, - ACTIONS(1523), 1, + ACTIONS(1531), 1, anon_sym_QMARK, - ACTIONS(1525), 1, + ACTIONS(1533), 1, anon_sym_PIPE_PIPE, - ACTIONS(1527), 1, + ACTIONS(1535), 1, anon_sym_AMP_AMP, - ACTIONS(1533), 1, + ACTIONS(1541), 1, anon_sym_SLASH, - ACTIONS(1535), 1, + ACTIONS(1543), 1, anon_sym_PIPE_GT, - ACTIONS(1519), 2, + ACTIONS(1527), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1521), 2, + ACTIONS(1529), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1531), 2, + ACTIONS(1539), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1529), 4, + ACTIONS(1537), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -58696,42 +58721,42 @@ static const uint16_t ts_small_parse_table[] = { [60357] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1539), 2, + ACTIONS(1547), 2, anon_sym_RBRACE, sym_float, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(1537), 8, + ACTIONS(1545), 8, anon_sym_LBRACK, anon_sym__, anon_sym_true, @@ -58743,42 +58768,42 @@ static const uint16_t ts_small_parse_table[] = { [60420] = 16, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1543), 2, + ACTIONS(1551), 2, anon_sym_RBRACE, sym_float, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(1541), 8, + ACTIONS(1549), 8, anon_sym_LBRACK, anon_sym__, anon_sym_true, @@ -58792,29 +58817,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1545), 1, + ACTIONS(1553), 1, anon_sym_RBRACE, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -58835,29 +58860,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1565), 1, + ACTIONS(1573), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(833), 2, @@ -58878,29 +58903,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1567), 1, + ACTIONS(1575), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(830), 2, @@ -58921,29 +58946,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1569), 1, + ACTIONS(1577), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -58964,29 +58989,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, - anon_sym_signature, ACTIONS(1571), 1, + anon_sym_signature, + ACTIONS(1579), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(838), 2, @@ -59007,29 +59032,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1573), 1, + ACTIONS(1581), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(843), 2, @@ -59050,29 +59075,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1575), 1, + ACTIONS(1583), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59091,31 +59116,31 @@ static const uint16_t ts_small_parse_table[] = { [60896] = 16, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1577), 1, + ACTIONS(1585), 1, anon_sym_RBRACE, - ACTIONS(1582), 1, + ACTIONS(1590), 1, anon_sym_fn, - ACTIONS(1585), 1, + ACTIONS(1593), 1, anon_sym_extern, - ACTIONS(1588), 1, + ACTIONS(1596), 1, anon_sym_type, - ACTIONS(1591), 1, + ACTIONS(1599), 1, anon_sym_effect, - ACTIONS(1594), 1, + ACTIONS(1602), 1, anon_sym_state, - ACTIONS(1597), 1, + ACTIONS(1605), 1, anon_sym_module, - ACTIONS(1600), 1, + ACTIONS(1608), 1, anon_sym_export, - ACTIONS(1603), 1, + ACTIONS(1611), 1, anon_sym_signature, - ACTIONS(1606), 1, + ACTIONS(1614), 1, sym__doc_comment_line, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1579), 2, + ACTIONS(1587), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59136,29 +59161,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1609), 1, + ACTIONS(1617), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59179,13 +59204,13 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(462), 1, anon_sym_LT, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(1485), 1, + ACTIONS(1493), 1, anon_sym_LBRACE, - ACTIONS(1611), 1, + ACTIONS(1619), 1, anon_sym_RBRACE, - ACTIONS(1614), 1, + ACTIONS(1622), 1, anon_sym_COMMA, STATE(716), 1, aux_sym_qualified_path_repeat1, @@ -59217,29 +59242,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1616), 1, + ACTIONS(1624), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(839), 2, @@ -59260,29 +59285,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1618), 1, + ACTIONS(1626), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59303,29 +59328,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1620), 1, + ACTIONS(1628), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59346,29 +59371,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1622), 1, + ACTIONS(1630), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(841), 2, @@ -59389,29 +59414,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1624), 1, + ACTIONS(1632), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59432,29 +59457,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1626), 1, + ACTIONS(1634), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59475,29 +59500,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1628), 1, + ACTIONS(1636), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59518,29 +59543,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1630), 1, + ACTIONS(1638), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(847), 2, @@ -59561,29 +59586,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1632), 1, + ACTIONS(1640), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(835), 2, @@ -59604,29 +59629,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1634), 1, + ACTIONS(1642), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(850), 2, @@ -59647,29 +59672,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1636), 1, + ACTIONS(1644), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59690,29 +59715,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1638), 1, + ACTIONS(1646), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(852), 2, @@ -59733,29 +59758,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1640), 1, + ACTIONS(1648), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(854), 2, @@ -59776,29 +59801,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1642), 1, + ACTIONS(1650), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59819,29 +59844,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1644), 1, + ACTIONS(1652), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(856), 2, @@ -59862,29 +59887,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1646), 1, + ACTIONS(1654), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59905,29 +59930,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1648), 1, + ACTIONS(1656), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(827), 2, @@ -59948,29 +59973,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1650), 1, + ACTIONS(1658), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -59991,29 +60016,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1652), 1, + ACTIONS(1660), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(859), 2, @@ -60034,29 +60059,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1654), 1, + ACTIONS(1662), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -60077,11 +60102,11 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(462), 1, anon_sym_LT, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(1485), 1, + ACTIONS(1493), 1, anon_sym_LBRACE, - ACTIONS(1656), 1, + ACTIONS(1664), 1, anon_sym_COLON, STATE(716), 1, aux_sym_qualified_path_repeat1, @@ -60113,29 +60138,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1658), 1, + ACTIONS(1666), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(860), 2, @@ -60156,29 +60181,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1660), 1, + ACTIONS(1668), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -60199,29 +60224,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1662), 1, + ACTIONS(1670), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(834), 2, @@ -60242,29 +60267,29 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1561), 1, + ACTIONS(1569), 1, anon_sym_export, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1664), 1, + ACTIONS(1672), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1005), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(842), 2, @@ -60283,40 +60308,40 @@ static const uint16_t ts_small_parse_table[] = { [62524] = 17, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1666), 1, + ACTIONS(1674), 1, anon_sym_COMMA, - ACTIONS(1668), 1, + ACTIONS(1676), 1, anon_sym_RBRACK, STATE(1319), 1, aux_sym_argument_list_repeat1, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60324,38 +60349,38 @@ static const uint16_t ts_small_parse_table[] = { [62582] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1670), 3, + ACTIONS(1678), 3, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60363,40 +60388,40 @@ static const uint16_t ts_small_parse_table[] = { [62636] = 17, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1666), 1, + ACTIONS(1674), 1, anon_sym_COMMA, - ACTIONS(1672), 1, + ACTIONS(1680), 1, anon_sym_RBRACK, STATE(1296), 1, aux_sym_argument_list_repeat1, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60404,40 +60429,40 @@ static const uint16_t ts_small_parse_table[] = { [62694] = 17, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1666), 1, - anon_sym_COMMA, ACTIONS(1674), 1, + anon_sym_COMMA, + ACTIONS(1682), 1, anon_sym_RBRACK, STATE(1380), 1, aux_sym_argument_list_repeat1, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60445,40 +60470,40 @@ static const uint16_t ts_small_parse_table[] = { [62752] = 17, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1666), 1, + ACTIONS(1674), 1, anon_sym_COMMA, - ACTIONS(1676), 1, + ACTIONS(1684), 1, anon_sym_RPAREN, STATE(1332), 1, aux_sym_argument_list_repeat1, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60486,7 +60511,7 @@ static const uint16_t ts_small_parse_table[] = { [62810] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1678), 2, + ACTIONS(1686), 2, anon_sym_RBRACE, anon_sym_COMMA, ACTIONS(566), 3, @@ -60513,37 +60538,37 @@ static const uint16_t ts_small_parse_table[] = { [62841] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1680), 2, + ACTIONS(1688), 2, anon_sym_RBRACE, anon_sym_COMMA, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60553,27 +60578,27 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1682), 1, + ACTIONS(1690), 1, anon_sym_opaque, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1042), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(982), 8, @@ -60588,37 +60613,37 @@ static const uint16_t ts_small_parse_table[] = { [62945] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1684), 2, + ACTIONS(1692), 2, anon_sym_RBRACE, anon_sym_COMMA, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60626,37 +60651,37 @@ static const uint16_t ts_small_parse_table[] = { [62998] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1686), 2, + ACTIONS(1694), 2, anon_sym_in, sym_identifier, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60664,37 +60689,37 @@ static const uint16_t ts_small_parse_table[] = { [63051] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1688), 2, + ACTIONS(1696), 2, anon_sym_in, sym_identifier, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60702,37 +60727,37 @@ static const uint16_t ts_small_parse_table[] = { [63104] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1690), 2, + ACTIONS(1698), 2, anon_sym_COMMA, anon_sym_RPAREN, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60742,27 +60767,27 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1549), 1, + ACTIONS(1557), 1, anon_sym_fn, - ACTIONS(1551), 1, + ACTIONS(1559), 1, anon_sym_extern, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1557), 1, + ACTIONS(1565), 1, anon_sym_state, - ACTIONS(1559), 1, + ACTIONS(1567), 1, anon_sym_module, - ACTIONS(1563), 1, + ACTIONS(1571), 1, anon_sym_signature, - ACTIONS(1692), 1, + ACTIONS(1700), 1, anon_sym_opaque, STATE(968), 1, aux_sym_doc_comment_repeat1, STATE(1042), 1, sym_doc_comment, - ACTIONS(1547), 2, + ACTIONS(1555), 2, anon_sym_let, anon_sym_mut, STATE(975), 8, @@ -60777,36 +60802,36 @@ static const uint16_t ts_small_parse_table[] = { [63208] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1694), 1, + ACTIONS(1702), 1, anon_sym_COLON, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60814,15 +60839,15 @@ static const uint16_t ts_small_parse_table[] = { [63260] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1700), 1, + ACTIONS(1708), 1, anon_sym_RBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, STATE(1474), 1, sym_qualified_path, @@ -60833,7 +60858,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(915), 2, @@ -60842,7 +60867,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -60852,34 +60877,34 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(673), 1, anon_sym_COLON, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60887,36 +60912,36 @@ static const uint16_t ts_small_parse_table[] = { [63362] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1710), 1, + ACTIONS(1718), 1, anon_sym_RBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60924,36 +60949,36 @@ static const uint16_t ts_small_parse_table[] = { [63414] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1712), 1, + ACTIONS(1720), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60961,36 +60986,36 @@ static const uint16_t ts_small_parse_table[] = { [63466] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1714), 1, + ACTIONS(1722), 1, anon_sym_COMMA, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -60998,36 +61023,36 @@ static const uint16_t ts_small_parse_table[] = { [63518] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1716), 1, + ACTIONS(1724), 1, anon_sym_RBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61035,36 +61060,36 @@ static const uint16_t ts_small_parse_table[] = { [63570] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1718), 1, + ACTIONS(1726), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61072,36 +61097,36 @@ static const uint16_t ts_small_parse_table[] = { [63622] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1720), 1, + ACTIONS(1728), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61109,36 +61134,36 @@ static const uint16_t ts_small_parse_table[] = { [63674] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1722), 1, + ACTIONS(1730), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61146,15 +61171,15 @@ static const uint16_t ts_small_parse_table[] = { [63726] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1724), 1, + ACTIONS(1732), 1, anon_sym_RBRACE, STATE(1474), 1, sym_qualified_path, @@ -61165,7 +61190,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(928), 2, @@ -61174,7 +61199,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -61182,36 +61207,36 @@ static const uint16_t ts_small_parse_table[] = { [63776] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1726), 1, + ACTIONS(1734), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61219,36 +61244,36 @@ static const uint16_t ts_small_parse_table[] = { [63828] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1728), 1, + ACTIONS(1736), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61256,36 +61281,36 @@ static const uint16_t ts_small_parse_table[] = { [63880] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1730), 1, + ACTIONS(1738), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61293,36 +61318,36 @@ static const uint16_t ts_small_parse_table[] = { [63932] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1732), 1, + ACTIONS(1740), 1, anon_sym_COLON, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61330,36 +61355,36 @@ static const uint16_t ts_small_parse_table[] = { [63984] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1734), 1, + ACTIONS(1742), 1, anon_sym_RBRACK, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61367,36 +61392,36 @@ static const uint16_t ts_small_parse_table[] = { [64036] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1736), 1, + ACTIONS(1744), 1, anon_sym_RBRACK, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61404,36 +61429,36 @@ static const uint16_t ts_small_parse_table[] = { [64088] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1738), 1, + ACTIONS(1746), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61441,36 +61466,36 @@ static const uint16_t ts_small_parse_table[] = { [64140] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1740), 1, + ACTIONS(1748), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61478,36 +61503,36 @@ static const uint16_t ts_small_parse_table[] = { [64192] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1742), 1, + ACTIONS(1750), 1, anon_sym_COLON, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61515,36 +61540,36 @@ static const uint16_t ts_small_parse_table[] = { [64244] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1744), 1, + ACTIONS(1752), 1, anon_sym_COLON, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61552,36 +61577,36 @@ static const uint16_t ts_small_parse_table[] = { [64296] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1746), 1, + ACTIONS(1754), 1, anon_sym_RBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61589,36 +61614,36 @@ static const uint16_t ts_small_parse_table[] = { [64348] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1748), 1, + ACTIONS(1756), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61626,15 +61651,15 @@ static const uint16_t ts_small_parse_table[] = { [64400] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1696), 1, + ACTIONS(1704), 1, sym_identifier, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1750), 1, + ACTIONS(1758), 1, anon_sym_RBRACE, STATE(1474), 1, sym_qualified_path, @@ -61645,7 +61670,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(919), 2, @@ -61654,7 +61679,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -61662,36 +61687,36 @@ static const uint16_t ts_small_parse_table[] = { [64450] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1752), 1, + ACTIONS(1760), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61699,36 +61724,36 @@ static const uint16_t ts_small_parse_table[] = { [64502] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1754), 1, + ACTIONS(1762), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61736,36 +61761,36 @@ static const uint16_t ts_small_parse_table[] = { [64554] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1756), 1, + ACTIONS(1764), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61773,36 +61798,36 @@ static const uint16_t ts_small_parse_table[] = { [64606] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1758), 1, + ACTIONS(1766), 1, anon_sym_COLON, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61810,36 +61835,36 @@ static const uint16_t ts_small_parse_table[] = { [64658] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1760), 1, + ACTIONS(1768), 1, anon_sym_RBRACK, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61847,36 +61872,36 @@ static const uint16_t ts_small_parse_table[] = { [64710] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1762), 1, + ACTIONS(1770), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61884,36 +61909,36 @@ static const uint16_t ts_small_parse_table[] = { [64762] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1764), 1, + ACTIONS(1772), 1, anon_sym_COLON, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61921,36 +61946,36 @@ static const uint16_t ts_small_parse_table[] = { [64814] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1766), 1, + ACTIONS(1774), 1, anon_sym_RBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61958,36 +61983,36 @@ static const uint16_t ts_small_parse_table[] = { [64866] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1768), 1, + ACTIONS(1776), 1, anon_sym_COLON, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -61995,36 +62020,36 @@ static const uint16_t ts_small_parse_table[] = { [64918] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1770), 1, + ACTIONS(1778), 1, anon_sym_COLON, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62032,36 +62057,36 @@ static const uint16_t ts_small_parse_table[] = { [64970] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1772), 1, + ACTIONS(1780), 1, anon_sym_COMMA, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62069,36 +62094,36 @@ static const uint16_t ts_small_parse_table[] = { [65022] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1774), 1, + ACTIONS(1782), 1, anon_sym_RBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62106,36 +62131,36 @@ static const uint16_t ts_small_parse_table[] = { [65074] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1776), 1, + ACTIONS(1784), 1, anon_sym_COMMA, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62143,36 +62168,36 @@ static const uint16_t ts_small_parse_table[] = { [65126] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1778), 1, + ACTIONS(1786), 1, anon_sym_RBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62180,36 +62205,36 @@ static const uint16_t ts_small_parse_table[] = { [65178] = 15, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1780), 1, + ACTIONS(1788), 1, anon_sym_RPAREN, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62217,34 +62242,34 @@ static const uint16_t ts_small_parse_table[] = { [65230] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1782), 1, + ACTIONS(1790), 1, anon_sym_LBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62252,15 +62277,15 @@ static const uint16_t ts_small_parse_table[] = { [65279] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1786), 1, + ACTIONS(1794), 1, anon_sym_RBRACE, STATE(1474), 1, sym_qualified_path, @@ -62269,7 +62294,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(918), 2, @@ -62278,7 +62303,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62286,15 +62311,15 @@ static const uint16_t ts_small_parse_table[] = { [65326] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1788), 1, + ACTIONS(1796), 1, anon_sym_RBRACE, STATE(1474), 1, sym_qualified_path, @@ -62303,7 +62328,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(927), 2, @@ -62312,7 +62337,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62320,34 +62345,34 @@ static const uint16_t ts_small_parse_table[] = { [65373] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1790), 1, + ACTIONS(1798), 1, anon_sym_LBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62355,24 +62380,24 @@ static const uint16_t ts_small_parse_table[] = { [65422] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1792), 1, + ACTIONS(1800), 1, sym_identifier, - ACTIONS(1795), 1, + ACTIONS(1803), 1, anon_sym_LBRACE, - ACTIONS(1798), 1, + ACTIONS(1806), 1, anon_sym_RBRACE, - ACTIONS(1800), 1, + ACTIONS(1808), 1, anon_sym_LBRACK, - ACTIONS(1812), 1, + ACTIONS(1820), 1, sym_float, STATE(1474), 1, sym_qualified_path, STATE(1628), 1, sym_pattern, - ACTIONS(1803), 2, + ACTIONS(1811), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1809), 2, + ACTIONS(1817), 2, anon_sym_true, anon_sym_false, STATE(918), 2, @@ -62381,7 +62406,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1806), 4, + ACTIONS(1814), 4, anon_sym__, sym_integer, sym_string, @@ -62389,15 +62414,15 @@ static const uint16_t ts_small_parse_table[] = { [65469] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1815), 1, + ACTIONS(1823), 1, anon_sym_RBRACE, STATE(1474), 1, sym_qualified_path, @@ -62406,7 +62431,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(918), 2, @@ -62415,7 +62440,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62423,15 +62448,15 @@ static const uint16_t ts_small_parse_table[] = { [65516] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1817), 1, + ACTIONS(1825), 1, anon_sym_RBRACE, STATE(1474), 1, sym_qualified_path, @@ -62440,7 +62465,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(927), 2, @@ -62449,7 +62474,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62463,7 +62488,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(969), 1, anon_sym_LT, - ACTIONS(1819), 1, + ACTIONS(1827), 1, anon_sym_LBRACK, STATE(469), 1, aux_sym_qualified_path_repeat1, @@ -62485,34 +62510,34 @@ static const uint16_t ts_small_parse_table[] = { [65598] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1821), 1, + ACTIONS(1829), 1, anon_sym_LBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62520,34 +62545,34 @@ static const uint16_t ts_small_parse_table[] = { [65647] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1505), 1, + ACTIONS(1513), 1, anon_sym_LBRACE, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62555,34 +62580,34 @@ static const uint16_t ts_small_parse_table[] = { [65696] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1823), 1, + ACTIONS(1831), 1, anon_sym_LBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62594,7 +62619,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, ACTIONS(969), 1, anon_sym_LT, - ACTIONS(1819), 1, + ACTIONS(1827), 1, anon_sym_LBRACK, STATE(469), 1, aux_sym_qualified_path_repeat1, @@ -62617,34 +62642,34 @@ static const uint16_t ts_small_parse_table[] = { [65778] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1825), 1, + ACTIONS(1833), 1, anon_sym_LBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62652,24 +62677,24 @@ static const uint16_t ts_small_parse_table[] = { [65827] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1827), 1, + ACTIONS(1835), 1, sym_identifier, - ACTIONS(1830), 1, + ACTIONS(1838), 1, anon_sym_LBRACE, - ACTIONS(1833), 1, + ACTIONS(1841), 1, anon_sym_RBRACE, - ACTIONS(1835), 1, + ACTIONS(1843), 1, anon_sym_LBRACK, - ACTIONS(1847), 1, + ACTIONS(1855), 1, sym_float, STATE(1474), 1, sym_qualified_path, STATE(1639), 1, sym_pattern, - ACTIONS(1838), 2, + ACTIONS(1846), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1844), 2, + ACTIONS(1852), 2, anon_sym_true, anon_sym_false, STATE(927), 2, @@ -62678,7 +62703,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1841), 4, + ACTIONS(1849), 4, anon_sym__, sym_integer, sym_string, @@ -62686,15 +62711,15 @@ static const uint16_t ts_small_parse_table[] = { [65874] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1850), 1, + ACTIONS(1858), 1, anon_sym_RBRACE, STATE(1474), 1, sym_qualified_path, @@ -62703,7 +62728,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(918), 2, @@ -62712,7 +62737,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62720,15 +62745,15 @@ static const uint16_t ts_small_parse_table[] = { [65921] = 13, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1852), 1, + ACTIONS(1860), 1, anon_sym_RBRACE, STATE(1474), 1, sym_qualified_path, @@ -62737,7 +62762,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(927), 2, @@ -62746,7 +62771,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62754,34 +62779,34 @@ static const uint16_t ts_small_parse_table[] = { [65968] = 14, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1491), 1, + ACTIONS(1499), 1, anon_sym_DOT, - ACTIONS(1495), 1, + ACTIONS(1503), 1, anon_sym_LPAREN, - ACTIONS(1499), 1, + ACTIONS(1507), 1, anon_sym_SLASH, - ACTIONS(1501), 1, + ACTIONS(1509), 1, anon_sym_PIPE_GT, - ACTIONS(1503), 1, + ACTIONS(1511), 1, anon_sym_LBRACK2, - ACTIONS(1509), 1, + ACTIONS(1517), 1, anon_sym_QMARK, - ACTIONS(1511), 1, + ACTIONS(1519), 1, anon_sym_PIPE_PIPE, - ACTIONS(1513), 1, + ACTIONS(1521), 1, anon_sym_AMP_AMP, - ACTIONS(1854), 1, + ACTIONS(1862), 1, anon_sym_LBRACE, - ACTIONS(1493), 2, + ACTIONS(1501), 2, anon_sym_STAR, anon_sym_PERCENT, - ACTIONS(1497), 2, + ACTIONS(1505), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(1507), 2, + ACTIONS(1515), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(1515), 4, + ACTIONS(1523), 4, anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_LT_EQ, @@ -62789,13 +62814,13 @@ static const uint16_t ts_small_parse_table[] = { [66017] = 12, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, STATE(1474), 1, sym_qualified_path, @@ -62804,7 +62829,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(920), 2, @@ -62813,7 +62838,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62821,13 +62846,13 @@ static const uint16_t ts_small_parse_table[] = { [66061] = 12, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, STATE(1474), 1, sym_qualified_path, @@ -62836,7 +62861,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(916), 2, @@ -62845,7 +62870,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62853,13 +62878,13 @@ static const uint16_t ts_small_parse_table[] = { [66105] = 12, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, STATE(1474), 1, sym_qualified_path, @@ -62868,7 +62893,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(929), 2, @@ -62877,7 +62902,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -62887,19 +62912,19 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1856), 1, + ACTIONS(1864), 1, anon_sym_RBRACE, - ACTIONS(1858), 1, + ACTIONS(1866), 1, anon_sym_let, - ACTIONS(1860), 1, + ACTIONS(1868), 1, anon_sym_fn, - ACTIONS(1862), 1, + ACTIONS(1870), 1, anon_sym_type, - ACTIONS(1864), 1, + ACTIONS(1872), 1, anon_sym_module, - ACTIONS(1866), 1, + ACTIONS(1874), 1, anon_sym_opaque, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -62919,19 +62944,19 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1858), 1, + ACTIONS(1866), 1, anon_sym_let, - ACTIONS(1860), 1, + ACTIONS(1868), 1, anon_sym_fn, - ACTIONS(1862), 1, + ACTIONS(1870), 1, anon_sym_type, - ACTIONS(1864), 1, + ACTIONS(1872), 1, anon_sym_module, - ACTIONS(1866), 1, + ACTIONS(1874), 1, anon_sym_opaque, - ACTIONS(1868), 1, + ACTIONS(1876), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -62951,19 +62976,19 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1858), 1, + ACTIONS(1866), 1, anon_sym_let, - ACTIONS(1860), 1, + ACTIONS(1868), 1, anon_sym_fn, - ACTIONS(1862), 1, + ACTIONS(1870), 1, anon_sym_type, - ACTIONS(1864), 1, + ACTIONS(1872), 1, anon_sym_module, - ACTIONS(1866), 1, + ACTIONS(1874), 1, anon_sym_opaque, - ACTIONS(1870), 1, + ACTIONS(1878), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -62983,19 +63008,19 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1858), 1, + ACTIONS(1866), 1, anon_sym_let, - ACTIONS(1860), 1, + ACTIONS(1868), 1, anon_sym_fn, - ACTIONS(1862), 1, + ACTIONS(1870), 1, anon_sym_type, - ACTIONS(1864), 1, + ACTIONS(1872), 1, anon_sym_module, - ACTIONS(1866), 1, + ACTIONS(1874), 1, anon_sym_opaque, - ACTIONS(1872), 1, + ACTIONS(1880), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -63015,19 +63040,19 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1858), 1, + ACTIONS(1866), 1, anon_sym_let, - ACTIONS(1860), 1, + ACTIONS(1868), 1, anon_sym_fn, - ACTIONS(1862), 1, + ACTIONS(1870), 1, anon_sym_type, - ACTIONS(1864), 1, + ACTIONS(1872), 1, anon_sym_module, - ACTIONS(1866), 1, - anon_sym_opaque, ACTIONS(1874), 1, + anon_sym_opaque, + ACTIONS(1882), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -63045,15 +63070,15 @@ static const uint16_t ts_small_parse_table[] = { [66374] = 12, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1876), 1, + ACTIONS(1884), 1, anon_sym_RBRACK, STATE(1412), 1, sym_pattern, @@ -63062,13 +63087,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -63078,19 +63103,19 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1858), 1, + ACTIONS(1866), 1, anon_sym_let, - ACTIONS(1860), 1, + ACTIONS(1868), 1, anon_sym_fn, - ACTIONS(1862), 1, + ACTIONS(1870), 1, anon_sym_type, - ACTIONS(1864), 1, + ACTIONS(1872), 1, anon_sym_module, - ACTIONS(1866), 1, + ACTIONS(1874), 1, anon_sym_opaque, - ACTIONS(1878), 1, + ACTIONS(1886), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -63110,19 +63135,19 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1858), 1, + ACTIONS(1866), 1, anon_sym_let, - ACTIONS(1860), 1, + ACTIONS(1868), 1, anon_sym_fn, - ACTIONS(1862), 1, + ACTIONS(1870), 1, anon_sym_type, - ACTIONS(1864), 1, + ACTIONS(1872), 1, anon_sym_module, - ACTIONS(1866), 1, + ACTIONS(1874), 1, anon_sym_opaque, - ACTIONS(1880), 1, + ACTIONS(1888), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -63140,15 +63165,15 @@ static const uint16_t ts_small_parse_table[] = { [66507] = 12, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1882), 1, + ACTIONS(1890), 1, anon_sym_DOT_DOT_DOT, STATE(1474), 1, sym_qualified_path, @@ -63157,13 +63182,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -63173,19 +63198,19 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1555), 1, + ACTIONS(1563), 1, anon_sym_effect, - ACTIONS(1858), 1, + ACTIONS(1866), 1, anon_sym_let, - ACTIONS(1860), 1, + ACTIONS(1868), 1, anon_sym_fn, - ACTIONS(1862), 1, + ACTIONS(1870), 1, anon_sym_type, - ACTIONS(1864), 1, + ACTIONS(1872), 1, anon_sym_module, - ACTIONS(1866), 1, + ACTIONS(1874), 1, anon_sym_opaque, - ACTIONS(1884), 1, + ACTIONS(1892), 1, anon_sym_RBRACE, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -63203,15 +63228,15 @@ static const uint16_t ts_small_parse_table[] = { [66595] = 12, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, - ACTIONS(1886), 1, + ACTIONS(1894), 1, anon_sym_DOT_DOT_DOT, STATE(1474), 1, sym_qualified_path, @@ -63220,13 +63245,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -63234,21 +63259,21 @@ static const uint16_t ts_small_parse_table[] = { [66638] = 13, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1888), 1, + ACTIONS(1896), 1, anon_sym_RBRACE, - ACTIONS(1890), 1, + ACTIONS(1898), 1, anon_sym_let, - ACTIONS(1893), 1, + ACTIONS(1901), 1, anon_sym_fn, - ACTIONS(1896), 1, + ACTIONS(1904), 1, anon_sym_type, - ACTIONS(1899), 1, + ACTIONS(1907), 1, anon_sym_effect, - ACTIONS(1902), 1, + ACTIONS(1910), 1, anon_sym_module, - ACTIONS(1905), 1, + ACTIONS(1913), 1, anon_sym_opaque, - ACTIONS(1908), 1, + ACTIONS(1916), 1, sym__doc_comment_line, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -63268,7 +63293,7 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(969), 1, anon_sym_LT, - ACTIONS(1819), 1, + ACTIONS(1827), 1, anon_sym_LBRACK, ACTIONS(965), 15, anon_sym_RBRACE, @@ -63293,7 +63318,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(969), 1, anon_sym_LT, - ACTIONS(1819), 1, + ACTIONS(1827), 1, anon_sym_LBRACK, ACTIONS(955), 14, anon_sym_RBRACE, @@ -63313,13 +63338,13 @@ static const uint16_t ts_small_parse_table[] = { [66739] = 11, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, STATE(1462), 1, sym_pattern, @@ -63328,13 +63353,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -63342,7 +63367,7 @@ static const uint16_t ts_small_parse_table[] = { [66779] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1911), 1, + ACTIONS(1919), 1, anon_sym_COLON_COLON, STATE(949), 1, aux_sym_qualified_path_repeat1, @@ -63365,13 +63390,13 @@ static const uint16_t ts_small_parse_table[] = { [66807] = 11, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, STATE(1336), 1, sym_pattern, @@ -63380,13 +63405,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -63394,13 +63419,13 @@ static const uint16_t ts_small_parse_table[] = { [66847] = 11, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1698), 1, + ACTIONS(1706), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1710), 1, anon_sym_LBRACK, - ACTIONS(1708), 1, + ACTIONS(1716), 1, sym_float, - ACTIONS(1784), 1, + ACTIONS(1792), 1, sym_identifier, STATE(1474), 1, sym_qualified_path, @@ -63409,13 +63434,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(424), 2, anon_sym_true, anon_sym_false, - ACTIONS(1704), 2, + ACTIONS(1712), 2, anon_sym_PLUS, anon_sym_DASH, STATE(1209), 2, sym_list_pattern, sym_boolean, - ACTIONS(1706), 4, + ACTIONS(1714), 4, anon_sym__, sym_integer, sym_string, @@ -63423,11 +63448,11 @@ static const uint16_t ts_small_parse_table[] = { [66887] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1914), 1, + ACTIONS(1922), 1, anon_sym_COLON_COLON, - ACTIONS(1916), 1, + ACTIONS(1924), 1, anon_sym_LT, - ACTIONS(1918), 1, + ACTIONS(1926), 1, anon_sym_LBRACK, STATE(953), 1, aux_sym_qualified_path_repeat1, @@ -63448,7 +63473,7 @@ static const uint16_t ts_small_parse_table[] = { [66919] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1914), 1, + ACTIONS(1922), 1, anon_sym_COLON_COLON, STATE(949), 1, aux_sym_qualified_path_repeat1, @@ -63491,13 +63516,13 @@ static const uint16_t ts_small_parse_table[] = { [66970] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1920), 1, + ACTIONS(1928), 1, sym_identifier, - ACTIONS(1922), 1, + ACTIONS(1930), 1, anon_sym_LBRACE, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, STATE(486), 1, sym_variant, @@ -63516,13 +63541,13 @@ static const uint16_t ts_small_parse_table[] = { [67004] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1928), 1, + ACTIONS(1936), 1, sym_identifier, - ACTIONS(1930), 1, + ACTIONS(1938), 1, anon_sym_LBRACE, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, STATE(578), 1, sym_variant, @@ -63541,13 +63566,13 @@ static const uint16_t ts_small_parse_table[] = { [67038] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1922), 1, + ACTIONS(1930), 1, anon_sym_LBRACE, - ACTIONS(1936), 1, + ACTIONS(1944), 1, sym_identifier, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, STATE(486), 1, sym_variant, @@ -63566,13 +63591,13 @@ static const uint16_t ts_small_parse_table[] = { [67072] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1920), 1, + ACTIONS(1928), 1, sym_identifier, - ACTIONS(1922), 1, + ACTIONS(1930), 1, anon_sym_LBRACE, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, STATE(486), 1, sym_variant, @@ -63591,13 +63616,13 @@ static const uint16_t ts_small_parse_table[] = { [67106] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1920), 1, + ACTIONS(1928), 1, sym_identifier, - ACTIONS(1922), 1, + ACTIONS(1930), 1, anon_sym_LBRACE, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, STATE(486), 1, sym_variant, @@ -63616,13 +63641,13 @@ static const uint16_t ts_small_parse_table[] = { [67140] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1922), 1, + ACTIONS(1930), 1, anon_sym_LBRACE, - ACTIONS(1936), 1, + ACTIONS(1944), 1, sym_identifier, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, STATE(486), 1, sym_variant, @@ -63641,13 +63666,13 @@ static const uint16_t ts_small_parse_table[] = { [67174] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1928), 1, + ACTIONS(1936), 1, sym_identifier, - ACTIONS(1930), 1, + ACTIONS(1938), 1, anon_sym_LBRACE, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, STATE(578), 1, sym_variant, @@ -63666,13 +63691,13 @@ static const uint16_t ts_small_parse_table[] = { [67208] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1922), 1, + ACTIONS(1930), 1, anon_sym_LBRACE, - ACTIONS(1936), 1, + ACTIONS(1944), 1, sym_identifier, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, STATE(486), 1, sym_variant, @@ -63691,13 +63716,13 @@ static const uint16_t ts_small_parse_table[] = { [67242] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1928), 1, + ACTIONS(1936), 1, sym_identifier, - ACTIONS(1930), 1, + ACTIONS(1938), 1, anon_sym_LBRACE, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, STATE(578), 1, sym_variant, @@ -63716,13 +63741,13 @@ static const uint16_t ts_small_parse_table[] = { [67276] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1922), 1, + ACTIONS(1930), 1, anon_sym_LBRACE, - ACTIONS(1936), 1, + ACTIONS(1944), 1, sym_identifier, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, STATE(486), 1, sym_variant, @@ -63741,13 +63766,13 @@ static const uint16_t ts_small_parse_table[] = { [67310] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1928), 1, + ACTIONS(1936), 1, sym_identifier, - ACTIONS(1930), 1, + ACTIONS(1938), 1, anon_sym_LBRACE, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, STATE(578), 1, sym_variant, @@ -63766,13 +63791,13 @@ static const uint16_t ts_small_parse_table[] = { [67344] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1920), 1, + ACTIONS(1928), 1, sym_identifier, - ACTIONS(1922), 1, + ACTIONS(1930), 1, anon_sym_LBRACE, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, STATE(486), 1, sym_variant, @@ -63791,9 +63816,9 @@ static const uint16_t ts_small_parse_table[] = { [67378] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1916), 1, + ACTIONS(1924), 1, anon_sym_LT, - ACTIONS(1918), 1, + ACTIONS(1926), 1, anon_sym_LBRACK, ACTIONS(967), 3, anon_sym_EQ, @@ -63812,11 +63837,11 @@ static const uint16_t ts_small_parse_table[] = { [67404] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1944), 1, + ACTIONS(1952), 1, sym__doc_comment_line, STATE(973), 1, aux_sym_doc_comment_repeat1, - ACTIONS(1942), 11, + ACTIONS(1950), 11, anon_sym_namespace, anon_sym_let, anon_sym_mut, @@ -63831,9 +63856,9 @@ static const uint16_t ts_small_parse_table[] = { [67427] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1946), 1, + ACTIONS(1954), 1, anon_sym_DASH_GT, - ACTIONS(1420), 12, + ACTIONS(1428), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -63849,9 +63874,9 @@ static const uint16_t ts_small_parse_table[] = { [67448] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1948), 1, + ACTIONS(1956), 1, anon_sym_DASH_GT, - ACTIONS(1410), 12, + ACTIONS(1418), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -63867,9 +63892,9 @@ static const uint16_t ts_small_parse_table[] = { [67469] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1950), 1, + ACTIONS(1958), 1, anon_sym_DASH_GT, - ACTIONS(1396), 12, + ACTIONS(1404), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -63885,9 +63910,9 @@ static const uint16_t ts_small_parse_table[] = { [67490] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1952), 1, + ACTIONS(1960), 1, anon_sym_DASH_GT, - ACTIONS(1404), 12, + ACTIONS(1412), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -63903,11 +63928,11 @@ static const uint16_t ts_small_parse_table[] = { [67511] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1956), 1, + ACTIONS(1964), 1, sym__doc_comment_line, STATE(973), 1, aux_sym_doc_comment_repeat1, - ACTIONS(1954), 11, + ACTIONS(1962), 11, anon_sym_namespace, anon_sym_let, anon_sym_mut, @@ -63922,7 +63947,7 @@ static const uint16_t ts_small_parse_table[] = { [67534] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1959), 12, + ACTIONS(1967), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -63938,7 +63963,7 @@ static const uint16_t ts_small_parse_table[] = { [67552] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1961), 12, + ACTIONS(1969), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -63956,13 +63981,13 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(436), 1, anon_sym_COLON_COLON, - ACTIONS(1965), 1, + ACTIONS(1973), 1, anon_sym_LT, STATE(24), 1, aux_sym_qualified_path_repeat1, STATE(1102), 1, sym_type_arguments, - ACTIONS(1963), 8, + ACTIONS(1971), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64008,7 +64033,7 @@ static const uint16_t ts_small_parse_table[] = { [67636] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1967), 12, + ACTIONS(1975), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -64058,7 +64083,7 @@ static const uint16_t ts_small_parse_table[] = { [67694] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1969), 12, + ACTIONS(1977), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -64091,7 +64116,7 @@ static const uint16_t ts_small_parse_table[] = { [67732] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1971), 12, + ACTIONS(1979), 12, anon_sym_RBRACE, anon_sym_let, anon_sym_mut, @@ -64107,13 +64132,13 @@ static const uint16_t ts_small_parse_table[] = { [67750] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(1979), 1, + ACTIONS(1987), 1, anon_sym_RPAREN, STATE(967), 1, sym_qualified_path, @@ -64128,13 +64153,13 @@ static const uint16_t ts_small_parse_table[] = { [67779] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1983), 1, + ACTIONS(1991), 1, anon_sym_DASH_GT, - ACTIONS(1985), 1, + ACTIONS(1993), 1, anon_sym_BANG, STATE(1117), 1, sym_effect_set, - ACTIONS(1981), 8, + ACTIONS(1989), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64146,13 +64171,13 @@ static const uint16_t ts_small_parse_table[] = { [67802] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(1987), 1, + ACTIONS(1995), 1, anon_sym_RPAREN, STATE(967), 1, sym_qualified_path, @@ -64167,13 +64192,13 @@ static const uint16_t ts_small_parse_table[] = { [67831] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(1989), 1, + ACTIONS(1997), 1, anon_sym_RPAREN, STATE(967), 1, sym_qualified_path, @@ -64188,13 +64213,13 @@ static const uint16_t ts_small_parse_table[] = { [67860] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(1991), 1, + ACTIONS(1999), 1, anon_sym_RPAREN, STATE(967), 1, sym_qualified_path, @@ -64213,7 +64238,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, STATE(994), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1993), 9, + ACTIONS(2001), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64226,13 +64251,13 @@ static const uint16_t ts_small_parse_table[] = { [67910] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(1995), 1, + ACTIONS(2003), 1, anon_sym_RPAREN, STATE(967), 1, sym_qualified_path, @@ -64247,13 +64272,13 @@ static const uint16_t ts_small_parse_table[] = { [67939] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1985), 1, + ACTIONS(1993), 1, anon_sym_BANG, - ACTIONS(1999), 1, + ACTIONS(2007), 1, anon_sym_DASH_GT, STATE(1119), 1, sym_effect_set, - ACTIONS(1997), 8, + ACTIONS(2005), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64265,13 +64290,13 @@ static const uint16_t ts_small_parse_table[] = { [67962] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(2001), 1, + ACTIONS(2009), 1, anon_sym_RPAREN, STATE(967), 1, sym_qualified_path, @@ -64290,7 +64315,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON_COLON, STATE(30), 1, aux_sym_qualified_path_repeat1, - ACTIONS(2003), 9, + ACTIONS(2011), 9, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64303,13 +64328,13 @@ static const uint16_t ts_small_parse_table[] = { [68012] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1985), 1, + ACTIONS(1993), 1, anon_sym_BANG, - ACTIONS(2007), 1, + ACTIONS(2015), 1, anon_sym_DASH_GT, STATE(1115), 1, sym_effect_set, - ACTIONS(2005), 8, + ACTIONS(2013), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64321,13 +64346,13 @@ static const uint16_t ts_small_parse_table[] = { [68035] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(2009), 1, + ACTIONS(2017), 1, anon_sym_RPAREN, STATE(967), 1, sym_qualified_path, @@ -64342,13 +64367,13 @@ static const uint16_t ts_small_parse_table[] = { [68064] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(2011), 1, + ACTIONS(2019), 1, anon_sym_RPAREN, STATE(967), 1, sym_qualified_path, @@ -64363,13 +64388,13 @@ static const uint16_t ts_small_parse_table[] = { [68093] = 5, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1985), 1, + ACTIONS(1993), 1, anon_sym_BANG, - ACTIONS(2015), 1, + ACTIONS(2023), 1, anon_sym_DASH_GT, STATE(1108), 1, sym_effect_set, - ACTIONS(2013), 8, + ACTIONS(2021), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64381,21 +64406,21 @@ static const uint16_t ts_small_parse_table[] = { [68116] = 11, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(1614), 1, + ACTIONS(1622), 1, anon_sym_COMMA, - ACTIONS(2017), 1, + ACTIONS(2025), 1, sym_identifier, - ACTIONS(2019), 1, + ACTIONS(2027), 1, anon_sym_LBRACE, - ACTIONS(2021), 1, + ACTIONS(2029), 1, anon_sym_RBRACE, - ACTIONS(2023), 1, + ACTIONS(2031), 1, anon_sym_COLON, - ACTIONS(2025), 1, + ACTIONS(2033), 1, anon_sym_LPAREN, - ACTIONS(2027), 1, + ACTIONS(2035), 1, anon_sym_EQ_GT, STATE(716), 1, aux_sym_qualified_path_repeat1, @@ -64404,11 +64429,11 @@ static const uint16_t ts_small_parse_table[] = { [68150] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1985), 1, + ACTIONS(1993), 1, anon_sym_BANG, STATE(1111), 1, sym_effect_set, - ACTIONS(2029), 8, + ACTIONS(2037), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64420,13 +64445,13 @@ static const uint16_t ts_small_parse_table[] = { [68170] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, - ACTIONS(2031), 1, + ACTIONS(2039), 1, anon_sym_LBRACE, STATE(967), 1, sym_qualified_path, @@ -64439,11 +64464,11 @@ static const uint16_t ts_small_parse_table[] = { [68196] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1985), 1, + ACTIONS(1993), 1, anon_sym_BANG, STATE(1116), 1, sym_effect_set, - ACTIONS(2033), 8, + ACTIONS(2041), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64455,11 +64480,11 @@ static const uint16_t ts_small_parse_table[] = { [68216] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1965), 1, + ACTIONS(1973), 1, anon_sym_LT, STATE(1102), 1, sym_type_arguments, - ACTIONS(1963), 8, + ACTIONS(1971), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64471,11 +64496,11 @@ static const uint16_t ts_small_parse_table[] = { [68236] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1985), 1, + ACTIONS(1993), 1, anon_sym_BANG, STATE(1104), 1, sym_effect_set, - ACTIONS(2035), 8, + ACTIONS(2043), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64487,33 +64512,33 @@ static const uint16_t ts_small_parse_table[] = { [68256] = 10, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2039), 1, + ACTIONS(2047), 1, anon_sym_fn, - ACTIONS(2041), 1, + ACTIONS(2049), 1, anon_sym_extern, - ACTIONS(2043), 1, + ACTIONS(2051), 1, anon_sym_type, - ACTIONS(2045), 1, + ACTIONS(2053), 1, anon_sym_effect, - ACTIONS(2047), 1, + ACTIONS(2055), 1, anon_sym_state, - ACTIONS(2049), 1, + ACTIONS(2057), 1, anon_sym_module, - ACTIONS(2051), 1, + ACTIONS(2059), 1, anon_sym_export, - ACTIONS(2053), 1, + ACTIONS(2061), 1, anon_sym_signature, - ACTIONS(2037), 2, + ACTIONS(2045), 2, anon_sym_let, anon_sym_mut, [68288] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64528,11 +64553,11 @@ static const uint16_t ts_small_parse_table[] = { [68314] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(1985), 1, + ACTIONS(1993), 1, anon_sym_BANG, STATE(1112), 1, sym_effect_set, - ACTIONS(2055), 8, + ACTIONS(2063), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64544,11 +64569,11 @@ static const uint16_t ts_small_parse_table[] = { [68334] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64563,11 +64588,11 @@ static const uint16_t ts_small_parse_table[] = { [68360] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64582,11 +64607,11 @@ static const uint16_t ts_small_parse_table[] = { [68386] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2059), 1, + ACTIONS(2067), 1, anon_sym_EQ, - ACTIONS(2061), 1, + ACTIONS(2069), 1, anon_sym_LT, - ACTIONS(2057), 8, + ACTIONS(2065), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64598,11 +64623,11 @@ static const uint16_t ts_small_parse_table[] = { [68406] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64617,11 +64642,11 @@ static const uint16_t ts_small_parse_table[] = { [68432] = 4, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2065), 1, + ACTIONS(2073), 1, anon_sym_EQ, - ACTIONS(2067), 1, + ACTIONS(2075), 1, anon_sym_LT, - ACTIONS(2063), 8, + ACTIONS(2071), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64633,41 +64658,41 @@ static const uint16_t ts_small_parse_table[] = { [68452] = 10, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2045), 1, + ACTIONS(2053), 1, anon_sym_effect, - ACTIONS(2047), 1, + ACTIONS(2055), 1, anon_sym_state, - ACTIONS(2049), 1, + ACTIONS(2057), 1, anon_sym_module, - ACTIONS(2053), 1, + ACTIONS(2061), 1, anon_sym_signature, - ACTIONS(2069), 1, + ACTIONS(2077), 1, anon_sym_namespace, - ACTIONS(2073), 1, + ACTIONS(2081), 1, anon_sym_fn, - ACTIONS(2075), 1, + ACTIONS(2083), 1, anon_sym_extern, - ACTIONS(2077), 1, + ACTIONS(2085), 1, anon_sym_type, - ACTIONS(2071), 2, + ACTIONS(2079), 2, anon_sym_let, anon_sym_mut, [68484] = 8, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2017), 1, + ACTIONS(2025), 1, sym_identifier, - ACTIONS(2019), 1, + ACTIONS(2027), 1, anon_sym_LBRACE, - ACTIONS(2023), 1, + ACTIONS(2031), 1, anon_sym_COLON, - ACTIONS(2025), 1, + ACTIONS(2033), 1, anon_sym_LPAREN, STATE(716), 1, aux_sym_qualified_path_repeat1, - ACTIONS(2027), 4, + ACTIONS(2035), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -64675,11 +64700,11 @@ static const uint16_t ts_small_parse_table[] = { [68512] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64694,33 +64719,33 @@ static const uint16_t ts_small_parse_table[] = { [68538] = 10, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2079), 1, + ACTIONS(2087), 1, anon_sym_namespace, - ACTIONS(2083), 1, + ACTIONS(2091), 1, anon_sym_fn, - ACTIONS(2085), 1, + ACTIONS(2093), 1, anon_sym_extern, - ACTIONS(2087), 1, + ACTIONS(2095), 1, anon_sym_type, - ACTIONS(2089), 1, + ACTIONS(2097), 1, anon_sym_effect, - ACTIONS(2091), 1, + ACTIONS(2099), 1, anon_sym_state, - ACTIONS(2093), 1, + ACTIONS(2101), 1, anon_sym_module, - ACTIONS(2095), 1, + ACTIONS(2103), 1, anon_sym_signature, - ACTIONS(2081), 2, + ACTIONS(2089), 2, anon_sym_let, anon_sym_mut, [68570] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64733,11 +64758,11 @@ static const uint16_t ts_small_parse_table[] = { [68593] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64750,11 +64775,11 @@ static const uint16_t ts_small_parse_table[] = { [68616] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -64767,11 +64792,11 @@ static const uint16_t ts_small_parse_table[] = { [68639] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -64784,11 +64809,11 @@ static const uint16_t ts_small_parse_table[] = { [68662] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, - ACTIONS(2099), 1, + ACTIONS(2107), 1, sym_identifier, STATE(536), 1, sym_qualified_path, @@ -64801,11 +64826,11 @@ static const uint16_t ts_small_parse_table[] = { [68685] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -64818,11 +64843,11 @@ static const uint16_t ts_small_parse_table[] = { [68708] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -64835,9 +64860,9 @@ static const uint16_t ts_small_parse_table[] = { [68731] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2103), 1, + ACTIONS(2111), 1, anon_sym_EQ, - ACTIONS(2101), 8, + ACTIONS(2109), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -64849,11 +64874,11 @@ static const uint16_t ts_small_parse_table[] = { [68748] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64866,11 +64891,11 @@ static const uint16_t ts_small_parse_table[] = { [68771] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, - ACTIONS(2099), 1, + ACTIONS(2107), 1, sym_identifier, STATE(536), 1, sym_qualified_path, @@ -64883,11 +64908,11 @@ static const uint16_t ts_small_parse_table[] = { [68794] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, - ACTIONS(2105), 1, + ACTIONS(2113), 1, sym_identifier, STATE(541), 1, sym_qualified_path, @@ -64900,11 +64925,11 @@ static const uint16_t ts_small_parse_table[] = { [68817] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, - ACTIONS(2105), 1, + ACTIONS(2113), 1, sym_identifier, STATE(541), 1, sym_qualified_path, @@ -64917,11 +64942,11 @@ static const uint16_t ts_small_parse_table[] = { [68840] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64934,11 +64959,11 @@ static const uint16_t ts_small_parse_table[] = { [68863] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64951,11 +64976,11 @@ static const uint16_t ts_small_parse_table[] = { [68886] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64968,11 +64993,11 @@ static const uint16_t ts_small_parse_table[] = { [68909] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -64985,11 +65010,11 @@ static const uint16_t ts_small_parse_table[] = { [68932] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, - ACTIONS(2099), 1, + ACTIONS(2107), 1, sym_identifier, STATE(536), 1, sym_qualified_path, @@ -65002,11 +65027,11 @@ static const uint16_t ts_small_parse_table[] = { [68955] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65019,11 +65044,11 @@ static const uint16_t ts_small_parse_table[] = { [68978] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, - ACTIONS(2099), 1, + ACTIONS(2107), 1, sym_identifier, STATE(536), 1, sym_qualified_path, @@ -65036,11 +65061,11 @@ static const uint16_t ts_small_parse_table[] = { [69001] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, - ACTIONS(2099), 1, + ACTIONS(2107), 1, sym_identifier, STATE(536), 1, sym_qualified_path, @@ -65053,11 +65078,11 @@ static const uint16_t ts_small_parse_table[] = { [69024] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65070,11 +65095,11 @@ static const uint16_t ts_small_parse_table[] = { [69047] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, - ACTIONS(2099), 1, + ACTIONS(2107), 1, sym_identifier, STATE(536), 1, sym_qualified_path, @@ -65087,11 +65112,11 @@ static const uint16_t ts_small_parse_table[] = { [69070] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65104,11 +65129,11 @@ static const uint16_t ts_small_parse_table[] = { [69093] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, - ACTIONS(2105), 1, + ACTIONS(2113), 1, sym_identifier, STATE(541), 1, sym_qualified_path, @@ -65121,11 +65146,11 @@ static const uint16_t ts_small_parse_table[] = { [69116] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, - ACTIONS(2105), 1, + ACTIONS(2113), 1, sym_identifier, STATE(541), 1, sym_qualified_path, @@ -65138,31 +65163,31 @@ static const uint16_t ts_small_parse_table[] = { [69139] = 9, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2039), 1, + ACTIONS(2047), 1, anon_sym_fn, - ACTIONS(2041), 1, + ACTIONS(2049), 1, anon_sym_extern, - ACTIONS(2043), 1, + ACTIONS(2051), 1, anon_sym_type, - ACTIONS(2045), 1, + ACTIONS(2053), 1, anon_sym_effect, - ACTIONS(2047), 1, + ACTIONS(2055), 1, anon_sym_state, - ACTIONS(2049), 1, + ACTIONS(2057), 1, anon_sym_module, - ACTIONS(2053), 1, + ACTIONS(2061), 1, anon_sym_signature, - ACTIONS(2037), 2, + ACTIONS(2045), 2, anon_sym_let, anon_sym_mut, [69168] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65175,11 +65200,11 @@ static const uint16_t ts_small_parse_table[] = { [69191] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65192,11 +65217,11 @@ static const uint16_t ts_small_parse_table[] = { [69214] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65209,11 +65234,11 @@ static const uint16_t ts_small_parse_table[] = { [69237] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65226,11 +65251,11 @@ static const uint16_t ts_small_parse_table[] = { [69260] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65243,11 +65268,11 @@ static const uint16_t ts_small_parse_table[] = { [69283] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65260,11 +65285,11 @@ static const uint16_t ts_small_parse_table[] = { [69306] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65277,11 +65302,11 @@ static const uint16_t ts_small_parse_table[] = { [69329] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65294,11 +65319,11 @@ static const uint16_t ts_small_parse_table[] = { [69352] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, - ACTIONS(2105), 1, + ACTIONS(2113), 1, sym_identifier, STATE(541), 1, sym_qualified_path, @@ -65311,11 +65336,11 @@ static const uint16_t ts_small_parse_table[] = { [69375] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65328,11 +65353,11 @@ static const uint16_t ts_small_parse_table[] = { [69398] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65345,11 +65370,11 @@ static const uint16_t ts_small_parse_table[] = { [69421] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65362,9 +65387,9 @@ static const uint16_t ts_small_parse_table[] = { [69444] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2109), 1, + ACTIONS(2117), 1, anon_sym_PLUS, - ACTIONS(2107), 8, + ACTIONS(2115), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -65376,11 +65401,11 @@ static const uint16_t ts_small_parse_table[] = { [69461] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, - ACTIONS(2105), 1, + ACTIONS(2113), 1, sym_identifier, STATE(541), 1, sym_qualified_path, @@ -65393,11 +65418,11 @@ static const uint16_t ts_small_parse_table[] = { [69484] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65410,11 +65435,11 @@ static const uint16_t ts_small_parse_table[] = { [69507] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65427,11 +65452,11 @@ static const uint16_t ts_small_parse_table[] = { [69530] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65444,11 +65469,11 @@ static const uint16_t ts_small_parse_table[] = { [69553] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65461,11 +65486,11 @@ static const uint16_t ts_small_parse_table[] = { [69576] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65478,11 +65503,11 @@ static const uint16_t ts_small_parse_table[] = { [69599] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65495,11 +65520,11 @@ static const uint16_t ts_small_parse_table[] = { [69622] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65512,11 +65537,11 @@ static const uint16_t ts_small_parse_table[] = { [69645] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65529,11 +65554,11 @@ static const uint16_t ts_small_parse_table[] = { [69668] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65546,11 +65571,11 @@ static const uint16_t ts_small_parse_table[] = { [69691] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65563,9 +65588,9 @@ static const uint16_t ts_small_parse_table[] = { [69714] = 3, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2113), 1, + ACTIONS(2121), 1, anon_sym_EQ, - ACTIONS(2111), 8, + ACTIONS(2119), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -65577,11 +65602,11 @@ static const uint16_t ts_small_parse_table[] = { [69731] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65594,11 +65619,11 @@ static const uint16_t ts_small_parse_table[] = { [69754] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65611,11 +65636,11 @@ static const uint16_t ts_small_parse_table[] = { [69777] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65628,11 +65653,11 @@ static const uint16_t ts_small_parse_table[] = { [69800] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65645,11 +65670,11 @@ static const uint16_t ts_small_parse_table[] = { [69823] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65662,11 +65687,11 @@ static const uint16_t ts_small_parse_table[] = { [69846] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65679,11 +65704,11 @@ static const uint16_t ts_small_parse_table[] = { [69869] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65696,11 +65721,11 @@ static const uint16_t ts_small_parse_table[] = { [69892] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65713,11 +65738,11 @@ static const uint16_t ts_small_parse_table[] = { [69915] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1932), 1, + ACTIONS(1940), 1, anon_sym_fn, - ACTIONS(1934), 1, + ACTIONS(1942), 1, anon_sym_LPAREN, - ACTIONS(2099), 1, + ACTIONS(2107), 1, sym_identifier, STATE(536), 1, sym_qualified_path, @@ -65730,11 +65755,11 @@ static const uint16_t ts_small_parse_table[] = { [69938] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65747,11 +65772,11 @@ static const uint16_t ts_small_parse_table[] = { [69961] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1938), 1, + ACTIONS(1946), 1, anon_sym_fn, - ACTIONS(1940), 1, + ACTIONS(1948), 1, anon_sym_LPAREN, - ACTIONS(2105), 1, + ACTIONS(2113), 1, sym_identifier, STATE(541), 1, sym_qualified_path, @@ -65764,11 +65789,11 @@ static const uint16_t ts_small_parse_table[] = { [69984] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65781,11 +65806,11 @@ static const uint16_t ts_small_parse_table[] = { [70007] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65798,11 +65823,11 @@ static const uint16_t ts_small_parse_table[] = { [70030] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65815,11 +65840,11 @@ static const uint16_t ts_small_parse_table[] = { [70053] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65832,11 +65857,11 @@ static const uint16_t ts_small_parse_table[] = { [70076] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65849,11 +65874,11 @@ static const uint16_t ts_small_parse_table[] = { [70099] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65866,11 +65891,11 @@ static const uint16_t ts_small_parse_table[] = { [70122] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65883,11 +65908,11 @@ static const uint16_t ts_small_parse_table[] = { [70145] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65900,11 +65925,11 @@ static const uint16_t ts_small_parse_table[] = { [70168] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65917,11 +65942,11 @@ static const uint16_t ts_small_parse_table[] = { [70191] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65934,11 +65959,11 @@ static const uint16_t ts_small_parse_table[] = { [70214] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65951,11 +65976,11 @@ static const uint16_t ts_small_parse_table[] = { [70237] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -65968,11 +65993,11 @@ static const uint16_t ts_small_parse_table[] = { [70260] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -65985,11 +66010,11 @@ static const uint16_t ts_small_parse_table[] = { [70283] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -66002,11 +66027,11 @@ static const uint16_t ts_small_parse_table[] = { [70306] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -66019,11 +66044,11 @@ static const uint16_t ts_small_parse_table[] = { [70329] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -66036,11 +66061,11 @@ static const uint16_t ts_small_parse_table[] = { [70352] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -66053,11 +66078,11 @@ static const uint16_t ts_small_parse_table[] = { [70375] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -66070,11 +66095,11 @@ static const uint16_t ts_small_parse_table[] = { [70398] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -66087,11 +66112,11 @@ static const uint16_t ts_small_parse_table[] = { [70421] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1924), 1, + ACTIONS(1932), 1, anon_sym_fn, - ACTIONS(1926), 1, + ACTIONS(1934), 1, anon_sym_LPAREN, - ACTIONS(2097), 1, + ACTIONS(2105), 1, sym_identifier, STATE(946), 1, sym_qualified_path, @@ -66104,11 +66129,11 @@ static const uint16_t ts_small_parse_table[] = { [70444] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1973), 1, + ACTIONS(1981), 1, sym_identifier, - ACTIONS(1975), 1, + ACTIONS(1983), 1, anon_sym_fn, - ACTIONS(1977), 1, + ACTIONS(1985), 1, anon_sym_LPAREN, STATE(967), 1, sym_qualified_path, @@ -66121,7 +66146,7 @@ static const uint16_t ts_small_parse_table[] = { [70467] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2115), 8, + ACTIONS(2123), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66133,7 +66158,7 @@ static const uint16_t ts_small_parse_table[] = { [70481] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2117), 8, + ACTIONS(2125), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66145,7 +66170,7 @@ static const uint16_t ts_small_parse_table[] = { [70495] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2119), 8, + ACTIONS(2127), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66157,7 +66182,7 @@ static const uint16_t ts_small_parse_table[] = { [70509] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2121), 8, + ACTIONS(2129), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66169,7 +66194,7 @@ static const uint16_t ts_small_parse_table[] = { [70523] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2123), 8, + ACTIONS(2131), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66181,7 +66206,7 @@ static const uint16_t ts_small_parse_table[] = { [70537] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2125), 8, + ACTIONS(2133), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66193,15 +66218,15 @@ static const uint16_t ts_small_parse_table[] = { [70551] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2127), 1, + ACTIONS(2135), 1, anon_sym_LT, STATE(716), 1, aux_sym_qualified_path_repeat1, STATE(1226), 1, sym_type_arguments, - ACTIONS(1963), 4, + ACTIONS(1971), 4, anon_sym_LBRACE, anon_sym_COMMA, anon_sym_EQ, @@ -66209,7 +66234,7 @@ static const uint16_t ts_small_parse_table[] = { [70573] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2129), 8, + ACTIONS(2137), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66221,7 +66246,7 @@ static const uint16_t ts_small_parse_table[] = { [70587] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2131), 8, + ACTIONS(2139), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66233,7 +66258,7 @@ static const uint16_t ts_small_parse_table[] = { [70601] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2133), 8, + ACTIONS(2141), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66245,7 +66270,7 @@ static const uint16_t ts_small_parse_table[] = { [70615] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2135), 8, + ACTIONS(2143), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66257,7 +66282,7 @@ static const uint16_t ts_small_parse_table[] = { [70629] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2137), 8, + ACTIONS(2145), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66269,7 +66294,7 @@ static const uint16_t ts_small_parse_table[] = { [70643] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2139), 8, + ACTIONS(2147), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66281,7 +66306,7 @@ static const uint16_t ts_small_parse_table[] = { [70657] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2141), 8, + ACTIONS(2149), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66293,7 +66318,7 @@ static const uint16_t ts_small_parse_table[] = { [70671] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2143), 8, + ACTIONS(2151), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66305,7 +66330,7 @@ static const uint16_t ts_small_parse_table[] = { [70685] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2145), 8, + ACTIONS(2153), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66317,7 +66342,7 @@ static const uint16_t ts_small_parse_table[] = { [70699] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2147), 8, + ACTIONS(2155), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66329,7 +66354,7 @@ static const uint16_t ts_small_parse_table[] = { [70713] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2149), 8, + ACTIONS(2157), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66341,7 +66366,7 @@ static const uint16_t ts_small_parse_table[] = { [70727] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2151), 8, + ACTIONS(2159), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66353,7 +66378,7 @@ static const uint16_t ts_small_parse_table[] = { [70741] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2153), 8, + ACTIONS(2161), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66365,7 +66390,7 @@ static const uint16_t ts_small_parse_table[] = { [70755] = 2, ACTIONS(3), 1, sym_line_comment, - ACTIONS(2155), 8, + ACTIONS(2163), 8, anon_sym_RBRACE, anon_sym_let, anon_sym_fn, @@ -66377,13 +66402,13 @@ static const uint16_t ts_small_parse_table[] = { [70769] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2159), 1, + ACTIONS(2167), 1, anon_sym_EQ, - ACTIONS(2161), 1, + ACTIONS(2169), 1, anon_sym_DASH_GT, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, STATE(583), 1, sym_block, @@ -66392,13 +66417,13 @@ static const uint16_t ts_small_parse_table[] = { [70791] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2167), 1, + ACTIONS(2175), 1, anon_sym_EQ, - ACTIONS(2169), 1, + ACTIONS(2177), 1, anon_sym_DASH_GT, STATE(586), 1, sym_block, @@ -66407,13 +66432,13 @@ static const uint16_t ts_small_parse_table[] = { [70813] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2171), 1, + ACTIONS(2179), 1, anon_sym_EQ, - ACTIONS(2173), 1, + ACTIONS(2181), 1, anon_sym_DASH_GT, STATE(519), 1, sym_block, @@ -66422,13 +66447,13 @@ static const uint16_t ts_small_parse_table[] = { [70835] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2175), 1, + ACTIONS(2183), 1, anon_sym_EQ, - ACTIONS(2177), 1, + ACTIONS(2185), 1, anon_sym_DASH_GT, STATE(552), 1, sym_block, @@ -66437,13 +66462,13 @@ static const uint16_t ts_small_parse_table[] = { [70857] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2181), 1, + ACTIONS(2189), 1, anon_sym_EQ, - ACTIONS(2183), 1, + ACTIONS(2191), 1, anon_sym_DASH_GT, STATE(677), 1, sym_block, @@ -66452,13 +66477,13 @@ static const uint16_t ts_small_parse_table[] = { [70879] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2185), 1, + ACTIONS(2193), 1, anon_sym_EQ, - ACTIONS(2187), 1, + ACTIONS(2195), 1, anon_sym_DASH_GT, STATE(575), 1, sym_block, @@ -66467,13 +66492,13 @@ static const uint16_t ts_small_parse_table[] = { [70901] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2189), 1, + ACTIONS(2197), 1, anon_sym_EQ, - ACTIONS(2191), 1, + ACTIONS(2199), 1, anon_sym_DASH_GT, STATE(641), 1, sym_block, @@ -66482,13 +66507,13 @@ static const uint16_t ts_small_parse_table[] = { [70923] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2193), 1, + ACTIONS(2201), 1, anon_sym_EQ, - ACTIONS(2195), 1, + ACTIONS(2203), 1, anon_sym_DASH_GT, STATE(552), 1, sym_block, @@ -66497,13 +66522,13 @@ static const uint16_t ts_small_parse_table[] = { [70945] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2197), 1, + ACTIONS(2205), 1, anon_sym_EQ, - ACTIONS(2199), 1, + ACTIONS(2207), 1, anon_sym_DASH_GT, STATE(660), 1, sym_block, @@ -66512,11 +66537,11 @@ static const uint16_t ts_small_parse_table[] = { [70967] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2127), 1, + ACTIONS(2135), 1, anon_sym_LT, STATE(1226), 1, sym_type_arguments, - ACTIONS(1963), 4, + ACTIONS(1971), 4, anon_sym_LBRACE, anon_sym_COMMA, anon_sym_EQ, @@ -66524,13 +66549,13 @@ static const uint16_t ts_small_parse_table[] = { [70983] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2201), 1, + ACTIONS(2209), 1, anon_sym_EQ, - ACTIONS(2203), 1, + ACTIONS(2211), 1, anon_sym_DASH_GT, STATE(689), 1, sym_block, @@ -66539,13 +66564,13 @@ static const uint16_t ts_small_parse_table[] = { [71005] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2205), 1, + ACTIONS(2213), 1, anon_sym_EQ, - ACTIONS(2207), 1, + ACTIONS(2215), 1, anon_sym_DASH_GT, STATE(586), 1, sym_block, @@ -66554,13 +66579,13 @@ static const uint16_t ts_small_parse_table[] = { [71027] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2209), 1, + ACTIONS(2217), 1, anon_sym_EQ, - ACTIONS(2211), 1, + ACTIONS(2219), 1, anon_sym_DASH_GT, STATE(585), 1, sym_block, @@ -66569,13 +66594,13 @@ static const uint16_t ts_small_parse_table[] = { [71049] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2213), 1, + ACTIONS(2221), 1, anon_sym_EQ, - ACTIONS(2215), 1, + ACTIONS(2223), 1, anon_sym_DASH_GT, STATE(691), 1, sym_block, @@ -66584,13 +66609,13 @@ static const uint16_t ts_small_parse_table[] = { [71071] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2217), 1, + ACTIONS(2225), 1, anon_sym_EQ, - ACTIONS(2219), 1, + ACTIONS(2227), 1, anon_sym_DASH_GT, STATE(575), 1, sym_block, @@ -66599,13 +66624,13 @@ static const uint16_t ts_small_parse_table[] = { [71093] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2221), 1, + ACTIONS(2229), 1, anon_sym_EQ, - ACTIONS(2223), 1, + ACTIONS(2231), 1, anon_sym_DASH_GT, STATE(519), 1, sym_block, @@ -66614,13 +66639,13 @@ static const uint16_t ts_small_parse_table[] = { [71115] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2225), 1, + ACTIONS(2233), 1, anon_sym_EQ, - ACTIONS(2227), 1, + ACTIONS(2235), 1, anon_sym_DASH_GT, STATE(568), 1, sym_block, @@ -66629,13 +66654,13 @@ static const uint16_t ts_small_parse_table[] = { [71137] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2229), 1, + ACTIONS(2237), 1, anon_sym_EQ, - ACTIONS(2231), 1, + ACTIONS(2239), 1, anon_sym_DASH_GT, STATE(585), 1, sym_block, @@ -66644,13 +66669,13 @@ static const uint16_t ts_small_parse_table[] = { [71159] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2233), 1, + ACTIONS(2241), 1, anon_sym_EQ, - ACTIONS(2235), 1, + ACTIONS(2243), 1, anon_sym_DASH_GT, STATE(701), 1, sym_block, @@ -66659,13 +66684,13 @@ static const uint16_t ts_small_parse_table[] = { [71181] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2237), 1, + ACTIONS(2245), 1, anon_sym_EQ, - ACTIONS(2239), 1, + ACTIONS(2247), 1, anon_sym_DASH_GT, STATE(545), 1, sym_block, @@ -66674,13 +66699,13 @@ static const uint16_t ts_small_parse_table[] = { [71203] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2241), 1, + ACTIONS(2249), 1, anon_sym_EQ, - ACTIONS(2243), 1, + ACTIONS(2251), 1, anon_sym_DASH_GT, STATE(673), 1, sym_block, @@ -66689,13 +66714,13 @@ static const uint16_t ts_small_parse_table[] = { [71225] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2245), 1, + ACTIONS(2253), 1, anon_sym_EQ, - ACTIONS(2247), 1, + ACTIONS(2255), 1, anon_sym_DASH_GT, STATE(545), 1, sym_block, @@ -66704,13 +66729,13 @@ static const uint16_t ts_small_parse_table[] = { [71247] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2249), 1, + ACTIONS(2257), 1, anon_sym_EQ, - ACTIONS(2251), 1, + ACTIONS(2259), 1, anon_sym_DASH_GT, STATE(583), 1, sym_block, @@ -66719,13 +66744,13 @@ static const uint16_t ts_small_parse_table[] = { [71269] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2253), 1, + ACTIONS(2261), 1, anon_sym_EQ, - ACTIONS(2255), 1, + ACTIONS(2263), 1, anon_sym_DASH_GT, STATE(568), 1, sym_block, @@ -66734,13 +66759,13 @@ static const uint16_t ts_small_parse_table[] = { [71291] = 7, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2257), 1, + ACTIONS(2265), 1, anon_sym_EQ, - ACTIONS(2259), 1, + ACTIONS(2267), 1, anon_sym_DASH_GT, STATE(655), 1, sym_block, @@ -66749,23 +66774,23 @@ static const uint16_t ts_small_parse_table[] = { [71313] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1586), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71330] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2265), 1, + ACTIONS(2273), 1, anon_sym_EQ, STATE(546), 1, sym_block, @@ -66774,11 +66799,11 @@ static const uint16_t ts_small_parse_table[] = { [71349] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2267), 1, + ACTIONS(2275), 1, anon_sym_EQ, STATE(534), 1, sym_block, @@ -66787,21 +66812,21 @@ static const uint16_t ts_small_parse_table[] = { [71368] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1520), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71385] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2269), 1, + ACTIONS(2277), 1, sym_identifier, STATE(716), 1, aux_sym_qualified_path_repeat1, @@ -66811,11 +66836,11 @@ static const uint16_t ts_small_parse_table[] = { [71402] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2271), 1, + ACTIONS(2279), 1, anon_sym_EQ, STATE(542), 1, sym_block, @@ -66824,11 +66849,11 @@ static const uint16_t ts_small_parse_table[] = { [71421] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2273), 1, + ACTIONS(2281), 1, anon_sym_EQ, STATE(546), 1, sym_block, @@ -66837,11 +66862,11 @@ static const uint16_t ts_small_parse_table[] = { [71440] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2275), 1, + ACTIONS(2283), 1, anon_sym_EQ, STATE(559), 1, sym_block, @@ -66852,7 +66877,7 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -66863,35 +66888,35 @@ static const uint16_t ts_small_parse_table[] = { [71478] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1665), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71495] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2277), 1, + ACTIONS(2285), 1, anon_sym_COLON, STATE(717), 1, aux_sym_qualified_path_repeat1, - ACTIONS(2003), 2, + ACTIONS(2011), 2, anon_sym_LBRACE, anon_sym_PLUS, [71512] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2279), 1, + ACTIONS(2287), 1, anon_sym_EQ, STATE(559), 1, sym_block, @@ -66900,23 +66925,23 @@ static const uint16_t ts_small_parse_table[] = { [71531] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1561), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71548] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2281), 1, + ACTIONS(2289), 1, anon_sym_EQ, STATE(679), 1, sym_block, @@ -66925,11 +66950,11 @@ static const uint16_t ts_small_parse_table[] = { [71567] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2283), 1, + ACTIONS(2291), 1, anon_sym_EQ, STATE(527), 1, sym_block, @@ -66938,9 +66963,9 @@ static const uint16_t ts_small_parse_table[] = { [71586] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2269), 1, + ACTIONS(2277), 1, sym_identifier, STATE(716), 1, aux_sym_qualified_path_repeat1, @@ -66950,11 +66975,11 @@ static const uint16_t ts_small_parse_table[] = { [71603] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2285), 1, + ACTIONS(2293), 1, anon_sym_EQ, STATE(683), 1, sym_block, @@ -66963,35 +66988,35 @@ static const uint16_t ts_small_parse_table[] = { [71622] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2287), 1, + ACTIONS(2295), 1, anon_sym_COLON, STATE(1156), 1, aux_sym_qualified_path_repeat1, - ACTIONS(1993), 2, + ACTIONS(2001), 2, anon_sym_LBRACE, anon_sym_PLUS, [71639] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1638), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71656] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2289), 1, + ACTIONS(2297), 1, anon_sym_EQ, STATE(667), 1, sym_block, @@ -67000,11 +67025,11 @@ static const uint16_t ts_small_parse_table[] = { [71675] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2291), 1, + ACTIONS(2299), 1, anon_sym_EQ, STATE(542), 1, sym_block, @@ -67013,33 +67038,33 @@ static const uint16_t ts_small_parse_table[] = { [71694] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1507), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71711] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1531), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71728] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2269), 1, + ACTIONS(2277), 1, sym_identifier, STATE(716), 1, aux_sym_qualified_path_repeat1, @@ -67049,9 +67074,9 @@ static const uint16_t ts_small_parse_table[] = { [71745] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2293), 1, + ACTIONS(2301), 1, sym_identifier, - ACTIONS(2295), 1, + ACTIONS(2303), 1, sym_string, STATE(508), 1, sym_import_target, @@ -67062,9 +67087,9 @@ static const uint16_t ts_small_parse_table[] = { [71764] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2269), 1, + ACTIONS(2277), 1, sym_identifier, STATE(716), 1, aux_sym_qualified_path_repeat1, @@ -67074,11 +67099,11 @@ static const uint16_t ts_small_parse_table[] = { [71781] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2297), 1, + ACTIONS(2305), 1, anon_sym_EQ, STATE(527), 1, sym_block, @@ -67087,11 +67112,11 @@ static const uint16_t ts_small_parse_table[] = { [71800] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2299), 1, + ACTIONS(2307), 1, anon_sym_EQ, STATE(572), 1, sym_block, @@ -67100,11 +67125,11 @@ static const uint16_t ts_small_parse_table[] = { [71819] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2301), 1, + ACTIONS(2309), 1, anon_sym_EQ, STATE(534), 1, sym_block, @@ -67113,11 +67138,11 @@ static const uint16_t ts_small_parse_table[] = { [71838] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2303), 1, + ACTIONS(2311), 1, anon_sym_EQ, STATE(698), 1, sym_block, @@ -67126,33 +67151,33 @@ static const uint16_t ts_small_parse_table[] = { [71857] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1731), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71874] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1782), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71891] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2305), 1, + ACTIONS(2313), 1, sym_identifier, - ACTIONS(2307), 1, + ACTIONS(2315), 1, sym_string, STATE(492), 1, sym_namespace_name, @@ -67163,11 +67188,11 @@ static const uint16_t ts_small_parse_table[] = { [71910] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2309), 1, + ACTIONS(2317), 1, anon_sym_EQ, STATE(704), 1, sym_block, @@ -67176,11 +67201,11 @@ static const uint16_t ts_small_parse_table[] = { [71929] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2311), 1, + ACTIONS(2319), 1, anon_sym_EQ, STATE(590), 1, sym_block, @@ -67189,11 +67214,11 @@ static const uint16_t ts_small_parse_table[] = { [71948] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2313), 1, + ACTIONS(2321), 1, anon_sym_EQ, STATE(705), 1, sym_block, @@ -67202,23 +67227,23 @@ static const uint16_t ts_small_parse_table[] = { [71967] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1608), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [71984] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2315), 1, + ACTIONS(2323), 1, anon_sym_EQ, STATE(558), 1, sym_block, @@ -67227,23 +67252,23 @@ static const uint16_t ts_small_parse_table[] = { [72003] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1652), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72020] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2317), 1, + ACTIONS(2325), 1, anon_sym_EQ, STATE(710), 1, sym_block, @@ -67252,11 +67277,11 @@ static const uint16_t ts_small_parse_table[] = { [72039] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2319), 1, + ACTIONS(2327), 1, anon_sym_EQ, STATE(590), 1, sym_block, @@ -67265,49 +67290,49 @@ static const uint16_t ts_small_parse_table[] = { [72058] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1667), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72075] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1612), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72092] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1719), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72109] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1726), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72126] = 6, @@ -67315,7 +67340,7 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, ACTIONS(67), 1, sym__doc_comment_line, - ACTIONS(1553), 1, + ACTIONS(1561), 1, anon_sym_type, STATE(968), 1, aux_sym_doc_comment_repeat1, @@ -67326,35 +67351,35 @@ static const uint16_t ts_small_parse_table[] = { [72145] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1762), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72162] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1765), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72179] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2321), 1, + ACTIONS(2329), 1, anon_sym_EQ, STATE(572), 1, sym_block, @@ -67363,35 +67388,35 @@ static const uint16_t ts_small_parse_table[] = { [72198] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1772), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72215] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1370), 1, sym_type_parameter, STATE(1773), 1, sym_type_parameter_list, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [72232] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2323), 1, + ACTIONS(2331), 1, anon_sym_EQ, STATE(558), 1, sym_block, @@ -67400,11 +67425,11 @@ static const uint16_t ts_small_parse_table[] = { [72251] = 6, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2163), 1, + ACTIONS(2171), 1, anon_sym_BANG, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2325), 1, + ACTIONS(2333), 1, anon_sym_EQ, STATE(693), 1, sym_block, @@ -67413,17 +67438,17 @@ static const uint16_t ts_small_parse_table[] = { [72270] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2327), 1, + ACTIONS(2335), 1, anon_sym_COMMA, STATE(1199), 1, aux_sym_parameter_list_repeat1, - ACTIONS(2330), 2, + ACTIONS(2338), 2, anon_sym_RPAREN, anon_sym_PIPE, [72284] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2332), 4, + ACTIONS(2340), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -67431,7 +67456,7 @@ static const uint16_t ts_small_parse_table[] = { [72294] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2334), 4, + ACTIONS(2342), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -67439,7 +67464,7 @@ static const uint16_t ts_small_parse_table[] = { [72304] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2336), 4, + ACTIONS(2344), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -67447,9 +67472,9 @@ static const uint16_t ts_small_parse_table[] = { [72314] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2340), 1, + ACTIONS(2348), 1, anon_sym_PIPE, STATE(1211), 1, sym_parameter, @@ -67458,7 +67483,7 @@ static const uint16_t ts_small_parse_table[] = { [72330] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2342), 4, + ACTIONS(2350), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -67466,9 +67491,9 @@ static const uint16_t ts_small_parse_table[] = { [72340] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, - ACTIONS(2346), 1, + ACTIONS(2354), 1, anon_sym_RPAREN, STATE(1333), 1, sym_extern_parameter, @@ -67477,9 +67502,9 @@ static const uint16_t ts_small_parse_table[] = { [72356] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, - ACTIONS(2348), 1, + ACTIONS(2356), 1, anon_sym_RPAREN, STATE(1333), 1, sym_extern_parameter, @@ -67488,9 +67513,9 @@ static const uint16_t ts_small_parse_table[] = { [72372] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2352), 1, + ACTIONS(2360), 1, anon_sym_RBRACE, STATE(1247), 2, sym_operation_declaration, @@ -67498,9 +67523,9 @@ static const uint16_t ts_small_parse_table[] = { [72386] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2354), 1, + ACTIONS(2362), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67509,7 +67534,7 @@ static const uint16_t ts_small_parse_table[] = { [72402] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2356), 4, + ACTIONS(2364), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -67517,37 +67542,37 @@ static const uint16_t ts_small_parse_table[] = { [72412] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2358), 1, + ACTIONS(2366), 1, anon_sym_COMMA, STATE(1210), 1, aux_sym_type_list_repeat1, - ACTIONS(2361), 2, + ACTIONS(2369), 2, anon_sym_GT, anon_sym_RPAREN, [72426] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2363), 1, + ACTIONS(2371), 1, anon_sym_COMMA, STATE(1237), 1, aux_sym_parameter_list_repeat1, - ACTIONS(2365), 2, + ACTIONS(2373), 2, anon_sym_RPAREN, anon_sym_PIPE, [72440] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2367), 1, + ACTIONS(2375), 1, anon_sym_COMMA, STATE(1210), 1, aux_sym_type_list_repeat1, - ACTIONS(2369), 2, + ACTIONS(2377), 2, anon_sym_GT, anon_sym_RPAREN, [72454] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2135), 4, + ACTIONS(2143), 4, anon_sym_LBRACE, anon_sym_COMMA, anon_sym_EQ, @@ -67555,9 +67580,9 @@ static const uint16_t ts_small_parse_table[] = { [72464] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2371), 1, + ACTIONS(2379), 1, anon_sym_RBRACE, STATE(1219), 2, sym_operation_declaration, @@ -67565,9 +67590,9 @@ static const uint16_t ts_small_parse_table[] = { [72478] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2373), 1, + ACTIONS(2381), 1, sym_identifier, - ACTIONS(2375), 1, + ACTIONS(2383), 1, anon_sym_in, STATE(1266), 2, sym_handler_arm, @@ -67575,9 +67600,9 @@ static const uint16_t ts_small_parse_table[] = { [72492] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, - ACTIONS(2377), 1, + ACTIONS(2385), 1, anon_sym_RPAREN, STATE(1333), 1, sym_extern_parameter, @@ -67586,9 +67611,9 @@ static const uint16_t ts_small_parse_table[] = { [72508] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2379), 1, + ACTIONS(2387), 1, sym_identifier, - ACTIONS(2381), 1, + ACTIONS(2389), 1, anon_sym_RBRACE, STATE(1291), 1, sym_import_member, @@ -67597,9 +67622,9 @@ static const uint16_t ts_small_parse_table[] = { [72524] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, - ACTIONS(2383), 1, + ACTIONS(2391), 1, anon_sym_RPAREN, STATE(1333), 1, sym_extern_parameter, @@ -67608,9 +67633,9 @@ static const uint16_t ts_small_parse_table[] = { [72540] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2385), 1, + ACTIONS(2393), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -67618,9 +67643,9 @@ static const uint16_t ts_small_parse_table[] = { [72554] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2387), 1, + ACTIONS(2395), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -67628,9 +67653,9 @@ static const uint16_t ts_small_parse_table[] = { [72568] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2389), 1, + ACTIONS(2397), 1, anon_sym_RBRACE, STATE(1224), 2, sym_operation_declaration, @@ -67638,9 +67663,9 @@ static const uint16_t ts_small_parse_table[] = { [72582] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2391), 1, + ACTIONS(2399), 1, sym_identifier, - ACTIONS(2393), 1, + ACTIONS(2401), 1, anon_sym_LBRACK, STATE(1003), 1, sym_qualified_path, @@ -67649,9 +67674,9 @@ static const uint16_t ts_small_parse_table[] = { [72598] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, - ACTIONS(2395), 1, + ACTIONS(2403), 1, anon_sym_RPAREN, STATE(1333), 1, sym_extern_parameter, @@ -67660,9 +67685,9 @@ static const uint16_t ts_small_parse_table[] = { [72614] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2397), 1, + ACTIONS(2405), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -67670,9 +67695,9 @@ static const uint16_t ts_small_parse_table[] = { [72628] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2399), 1, + ACTIONS(2407), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67681,7 +67706,7 @@ static const uint16_t ts_small_parse_table[] = { [72644] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2119), 4, + ACTIONS(2127), 4, anon_sym_LBRACE, anon_sym_COMMA, anon_sym_EQ, @@ -67689,9 +67714,9 @@ static const uint16_t ts_small_parse_table[] = { [72654] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2401), 1, + ACTIONS(2409), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67700,9 +67725,9 @@ static const uint16_t ts_small_parse_table[] = { [72670] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2403), 1, + ACTIONS(2411), 1, anon_sym_RBRACE, STATE(1230), 2, sym_operation_declaration, @@ -67710,9 +67735,9 @@ static const uint16_t ts_small_parse_table[] = { [72684] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2405), 1, + ACTIONS(2413), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67721,9 +67746,9 @@ static const uint16_t ts_small_parse_table[] = { [72700] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2407), 1, + ACTIONS(2415), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -67731,9 +67756,9 @@ static const uint16_t ts_small_parse_table[] = { [72714] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, - ACTIONS(2409), 1, + ACTIONS(2417), 1, anon_sym_RPAREN, STATE(1333), 1, sym_extern_parameter, @@ -67742,9 +67767,9 @@ static const uint16_t ts_small_parse_table[] = { [72730] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2411), 1, + ACTIONS(2419), 1, anon_sym_RBRACE, STATE(1234), 2, sym_operation_declaration, @@ -67752,9 +67777,9 @@ static const uint16_t ts_small_parse_table[] = { [72744] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2413), 1, + ACTIONS(2421), 1, anon_sym_RBRACE, STATE(1220), 2, sym_operation_declaration, @@ -67762,9 +67787,9 @@ static const uint16_t ts_small_parse_table[] = { [72758] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2415), 1, + ACTIONS(2423), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -67772,7 +67797,7 @@ static const uint16_t ts_small_parse_table[] = { [72772] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2417), 1, + ACTIONS(2425), 1, sym_identifier, STATE(1130), 1, sym_qualified_path, @@ -67783,9 +67808,9 @@ static const uint16_t ts_small_parse_table[] = { [72788] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2373), 1, + ACTIONS(2381), 1, sym_identifier, - ACTIONS(2419), 1, + ACTIONS(2427), 1, anon_sym_in, STATE(1266), 2, sym_handler_arm, @@ -67793,19 +67818,19 @@ static const uint16_t ts_small_parse_table[] = { [72802] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2363), 1, + ACTIONS(2371), 1, anon_sym_COMMA, STATE(1199), 1, aux_sym_parameter_list_repeat1, - ACTIONS(2421), 2, + ACTIONS(2429), 2, anon_sym_RPAREN, anon_sym_PIPE, [72816] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2417), 1, + ACTIONS(2425), 1, sym_identifier, - ACTIONS(2423), 1, + ACTIONS(2431), 1, anon_sym_LBRACK, STATE(1130), 1, sym_qualified_path, @@ -67814,9 +67839,9 @@ static const uint16_t ts_small_parse_table[] = { [72832] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2425), 1, + ACTIONS(2433), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -67824,9 +67849,9 @@ static const uint16_t ts_small_parse_table[] = { [72846] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2427), 1, + ACTIONS(2435), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -67834,9 +67859,9 @@ static const uint16_t ts_small_parse_table[] = { [72860] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2373), 1, + ACTIONS(2381), 1, sym_identifier, - ACTIONS(2429), 1, + ACTIONS(2437), 1, anon_sym_in, STATE(1266), 2, sym_handler_arm, @@ -67844,9 +67869,9 @@ static const uint16_t ts_small_parse_table[] = { [72874] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2431), 1, + ACTIONS(2439), 1, anon_sym_RBRACE, STATE(1239), 2, sym_operation_declaration, @@ -67854,9 +67879,9 @@ static const uint16_t ts_small_parse_table[] = { [72888] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2433), 1, + ACTIONS(2441), 1, anon_sym_PIPE, STATE(1211), 1, sym_parameter, @@ -67865,9 +67890,9 @@ static const uint16_t ts_small_parse_table[] = { [72904] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2435), 1, + ACTIONS(2443), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67876,7 +67901,7 @@ static const uint16_t ts_small_parse_table[] = { [72920] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2437), 4, + ACTIONS(2445), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -67884,9 +67909,9 @@ static const uint16_t ts_small_parse_table[] = { [72930] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2379), 1, + ACTIONS(2387), 1, sym_identifier, - ACTIONS(2439), 1, + ACTIONS(2447), 1, anon_sym_RBRACE, STATE(1291), 1, sym_import_member, @@ -67895,9 +67920,9 @@ static const uint16_t ts_small_parse_table[] = { [72946] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2441), 1, + ACTIONS(2449), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -67905,9 +67930,9 @@ static const uint16_t ts_small_parse_table[] = { [72960] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2443), 1, + ACTIONS(2451), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67916,19 +67941,19 @@ static const uint16_t ts_small_parse_table[] = { [72976] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2367), 1, + ACTIONS(2375), 1, anon_sym_COMMA, STATE(1212), 1, aux_sym_type_list_repeat1, - ACTIONS(2445), 2, + ACTIONS(2453), 2, anon_sym_GT, anon_sym_RPAREN, [72990] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2447), 1, + ACTIONS(2455), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67937,9 +67962,9 @@ static const uint16_t ts_small_parse_table[] = { [73006] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2449), 1, + ACTIONS(2457), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67948,7 +67973,7 @@ static const uint16_t ts_small_parse_table[] = { [73022] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2417), 1, + ACTIONS(2425), 1, sym_identifier, STATE(1130), 1, sym_qualified_path, @@ -67959,19 +67984,19 @@ static const uint16_t ts_small_parse_table[] = { [73038] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2451), 1, + ACTIONS(2459), 1, anon_sym_COMMA, STATE(1253), 1, aux_sym_argument_list_repeat1, - ACTIONS(1670), 2, + ACTIONS(1678), 2, anon_sym_RPAREN, anon_sym_RBRACK, [73052] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2454), 1, + ACTIONS(2462), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -67980,9 +68005,9 @@ static const uint16_t ts_small_parse_table[] = { [73068] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2456), 1, + ACTIONS(2464), 1, anon_sym_PIPE, STATE(1211), 1, sym_parameter, @@ -67991,9 +68016,9 @@ static const uint16_t ts_small_parse_table[] = { [73084] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2458), 1, + ACTIONS(2466), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -68002,9 +68027,9 @@ static const uint16_t ts_small_parse_table[] = { [73100] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2460), 1, + ACTIONS(2468), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -68013,18 +68038,18 @@ static const uint16_t ts_small_parse_table[] = { [73116] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2464), 1, + ACTIONS(2472), 1, anon_sym_COLON, - ACTIONS(2462), 3, + ACTIONS(2470), 3, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_PIPE, [73128] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2466), 1, + ACTIONS(2474), 1, sym_identifier, - ACTIONS(2469), 1, + ACTIONS(2477), 1, anon_sym_RBRACE, STATE(1259), 2, sym_operation_declaration, @@ -68032,9 +68057,9 @@ static const uint16_t ts_small_parse_table[] = { [73142] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2471), 1, + ACTIONS(2479), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -68043,9 +68068,9 @@ static const uint16_t ts_small_parse_table[] = { [73158] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2350), 1, + ACTIONS(2358), 1, sym_identifier, - ACTIONS(2473), 1, + ACTIONS(2481), 1, anon_sym_RBRACE, STATE(1240), 2, sym_operation_declaration, @@ -68053,9 +68078,9 @@ static const uint16_t ts_small_parse_table[] = { [73172] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2475), 1, + ACTIONS(2483), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -68064,9 +68089,9 @@ static const uint16_t ts_small_parse_table[] = { [73188] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2477), 1, + ACTIONS(2485), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -68075,9 +68100,9 @@ static const uint16_t ts_small_parse_table[] = { [73204] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2479), 1, + ACTIONS(2487), 1, anon_sym_PIPE, STATE(1211), 1, sym_parameter, @@ -68086,9 +68111,9 @@ static const uint16_t ts_small_parse_table[] = { [73220] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2481), 1, + ACTIONS(2489), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -68097,9 +68122,9 @@ static const uint16_t ts_small_parse_table[] = { [73236] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2483), 1, + ACTIONS(2491), 1, sym_identifier, - ACTIONS(2486), 1, + ACTIONS(2494), 1, anon_sym_in, STATE(1266), 2, sym_handler_arm, @@ -68107,7 +68132,7 @@ static const uint16_t ts_small_parse_table[] = { [73250] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2488), 4, + ACTIONS(2496), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -68115,9 +68140,9 @@ static const uint16_t ts_small_parse_table[] = { [73260] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, - ACTIONS(2490), 1, + ACTIONS(2498), 1, anon_sym_RPAREN, STATE(1333), 1, sym_extern_parameter, @@ -68126,7 +68151,7 @@ static const uint16_t ts_small_parse_table[] = { [73276] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2492), 4, + ACTIONS(2500), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -68134,9 +68159,9 @@ static const uint16_t ts_small_parse_table[] = { [73286] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, - ACTIONS(2494), 1, + ACTIONS(2502), 1, anon_sym_RPAREN, STATE(1333), 1, sym_extern_parameter, @@ -68145,7 +68170,7 @@ static const uint16_t ts_small_parse_table[] = { [73302] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2496), 4, + ACTIONS(2504), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -68153,7 +68178,7 @@ static const uint16_t ts_small_parse_table[] = { [73312] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2498), 4, + ACTIONS(2506), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -68161,7 +68186,7 @@ static const uint16_t ts_small_parse_table[] = { [73322] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2500), 4, + ACTIONS(2508), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -68169,9 +68194,9 @@ static const uint16_t ts_small_parse_table[] = { [73332] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2502), 1, + ACTIONS(2510), 1, sym_identifier, - ACTIONS(2504), 1, + ACTIONS(2512), 1, anon_sym_EQ_GT, STATE(1388), 1, aux_sym_handler_params_repeat1, @@ -68180,9 +68205,9 @@ static const uint16_t ts_small_parse_table[] = { [73348] = 5, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, - ACTIONS(2506), 1, + ACTIONS(2514), 1, anon_sym_RPAREN, STATE(1211), 1, sym_parameter, @@ -68191,9 +68216,9 @@ static const uint16_t ts_small_parse_table[] = { [73364] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2373), 1, + ACTIONS(2381), 1, sym_identifier, - ACTIONS(2508), 1, + ACTIONS(2516), 1, anon_sym_in, STATE(1266), 2, sym_handler_arm, @@ -68201,7 +68226,7 @@ static const uint16_t ts_small_parse_table[] = { [73378] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2510), 4, + ACTIONS(2518), 4, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, @@ -68209,195 +68234,195 @@ static const uint16_t ts_small_parse_table[] = { [73388] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2261), 1, + ACTIONS(2269), 1, sym_identifier, STATE(1490), 1, sym_type_parameter, - ACTIONS(2263), 2, + ACTIONS(2271), 2, anon_sym_in, anon_sym_out, [73402] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2512), 1, + ACTIONS(2520), 1, anon_sym_RBRACE, - ACTIONS(2514), 1, + ACTIONS(2522), 1, anon_sym_COMMA, STATE(1368), 1, aux_sym_field_declarations_repeat1, [73415] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2516), 1, + ACTIONS(2524), 1, anon_sym_EQ, STATE(699), 1, sym_block, [73428] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2518), 1, + ACTIONS(2526), 1, anon_sym_EQ, STATE(700), 1, sym_block, [73441] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2520), 1, + ACTIONS(2528), 1, anon_sym_EQ, STATE(702), 1, sym_block, [73454] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2522), 1, + ACTIONS(2530), 1, anon_sym_EQ, STATE(703), 1, sym_block, [73467] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2524), 1, + ACTIONS(2532), 1, anon_sym_RBRACE, - ACTIONS(2526), 1, + ACTIONS(2534), 1, anon_sym_COMMA, STATE(1303), 1, aux_sym_map_literal_repeat1, [73480] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2528), 1, + ACTIONS(2536), 1, anon_sym_EQ, STATE(706), 1, sym_block, [73493] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2530), 1, + ACTIONS(2538), 1, anon_sym_EQ, STATE(708), 1, sym_block, [73506] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2532), 1, + ACTIONS(2540), 1, anon_sym_EQ, STATE(709), 1, sym_block, [73519] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2534), 1, + ACTIONS(2542), 1, anon_sym_as, - ACTIONS(2536), 2, + ACTIONS(2544), 2, anon_sym_RBRACE, anon_sym_COMMA, [73530] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2538), 1, + ACTIONS(2546), 1, anon_sym_EQ, STATE(711), 1, sym_block, [73543] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2526), 1, + ACTIONS(2534), 1, anon_sym_COMMA, - ACTIONS(2540), 1, + ACTIONS(2548), 1, anon_sym_RBRACE, STATE(1294), 1, aux_sym_map_literal_repeat1, [73556] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2542), 1, + ACTIONS(2550), 1, anon_sym_RBRACE, - ACTIONS(2544), 1, + ACTIONS(2552), 1, anon_sym_COMMA, STATE(1381), 1, aux_sym_import_member_list_repeat1, [73569] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2546), 1, + ACTIONS(2554), 1, anon_sym_COMMA, - ACTIONS(2548), 1, + ACTIONS(2556), 1, anon_sym_RBRACK, STATE(1393), 1, aux_sym_effect_list_repeat1, [73582] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2550), 1, + ACTIONS(2558), 1, anon_sym_COMMA, - ACTIONS(2553), 1, + ACTIONS(2561), 1, anon_sym_RPAREN, STATE(1293), 1, aux_sym_extern_parameter_list_repeat1, [73595] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2526), 1, + ACTIONS(2534), 1, anon_sym_COMMA, - ACTIONS(2555), 1, + ACTIONS(2563), 1, anon_sym_RBRACE, STATE(1303), 1, aux_sym_map_literal_repeat1, [73608] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2559), 1, + ACTIONS(2567), 1, anon_sym_where, - ACTIONS(2557), 2, + ACTIONS(2565), 2, anon_sym_RBRACE, anon_sym_COMMA, [73619] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1666), 1, + ACTIONS(1674), 1, anon_sym_COMMA, - ACTIONS(2561), 1, + ACTIONS(2569), 1, anon_sym_RBRACK, STATE(1253), 1, aux_sym_argument_list_repeat1, [73632] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2563), 1, + ACTIONS(2571), 1, anon_sym_EQ, STATE(588), 1, sym_block, [73645] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2565), 1, + ACTIONS(2573), 1, anon_sym_LBRACE, - ACTIONS(2567), 1, + ACTIONS(2575), 1, anon_sym_COLON, STATE(1793), 1, sym_signature_ascription, [73658] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -68406,18 +68431,18 @@ static const uint16_t ts_small_parse_table[] = { [73671] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2571), 1, + ACTIONS(2579), 1, anon_sym_EQ, STATE(532), 1, sym_block, [73684] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2573), 1, + ACTIONS(2581), 1, anon_sym_EQ, STATE(530), 1, sym_block, @@ -68426,281 +68451,281 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, STATE(1389), 1, sym_namespace_name, - ACTIONS(2575), 2, + ACTIONS(2583), 2, sym_string, sym_identifier, [73708] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2577), 1, + ACTIONS(2585), 1, anon_sym_RBRACE, - ACTIONS(2579), 1, + ACTIONS(2587), 1, anon_sym_COMMA, STATE(1303), 1, aux_sym_map_literal_repeat1, [73721] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2582), 1, + ACTIONS(2590), 1, anon_sym_RBRACE, - ACTIONS(2584), 1, + ACTIONS(2592), 1, anon_sym_COMMA, STATE(1304), 1, aux_sym_field_declarations_repeat1, [73734] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2587), 1, + ACTIONS(2595), 1, anon_sym_EQ, STATE(532), 1, sym_block, [73747] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2589), 1, + ACTIONS(2597), 1, anon_sym_LBRACE, - ACTIONS(2591), 1, + ACTIONS(2599), 1, anon_sym_if, STATE(766), 1, sym_if_expression, [73760] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2593), 1, + ACTIONS(2601), 1, anon_sym_EQ, STATE(571), 1, sym_block, [73773] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2595), 1, + ACTIONS(2603), 1, anon_sym_EQ, STATE(564), 1, sym_block, [73786] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2605), 1, anon_sym_COMMA, - ACTIONS(2599), 1, + ACTIONS(2607), 1, anon_sym_GT, STATE(1397), 1, aux_sym_type_parameter_list_repeat1, [73799] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2601), 1, + ACTIONS(2609), 1, anon_sym_EQ, STATE(588), 1, sym_block, [73812] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2603), 1, + ACTIONS(2611), 1, anon_sym_EQ, STATE(535), 1, sym_block, [73825] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2605), 1, + ACTIONS(2613), 1, anon_sym_EQ, STATE(549), 1, sym_block, [73838] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2607), 1, + ACTIONS(2615), 1, anon_sym_EQ, STATE(554), 1, sym_block, [73851] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2609), 1, + ACTIONS(2617), 1, anon_sym_EQ, STATE(571), 1, sym_block, [73864] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2611), 1, + ACTIONS(2619), 1, anon_sym_EQ, STATE(535), 1, sym_block, [73877] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2613), 3, + ACTIONS(2621), 3, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_PIPE, [73886] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2330), 3, + ACTIONS(2338), 3, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_PIPE, [73895] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2615), 1, + ACTIONS(2623), 1, anon_sym_EQ, STATE(562), 1, sym_block, [73908] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1666), 1, + ACTIONS(1674), 1, anon_sym_COMMA, - ACTIONS(2617), 1, + ACTIONS(2625), 1, anon_sym_RBRACK, STATE(1253), 1, aux_sym_argument_list_repeat1, [73921] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2619), 1, + ACTIONS(2627), 1, anon_sym_EQ, STATE(530), 1, sym_block, [73934] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2621), 1, + ACTIONS(2629), 1, anon_sym_EQ, STATE(547), 1, sym_block, [73947] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2623), 1, + ACTIONS(2631), 1, anon_sym_EQ, STATE(569), 1, sym_block, [73960] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1614), 1, + ACTIONS(1622), 1, anon_sym_COMMA, - ACTIONS(2021), 1, + ACTIONS(2029), 1, anon_sym_RBRACE, STATE(1355), 1, aux_sym_field_pattern_repeat1, [73973] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2625), 1, + ACTIONS(2633), 1, anon_sym_EQ, STATE(526), 1, sym_block, [73986] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2627), 1, + ACTIONS(2635), 1, anon_sym_EQ, STATE(537), 1, sym_block, [73999] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2629), 1, + ACTIONS(2637), 1, anon_sym_EQ, STATE(549), 1, sym_block, [74012] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2631), 1, + ACTIONS(2639), 1, anon_sym_EQ, STATE(555), 1, sym_block, [74025] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2633), 1, + ACTIONS(2641), 1, anon_sym_EQ, STATE(515), 1, sym_block, [74038] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2526), 1, + ACTIONS(2534), 1, anon_sym_COMMA, - ACTIONS(2635), 1, + ACTIONS(2643), 1, anon_sym_RBRACE, STATE(1303), 1, aux_sym_map_literal_repeat1, [74051] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2165), 1, + ACTIONS(2173), 1, anon_sym_LBRACE, - ACTIONS(2637), 1, + ACTIONS(2645), 1, anon_sym_EQ, STATE(573), 1, sym_block, [74064] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2639), 1, + ACTIONS(2647), 1, anon_sym_EQ, STATE(569), 1, sym_block, [74077] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1666), 1, + ACTIONS(1674), 1, anon_sym_COMMA, - ACTIONS(2641), 1, + ACTIONS(2649), 1, anon_sym_RPAREN, STATE(1253), 1, aux_sym_argument_list_repeat1, [74090] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2643), 1, + ACTIONS(2651), 1, anon_sym_COMMA, - ACTIONS(2645), 1, + ACTIONS(2653), 1, anon_sym_RPAREN, STATE(1356), 1, aux_sym_extern_parameter_list_repeat1, @@ -68709,24 +68734,24 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, STATE(1391), 1, sym_namespace_name, - ACTIONS(2575), 2, + ACTIONS(2583), 2, sym_string, sym_identifier, [74114] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2647), 1, + ACTIONS(2655), 1, anon_sym_LBRACE, - ACTIONS(2649), 1, + ACTIONS(2657), 1, anon_sym_SEMI, STATE(638), 1, sym_namespace_body, [74127] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2651), 1, + ACTIONS(2659), 1, anon_sym_COMMA, - ACTIONS(2653), 1, + ACTIONS(2661), 1, anon_sym_RPAREN, STATE(1407), 1, aux_sym_pattern_repeat1, @@ -68735,22 +68760,22 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, STATE(1372), 1, sym_namespace_name, - ACTIONS(2575), 2, + ACTIONS(2583), 2, sym_string, sym_identifier, [74151] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2655), 1, + ACTIONS(2663), 1, anon_sym_EQ, STATE(555), 1, sym_block, [74164] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2269), 1, + ACTIONS(2277), 1, sym_identifier, STATE(1215), 2, sym_handler_arm, @@ -68758,25 +68783,25 @@ static const uint16_t ts_small_parse_table[] = { [74175] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2657), 1, + ACTIONS(2665), 1, anon_sym_EQ, STATE(564), 1, sym_block, [74188] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2567), 1, + ACTIONS(2575), 1, anon_sym_COLON, - ACTIONS(2659), 1, + ACTIONS(2667), 1, anon_sym_LBRACE, STATE(1577), 1, sym_signature_ascription, [74201] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -68785,7 +68810,7 @@ static const uint16_t ts_small_parse_table[] = { [74214] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2417), 1, + ACTIONS(2425), 1, sym_identifier, STATE(1130), 1, sym_qualified_path, @@ -68794,16 +68819,16 @@ static const uint16_t ts_small_parse_table[] = { [74227] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2661), 1, + ACTIONS(2669), 1, anon_sym_COMMA, - ACTIONS(2664), 1, + ACTIONS(2672), 1, anon_sym_RPAREN, STATE(1344), 1, aux_sym_pattern_repeat1, [74240] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -68814,38 +68839,38 @@ static const uint16_t ts_small_parse_table[] = { sym_line_comment, STATE(1335), 1, sym_namespace_name, - ACTIONS(2575), 2, + ACTIONS(2583), 2, sym_string, sym_identifier, [74264] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2666), 1, + ACTIONS(2674), 1, anon_sym_COMMA, - ACTIONS(2668), 1, + ACTIONS(2676), 1, anon_sym_RPAREN, STATE(1399), 1, aux_sym_named_argument_list_repeat1, [74277] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2361), 3, + ACTIONS(2369), 3, anon_sym_COMMA, anon_sym_GT, anon_sym_RPAREN, [74286] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2567), 1, + ACTIONS(2575), 1, anon_sym_COLON, - ACTIONS(2670), 1, + ACTIONS(2678), 1, anon_sym_LBRACE, STATE(1589), 1, sym_signature_ascription, [74299] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -68854,16 +68879,16 @@ static const uint16_t ts_small_parse_table[] = { [74312] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2567), 1, + ACTIONS(2575), 1, anon_sym_COLON, - ACTIONS(2672), 1, + ACTIONS(2680), 1, anon_sym_LBRACE, STATE(1598), 1, sym_signature_ascription, [74325] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2674), 1, + ACTIONS(2682), 1, sym_identifier, STATE(1279), 1, sym_field_declaration, @@ -68872,70 +68897,70 @@ static const uint16_t ts_small_parse_table[] = { [74338] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2676), 1, + ACTIONS(2684), 1, anon_sym_RBRACE, - ACTIONS(2678), 1, + ACTIONS(2686), 1, anon_sym_COMMA, STATE(1394), 1, aux_sym_field_assignments_repeat1, [74351] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2567), 1, + ACTIONS(2575), 1, anon_sym_COLON, - ACTIONS(2680), 1, + ACTIONS(2688), 1, anon_sym_LBRACE, STATE(1566), 1, sym_signature_ascription, [74364] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1614), 1, + ACTIONS(1622), 1, anon_sym_COMMA, - ACTIONS(2682), 1, + ACTIONS(2690), 1, anon_sym_RBRACE, STATE(1365), 1, aux_sym_field_pattern_repeat1, [74377] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2643), 1, + ACTIONS(2651), 1, anon_sym_COMMA, - ACTIONS(2684), 1, + ACTIONS(2692), 1, anon_sym_RPAREN, STATE(1293), 1, aux_sym_extern_parameter_list_repeat1, [74390] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2686), 1, + ACTIONS(2694), 1, anon_sym_EQ, STATE(654), 1, sym_block, [74403] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2567), 1, + ACTIONS(2575), 1, anon_sym_COLON, - ACTIONS(2688), 1, + ACTIONS(2696), 1, anon_sym_LBRACE, STATE(1609), 1, sym_signature_ascription, [74416] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2690), 1, + ACTIONS(2698), 1, anon_sym_EQ, STATE(554), 1, sym_block, [74429] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2674), 1, + ACTIONS(2682), 1, sym_identifier, STATE(1279), 1, sym_field_declaration, @@ -68944,7 +68969,7 @@ static const uint16_t ts_small_parse_table[] = { [74442] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2692), 1, + ACTIONS(2700), 1, sym_identifier, STATE(600), 1, sym_variant, @@ -68953,25 +68978,25 @@ static const uint16_t ts_small_parse_table[] = { [74455] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2546), 1, + ACTIONS(2554), 1, anon_sym_COMMA, - ACTIONS(2694), 1, + ACTIONS(2702), 1, anon_sym_RBRACK, STATE(1292), 1, aux_sym_effect_list_repeat1, [74468] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2696), 1, + ACTIONS(2704), 1, anon_sym_EQ, STATE(537), 1, sym_block, [74481] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2698), 1, + ACTIONS(2706), 1, sym_identifier, STATE(501), 1, sym_variant, @@ -68980,61 +69005,61 @@ static const uint16_t ts_small_parse_table[] = { [74494] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2700), 1, + ACTIONS(2708), 1, anon_sym_RBRACE, - ACTIONS(2702), 1, + ACTIONS(2710), 1, anon_sym_COMMA, STATE(1365), 1, aux_sym_field_pattern_repeat1, [74507] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2705), 1, + ACTIONS(2713), 1, anon_sym_EQ, STATE(515), 1, sym_block, [74520] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2707), 1, + ACTIONS(2715), 1, anon_sym_DOT, STATE(716), 1, aux_sym_qualified_path_repeat1, [74533] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2514), 1, + ACTIONS(2522), 1, anon_sym_COMMA, - ACTIONS(2709), 1, + ACTIONS(2717), 1, anon_sym_RBRACE, STATE(1304), 1, aux_sym_field_declarations_repeat1, [74546] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2567), 1, + ACTIONS(2575), 1, anon_sym_COLON, - ACTIONS(2711), 1, + ACTIONS(2719), 1, anon_sym_LBRACE, STATE(1670), 1, sym_signature_ascription, [74559] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2597), 1, + ACTIONS(2605), 1, anon_sym_COMMA, - ACTIONS(2713), 1, + ACTIONS(2721), 1, anon_sym_GT, STATE(1309), 1, aux_sym_type_parameter_list_repeat1, [74572] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2269), 1, + ACTIONS(2277), 1, sym_identifier, STATE(1236), 2, sym_handler_arm, @@ -69042,16 +69067,16 @@ static const uint16_t ts_small_parse_table[] = { [74583] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2715), 1, + ACTIONS(2723), 1, anon_sym_LBRACE, - ACTIONS(2717), 1, + ACTIONS(2725), 1, anon_sym_SEMI, STATE(628), 1, sym_namespace_body, [74596] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -69060,7 +69085,7 @@ static const uint16_t ts_small_parse_table[] = { [74609] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -69069,34 +69094,34 @@ static const uint16_t ts_small_parse_table[] = { [74622] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2678), 1, + ACTIONS(2686), 1, anon_sym_COMMA, - ACTIONS(2719), 1, + ACTIONS(2727), 1, anon_sym_RBRACE, STATE(1353), 1, aux_sym_field_assignments_repeat1, [74635] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2721), 1, + ACTIONS(2729), 1, anon_sym_EQ, STATE(526), 1, sym_block, [74648] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2723), 1, + ACTIONS(2731), 1, anon_sym_EQ, STATE(547), 1, sym_block, [74661] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -69105,124 +69130,124 @@ static const uint16_t ts_small_parse_table[] = { [74674] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2666), 1, + ACTIONS(2674), 1, anon_sym_COMMA, - ACTIONS(2725), 1, + ACTIONS(2733), 1, anon_sym_RPAREN, STATE(1347), 1, aux_sym_named_argument_list_repeat1, [74687] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1666), 1, + ACTIONS(1674), 1, anon_sym_COMMA, - ACTIONS(2727), 1, + ACTIONS(2735), 1, anon_sym_RBRACK, STATE(1253), 1, aux_sym_argument_list_repeat1, [74700] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2544), 1, + ACTIONS(2552), 1, anon_sym_COMMA, - ACTIONS(2729), 1, + ACTIONS(2737), 1, anon_sym_RBRACE, STATE(1383), 1, aux_sym_import_member_list_repeat1, [74713] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2731), 1, + ACTIONS(2739), 1, anon_sym_EQ, STATE(668), 1, sym_block, [74726] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2733), 1, + ACTIONS(2741), 1, anon_sym_RBRACE, - ACTIONS(2735), 1, + ACTIONS(2743), 1, anon_sym_COMMA, STATE(1383), 1, aux_sym_import_member_list_repeat1, [74739] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2526), 1, + ACTIONS(2534), 1, anon_sym_COMMA, - ACTIONS(2738), 1, + ACTIONS(2746), 1, anon_sym_RBRACE, STATE(1284), 1, aux_sym_map_literal_repeat1, [74752] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2526), 1, + ACTIONS(2534), 1, anon_sym_COMMA, - ACTIONS(2740), 1, + ACTIONS(2748), 1, anon_sym_RBRACE, STATE(1329), 1, aux_sym_map_literal_repeat1, [74765] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2742), 1, + ACTIONS(2750), 1, anon_sym_LBRACE, - ACTIONS(2744), 1, + ACTIONS(2752), 1, anon_sym_if, STATE(229), 1, sym_if_expression, [74778] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2746), 1, + ACTIONS(2754), 1, anon_sym_LBRACE, - ACTIONS(2748), 1, + ACTIONS(2756), 1, anon_sym_if, STATE(52), 1, sym_if_expression, [74791] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2750), 1, + ACTIONS(2758), 1, sym_identifier, - ACTIONS(2752), 1, + ACTIONS(2760), 1, anon_sym_EQ_GT, STATE(1396), 1, aux_sym_handler_params_repeat1, [74804] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2715), 1, + ACTIONS(2723), 1, anon_sym_LBRACE, - ACTIONS(2754), 1, + ACTIONS(2762), 1, anon_sym_SEMI, STATE(694), 1, sym_namespace_body, [74817] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2756), 1, + ACTIONS(2764), 1, anon_sym_EQ, STATE(715), 1, sym_block, [74830] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2647), 1, + ACTIONS(2655), 1, anon_sym_LBRACE, - ACTIONS(2758), 1, + ACTIONS(2766), 1, anon_sym_SEMI, STATE(626), 1, sym_namespace_body, [74843] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2269), 1, + ACTIONS(2277), 1, sym_identifier, STATE(1241), 2, sym_handler_arm, @@ -69230,88 +69255,88 @@ static const uint16_t ts_small_parse_table[] = { [74854] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2760), 1, + ACTIONS(2768), 1, anon_sym_COMMA, - ACTIONS(2763), 1, + ACTIONS(2771), 1, anon_sym_RBRACK, STATE(1393), 1, aux_sym_effect_list_repeat1, [74867] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2765), 1, + ACTIONS(2773), 1, anon_sym_RBRACE, - ACTIONS(2767), 1, + ACTIONS(2775), 1, anon_sym_COMMA, STATE(1394), 1, aux_sym_field_assignments_repeat1, [74880] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2770), 1, + ACTIONS(2778), 1, anon_sym_EQ, STATE(678), 1, sym_block, [74893] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2772), 1, + ACTIONS(2780), 1, sym_identifier, - ACTIONS(2775), 1, + ACTIONS(2783), 1, anon_sym_EQ_GT, STATE(1396), 1, aux_sym_handler_params_repeat1, [74906] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2777), 1, + ACTIONS(2785), 1, anon_sym_COMMA, - ACTIONS(2780), 1, + ACTIONS(2788), 1, anon_sym_GT, STATE(1397), 1, aux_sym_type_parameter_list_repeat1, [74919] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2782), 1, + ACTIONS(2790), 1, anon_sym_COMMA, - ACTIONS(2785), 1, + ACTIONS(2793), 1, anon_sym_RBRACK, STATE(1398), 1, aux_sym_list_pattern_repeat1, [74932] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2787), 1, + ACTIONS(2795), 1, anon_sym_COMMA, - ACTIONS(2790), 1, + ACTIONS(2798), 1, anon_sym_RPAREN, STATE(1399), 1, aux_sym_named_argument_list_repeat1, [74945] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2792), 1, + ACTIONS(2800), 1, anon_sym_EQ, STATE(562), 1, sym_block, [74958] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2794), 1, + ACTIONS(2802), 1, anon_sym_EQ, STATE(684), 1, sym_block, [74971] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -69320,7 +69345,7 @@ static const uint16_t ts_small_parse_table[] = { [74984] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2269), 1, + ACTIONS(2277), 1, sym_identifier, STATE(1276), 2, sym_handler_arm, @@ -69328,43 +69353,43 @@ static const uint16_t ts_small_parse_table[] = { [74995] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2567), 1, + ACTIONS(2575), 1, anon_sym_COLON, - ACTIONS(2796), 1, + ACTIONS(2804), 1, anon_sym_LBRACE, STATE(1766), 1, sym_signature_ascription, [75008] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2798), 1, + ACTIONS(2806), 1, anon_sym_COMMA, - ACTIONS(2800), 1, + ACTIONS(2808), 1, anon_sym_RBRACK, STATE(1398), 1, aux_sym_list_pattern_repeat1, [75021] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2802), 1, + ACTIONS(2810), 1, anon_sym_DOT, STATE(716), 1, aux_sym_qualified_path_repeat1, [75034] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2651), 1, + ACTIONS(2659), 1, anon_sym_COMMA, - ACTIONS(2804), 1, + ACTIONS(2812), 1, anon_sym_RPAREN, STATE(1344), 1, aux_sym_pattern_repeat1, [75047] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1375), 1, sym_field_assignment, @@ -69373,52 +69398,52 @@ static const uint16_t ts_small_parse_table[] = { [75060] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2806), 1, + ACTIONS(2814), 1, anon_sym_EQ, STATE(688), 1, sym_block, [75073] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2808), 1, + ACTIONS(2816), 1, anon_sym_EQ, STATE(690), 1, sym_block, [75086] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1480), 1, + ACTIONS(1488), 1, anon_sym_COLON_COLON, - ACTIONS(2810), 1, + ACTIONS(2818), 1, anon_sym_DOT, STATE(716), 1, aux_sym_qualified_path_repeat1, [75099] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2812), 1, + ACTIONS(2820), 1, anon_sym_COMMA, - ACTIONS(2814), 1, + ACTIONS(2822), 1, anon_sym_RBRACK, STATE(1405), 1, aux_sym_list_pattern_repeat1, [75112] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2157), 1, + ACTIONS(2165), 1, anon_sym_LBRACE, - ACTIONS(2816), 1, + ACTIONS(2824), 1, anon_sym_EQ, STATE(573), 1, sym_block, [75125] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2674), 1, + ACTIONS(2682), 1, sym_identifier, STATE(1279), 1, sym_field_declaration, @@ -69427,16 +69452,16 @@ static const uint16_t ts_small_parse_table[] = { [75138] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2179), 1, + ACTIONS(2187), 1, anon_sym_LBRACE, - ACTIONS(2818), 1, + ACTIONS(2826), 1, anon_sym_EQ, STATE(692), 1, sym_block, [75151] = 4, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2674), 1, + ACTIONS(2682), 1, sym_identifier, STATE(1279), 1, sym_field_declaration, @@ -69445,33 +69470,33 @@ static const uint16_t ts_small_parse_table[] = { [75164] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2820), 1, + ACTIONS(2828), 1, sym_identifier, STATE(1768), 1, sym_qualified_path, [75174] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2790), 2, + ACTIONS(2798), 2, anon_sym_COMMA, anon_sym_RPAREN, [75182] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2822), 2, + ACTIONS(2830), 2, anon_sym_RBRACE, anon_sym_COMMA, [75190] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2824), 1, + ACTIONS(2832), 1, anon_sym_LBRACE, - ACTIONS(2826), 1, + ACTIONS(2834), 1, anon_sym_LT, [75200] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2733), 2, + ACTIONS(2741), 2, anon_sym_RBRACE, anon_sym_COMMA, [75208] = 2, @@ -69483,2013 +69508,2013 @@ static const uint16_t ts_small_parse_table[] = { [75216] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2828), 1, + ACTIONS(2836), 1, anon_sym_DASH_GT, - ACTIONS(2830), 1, + ACTIONS(2838), 1, anon_sym_EQ_GT, [75226] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1445), 1, sym_symbol_path, [75236] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1354), 1, sym_symbol_path, [75246] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2834), 1, + ACTIONS(2842), 1, anon_sym_LBRACE, - ACTIONS(2836), 1, + ACTIONS(2844), 1, anon_sym_LT, [75256] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2838), 2, + ACTIONS(2846), 2, anon_sym_COMMA, anon_sym_RPAREN, [75264] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2840), 1, + ACTIONS(2848), 1, anon_sym_COLON, - ACTIONS(2842), 1, + ACTIONS(2850), 1, anon_sym_EQ, [75274] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2844), 1, + ACTIONS(2852), 1, anon_sym_COLON, - ACTIONS(2846), 1, + ACTIONS(2854), 1, anon_sym_EQ, [75284] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2848), 1, + ACTIONS(2856), 1, sym_float, - ACTIONS(2850), 1, + ACTIONS(2858), 1, sym_integer, [75294] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2553), 2, + ACTIONS(2561), 2, anon_sym_COMMA, anon_sym_RPAREN, [75302] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2852), 1, + ACTIONS(2860), 1, anon_sym_DASH_GT, - ACTIONS(2854), 1, + ACTIONS(2862), 1, anon_sym_EQ_GT, [75312] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2115), 2, + ACTIONS(2123), 2, anon_sym_LBRACE, anon_sym_EQ, [75320] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2856), 1, + ACTIONS(2864), 1, anon_sym_COLON, - ACTIONS(2858), 1, + ACTIONS(2866), 1, anon_sym_EQ, [75330] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2338), 1, + ACTIONS(2346), 1, sym_identifier, STATE(1317), 1, sym_parameter, [75340] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2860), 1, + ACTIONS(2868), 1, anon_sym_COLON, - ACTIONS(2862), 1, + ACTIONS(2870), 1, anon_sym_EQ, [75350] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2864), 1, + ACTIONS(2872), 1, anon_sym_EQ, - ACTIONS(2866), 1, + ACTIONS(2874), 1, anon_sym_LT, [75360] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2868), 1, + ACTIONS(2876), 1, anon_sym_DASH_GT, - ACTIONS(2870), 1, + ACTIONS(2878), 1, anon_sym_EQ_GT, [75370] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2872), 1, + ACTIONS(2880), 1, sym_identifier, STATE(1403), 1, sym_qualified_path, [75380] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2582), 2, + ACTIONS(2590), 2, anon_sym_RBRACE, anon_sym_COMMA, [75388] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2874), 1, + ACTIONS(2882), 1, anon_sym_LBRACE, - ACTIONS(2876), 1, + ACTIONS(2884), 1, anon_sym_STAR, [75398] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2878), 2, + ACTIONS(2886), 2, anon_sym_COMMA, anon_sym_GT, [75406] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2880), 1, + ACTIONS(2888), 1, anon_sym_DASH_GT, - ACTIONS(2882), 1, + ACTIONS(2890), 1, anon_sym_EQ_GT, [75416] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2884), 1, + ACTIONS(2892), 1, anon_sym_LBRACE, - ACTIONS(2886), 1, + ACTIONS(2894), 1, anon_sym_STAR, [75426] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2107), 1, + ACTIONS(2115), 1, anon_sym_LBRACE, - ACTIONS(2888), 1, + ACTIONS(2896), 1, anon_sym_PLUS, [75436] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2890), 1, + ACTIONS(2898), 1, sym_identifier, STATE(1055), 1, sym_symbol_path, [75446] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2892), 1, + ACTIONS(2900), 1, anon_sym_LT, - ACTIONS(2894), 1, + ACTIONS(2902), 1, anon_sym_LPAREN, [75456] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2896), 1, + ACTIONS(2904), 1, sym_identifier, STATE(1737), 1, sym_field_pattern, [75466] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2898), 1, + ACTIONS(2906), 1, anon_sym_COLON, - ACTIONS(2900), 1, + ACTIONS(2908), 1, anon_sym_EQ, [75476] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2902), 1, + ACTIONS(2910), 1, anon_sym_EQ, - ACTIONS(2904), 1, + ACTIONS(2912), 1, anon_sym_LT, [75486] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2906), 1, + ACTIONS(2914), 1, anon_sym_DASH_GT, - ACTIONS(2908), 1, + ACTIONS(2916), 1, anon_sym_EQ_GT, [75496] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2910), 1, + ACTIONS(2918), 1, anon_sym_DASH_GT, - ACTIONS(2912), 1, + ACTIONS(2920), 1, anon_sym_EQ_GT, [75506] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2914), 1, + ACTIONS(2922), 1, sym_identifier, STATE(1418), 1, sym_named_argument, [75516] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2916), 1, + ACTIONS(2924), 1, anon_sym_DASH_GT, - ACTIONS(2918), 1, + ACTIONS(2926), 1, anon_sym_EQ_GT, [75526] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2920), 1, + ACTIONS(2928), 1, anon_sym_DASH_GT, - ACTIONS(2922), 1, + ACTIONS(2930), 1, anon_sym_EQ_GT, [75536] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2924), 1, + ACTIONS(2932), 1, anon_sym_EQ, - ACTIONS(2926), 1, + ACTIONS(2934), 1, anon_sym_LT, [75546] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2928), 1, + ACTIONS(2936), 1, anon_sym_LBRACE, - ACTIONS(2930), 1, + ACTIONS(2938), 1, anon_sym_LT, [75556] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1404), 1, sym_symbol_path, [75566] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2932), 1, + ACTIONS(2940), 1, sym_identifier, - ACTIONS(2934), 1, + ACTIONS(2942), 1, anon_sym_LPAREN, [75576] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2936), 1, + ACTIONS(2944), 1, anon_sym_COLON, STATE(1113), 1, sym_signature_ascription, [75586] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2896), 1, + ACTIONS(2904), 1, sym_identifier, STATE(1784), 1, sym_field_pattern, [75596] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2664), 2, + ACTIONS(2672), 2, anon_sym_COMMA, anon_sym_RPAREN, [75604] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2938), 1, + ACTIONS(2946), 1, anon_sym_LBRACE, - ACTIONS(2940), 1, + ACTIONS(2948), 1, anon_sym_LT, [75614] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1460), 1, sym_symbol_path, [75624] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2896), 1, + ACTIONS(2904), 1, sym_identifier, STATE(1738), 1, sym_field_pattern, [75634] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2942), 1, + ACTIONS(2950), 1, anon_sym_LT, - ACTIONS(2944), 1, + ACTIONS(2952), 1, anon_sym_LPAREN, [75644] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1298), 1, sym_symbol_path, [75654] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2946), 2, + ACTIONS(2954), 2, anon_sym_COMMA, anon_sym_GT, [75662] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2674), 1, + ACTIONS(2682), 1, sym_identifier, STATE(1440), 1, sym_field_declaration, [75672] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2577), 2, + ACTIONS(2585), 2, anon_sym_RBRACE, anon_sym_COMMA, [75680] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2948), 1, + ACTIONS(2956), 1, anon_sym_EQ, - ACTIONS(2950), 1, + ACTIONS(2958), 1, anon_sym_LT, [75690] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2121), 2, + ACTIONS(2129), 2, anon_sym_LBRACE, anon_sym_EQ, [75698] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2379), 1, + ACTIONS(2387), 1, sym_identifier, STATE(1421), 1, sym_import_member, [75708] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2019), 1, + ACTIONS(2027), 1, anon_sym_LBRACE, - ACTIONS(2025), 1, + ACTIONS(2033), 1, anon_sym_LPAREN, [75718] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2952), 1, + ACTIONS(2960), 1, anon_sym_LT, - ACTIONS(2954), 1, + ACTIONS(2962), 1, anon_sym_LPAREN, [75728] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2956), 1, + ACTIONS(2964), 1, anon_sym_COLON, - ACTIONS(2958), 1, + ACTIONS(2966), 1, anon_sym_EQ, [75738] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2960), 2, + ACTIONS(2968), 2, anon_sym_RBRACE, sym_identifier, [75746] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1369), 1, sym_symbol_path, [75756] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2765), 2, + ACTIONS(2773), 2, anon_sym_RBRACE, anon_sym_COMMA, [75764] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2763), 2, + ACTIONS(2771), 2, anon_sym_COMMA, anon_sym_RBRACK, [75772] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2962), 2, + ACTIONS(2970), 2, anon_sym_COMMA, anon_sym_RBRACK, [75780] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2964), 1, + ACTIONS(2972), 1, sym_identifier, - ACTIONS(2966), 1, + ACTIONS(2974), 1, anon_sym_LPAREN, [75790] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2968), 1, + ACTIONS(2976), 1, sym_identifier, STATE(1339), 1, sym_qualified_path, [75800] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1341), 1, sym_symbol_path, [75810] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2970), 1, + ACTIONS(2978), 1, anon_sym_LT, - ACTIONS(2972), 1, + ACTIONS(2980), 1, anon_sym_LPAREN, [75820] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1349), 1, sym_symbol_path, [75830] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1351), 1, sym_symbol_path, [75840] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2974), 1, + ACTIONS(2982), 1, anon_sym_LT, - ACTIONS(2976), 1, + ACTIONS(2984), 1, anon_sym_LPAREN, [75850] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2832), 1, + ACTIONS(2840), 1, sym_identifier, STATE(1358), 1, sym_symbol_path, [75860] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2780), 2, + ACTIONS(2788), 2, anon_sym_COMMA, anon_sym_GT, [75868] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2569), 1, + ACTIONS(2577), 1, sym_identifier, STATE(1479), 1, sym_field_assignment, [75878] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2978), 1, + ACTIONS(2986), 1, sym_identifier, STATE(1626), 1, sym_qualified_path, [75888] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2980), 1, + ACTIONS(2988), 1, sym_identifier, STATE(1371), 1, sym_qualified_path, [75898] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2982), 1, + ACTIONS(2990), 1, anon_sym_LT, - ACTIONS(2984), 1, + ACTIONS(2992), 1, anon_sym_LPAREN, [75908] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2986), 1, + ACTIONS(2994), 1, anon_sym_LT, - ACTIONS(2988), 1, + ACTIONS(2996), 1, anon_sym_LPAREN, [75918] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2990), 1, + ACTIONS(2998), 1, sym_identifier, STATE(1392), 1, sym_qualified_path, [75928] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2700), 2, + ACTIONS(2708), 2, anon_sym_RBRACE, anon_sym_COMMA, [75936] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2992), 1, + ACTIONS(3000), 1, anon_sym_EQ, - ACTIONS(2994), 1, + ACTIONS(3002), 1, anon_sym_LT, [75946] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2996), 1, + ACTIONS(3004), 1, sym_identifier, STATE(1754), 1, sym_qualified_path, [75956] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2896), 1, + ACTIONS(2904), 1, sym_identifier, STATE(1761), 1, sym_field_pattern, [75966] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2998), 1, + ACTIONS(3006), 1, anon_sym_EQ, - ACTIONS(3000), 1, + ACTIONS(3008), 1, anon_sym_LT, [75976] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2896), 1, + ACTIONS(2904), 1, sym_identifier, STATE(1771), 1, sym_field_pattern, [75986] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2896), 1, + ACTIONS(2904), 1, sym_identifier, STATE(1778), 1, sym_field_pattern, [75996] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2896), 1, + ACTIONS(2904), 1, sym_identifier, STATE(1774), 1, sym_field_pattern, [76006] = 3, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2344), 1, + ACTIONS(2352), 1, sym_identifier, STATE(1431), 1, sym_extern_parameter, [76016] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3002), 1, + ACTIONS(3010), 1, anon_sym_RBRACK, [76023] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3004), 1, + ACTIONS(3012), 1, anon_sym_GT, [76030] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3006), 1, + ACTIONS(3014), 1, anon_sym_QMARK, [76037] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3008), 1, + ACTIONS(3016), 1, sym_identifier, [76044] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3010), 1, + ACTIONS(3018), 1, anon_sym_RPAREN, [76051] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3012), 1, + ACTIONS(3020), 1, sym_identifier, [76058] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1676), 1, + ACTIONS(1684), 1, anon_sym_RPAREN, [76065] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3014), 1, + ACTIONS(3022), 1, anon_sym_LPAREN, [76072] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3016), 1, + ACTIONS(3024), 1, anon_sym_RBRACE, [76079] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3018), 1, + ACTIONS(3026), 1, anon_sym_GT, [76086] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3020), 1, + ACTIONS(3028), 1, anon_sym_RPAREN, [76093] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3022), 1, + ACTIONS(3030), 1, sym_identifier, [76100] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3024), 1, + ACTIONS(3032), 1, anon_sym_COLON, [76107] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3026), 1, + ACTIONS(3034), 1, anon_sym_fn, [76114] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3028), 1, + ACTIONS(3036), 1, anon_sym_GT, [76121] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3030), 1, + ACTIONS(3038), 1, anon_sym_RBRACE, [76128] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3032), 1, + ACTIONS(3040), 1, anon_sym_LPAREN, [76135] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3034), 1, + ACTIONS(3042), 1, anon_sym_RPAREN, [76142] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3036), 1, + ACTIONS(3044), 1, anon_sym_RBRACE, [76149] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3038), 1, + ACTIONS(3046), 1, sym_identifier, [76156] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3040), 1, + ACTIONS(3048), 1, anon_sym_LPAREN, [76163] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3042), 1, + ACTIONS(3050), 1, anon_sym_RBRACE, [76170] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3044), 1, + ACTIONS(3052), 1, anon_sym_EQ_GT, [76177] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3046), 1, + ACTIONS(3054), 1, sym_identifier, [76184] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3048), 1, + ACTIONS(3056), 1, anon_sym_COLON, [76191] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3050), 1, + ACTIONS(3058), 1, anon_sym_GT, [76198] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2854), 1, + ACTIONS(2862), 1, anon_sym_EQ_GT, [76205] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2908), 1, + ACTIONS(2916), 1, anon_sym_EQ_GT, [76212] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3052), 1, + ACTIONS(3060), 1, anon_sym_LPAREN, [76219] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3054), 1, + ACTIONS(3062), 1, anon_sym_RPAREN, [76226] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3056), 1, + ACTIONS(3064), 1, anon_sym_RBRACE, [76233] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3058), 1, + ACTIONS(3066), 1, anon_sym_DASH_GT, [76240] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3060), 1, + ACTIONS(3068), 1, anon_sym_EQ_GT, [76247] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3062), 1, + ACTIONS(3070), 1, anon_sym_DASH_GT, [76254] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3064), 1, + ACTIONS(3072), 1, anon_sym_EQ_GT, [76261] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3066), 1, + ACTIONS(3074), 1, anon_sym_DASH_GT, [76268] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3068), 1, + ACTIONS(3076), 1, anon_sym_EQ_GT, [76275] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3070), 1, + ACTIONS(3078), 1, anon_sym_RBRACK, [76282] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3072), 1, + ACTIONS(3080), 1, sym_identifier, [76289] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3074), 1, + ACTIONS(3082), 1, sym_identifier, [76296] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3076), 1, + ACTIONS(3084), 1, sym_identifier, [76303] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3078), 1, + ACTIONS(3086), 1, anon_sym_EQ, [76310] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3080), 1, + ACTIONS(3088), 1, sym_identifier, [76317] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3082), 1, + ACTIONS(3090), 1, sym_identifier, [76324] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3084), 1, + ACTIONS(3092), 1, anon_sym_COLON, [76331] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3086), 1, + ACTIONS(3094), 1, anon_sym_LPAREN, [76338] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3088), 1, + ACTIONS(3096), 1, sym_identifier, [76345] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2934), 1, + ACTIONS(2942), 1, anon_sym_LPAREN, [76352] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2922), 1, + ACTIONS(2930), 1, anon_sym_EQ_GT, [76359] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3090), 1, + ACTIONS(3098), 1, anon_sym_PIPE, [76366] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3092), 1, + ACTIONS(3100), 1, anon_sym_RBRACE, [76373] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3094), 1, + ACTIONS(3102), 1, sym_identifier, [76380] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3096), 1, + ACTIONS(3104), 1, anon_sym_RBRACE, [76387] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3098), 1, + ACTIONS(3106), 1, anon_sym_RPAREN, [76394] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3100), 1, + ACTIONS(3108), 1, sym_identifier, [76401] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3102), 1, + ACTIONS(3110), 1, anon_sym_GT, [76408] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3104), 1, + ACTIONS(3112), 1, anon_sym_LBRACE, [76415] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3106), 1, + ACTIONS(3114), 1, sym_identifier, [76422] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3108), 1, + ACTIONS(3116), 1, anon_sym_LBRACE, [76429] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3110), 1, + ACTIONS(3118), 1, sym_identifier, [76436] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3112), 1, + ACTIONS(3120), 1, anon_sym_LBRACE, [76443] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3114), 1, + ACTIONS(3122), 1, anon_sym_DASH_GT, [76450] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3116), 1, + ACTIONS(3124), 1, anon_sym_RBRACE, [76457] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3118), 1, + ACTIONS(3126), 1, sym_identifier, [76464] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3120), 1, + ACTIONS(3128), 1, sym_identifier, [76471] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3122), 1, + ACTIONS(3130), 1, sym_identifier, [76478] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3124), 1, + ACTIONS(3132), 1, sym_identifier, [76485] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3126), 1, + ACTIONS(3134), 1, anon_sym_RPAREN, [76492] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3128), 1, + ACTIONS(3136), 1, anon_sym_RPAREN, [76499] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3130), 1, + ACTIONS(3138), 1, anon_sym_LPAREN, [76506] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3132), 1, + ACTIONS(3140), 1, anon_sym_RBRACE, [76513] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3134), 1, + ACTIONS(3142), 1, anon_sym_LBRACE, [76520] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3136), 1, + ACTIONS(3144), 1, anon_sym_COLON, [76527] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3138), 1, + ACTIONS(3146), 1, anon_sym_EQ_GT, [76534] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3140), 1, + ACTIONS(3148), 1, anon_sym_RBRACE, [76541] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3142), 1, + ACTIONS(3150), 1, anon_sym_RBRACK, [76548] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3144), 1, + ACTIONS(3152), 1, anon_sym_LBRACE, [76555] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3146), 1, + ACTIONS(3154), 1, anon_sym_RBRACE, [76562] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3148), 1, + ACTIONS(3156), 1, anon_sym_RPAREN, [76569] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3150), 1, + ACTIONS(3158), 1, anon_sym_extra, [76576] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3152), 1, + ACTIONS(3160), 1, anon_sym_GT, [76583] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3154), 1, + ACTIONS(3162), 1, sym_identifier, [76590] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3156), 1, + ACTIONS(3164), 1, anon_sym_LPAREN, [76597] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3158), 1, + ACTIONS(3166), 1, anon_sym_LBRACE, [76604] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3160), 1, + ACTIONS(3168), 1, sym_identifier, [76611] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1989), 1, + ACTIONS(1997), 1, anon_sym_RPAREN, [76618] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3162), 1, + ACTIONS(3170), 1, anon_sym_module, [76625] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3164), 1, + ACTIONS(3172), 1, anon_sym_RPAREN, [76632] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3166), 1, + ACTIONS(3174), 1, anon_sym_RBRACE, [76639] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3168), 1, + ACTIONS(3176), 1, sym_identifier, [76646] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3170), 1, + ACTIONS(3178), 1, anon_sym_LPAREN, [76653] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3172), 1, + ACTIONS(3180), 1, anon_sym_EQ, [76660] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3174), 1, + ACTIONS(3182), 1, anon_sym_LBRACE, [76667] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3176), 1, + ACTIONS(3184), 1, sym_identifier, [76674] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3178), 1, + ACTIONS(3186), 1, ts_builtin_sym_end, [76681] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3180), 1, + ACTIONS(3188), 1, anon_sym_EQ, [76688] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3182), 1, + ACTIONS(3190), 1, sym_identifier, [76695] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3184), 1, + ACTIONS(3192), 1, anon_sym_LBRACE, [76702] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3186), 1, + ACTIONS(3194), 1, anon_sym_else, [76709] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3188), 1, + ACTIONS(3196), 1, anon_sym_RPAREN, [76716] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3190), 1, + ACTIONS(3198), 1, anon_sym_GT, [76723] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3192), 1, + ACTIONS(3200), 1, anon_sym_RPAREN, [76730] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3194), 1, + ACTIONS(3202), 1, anon_sym_GT, [76737] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3196), 1, + ACTIONS(3204), 1, anon_sym_LBRACE, [76744] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3198), 1, + ACTIONS(3206), 1, anon_sym_type, [76751] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2117), 1, + ACTIONS(2125), 1, anon_sym_LBRACE, [76758] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3200), 1, + ACTIONS(3208), 1, anon_sym_GT, [76765] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3202), 1, + ACTIONS(3210), 1, sym_identifier, [76772] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3204), 1, + ACTIONS(3212), 1, sym_identifier, [76779] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3206), 1, + ACTIONS(3214), 1, sym_identifier, [76786] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3208), 1, + ACTIONS(3216), 1, anon_sym_LBRACE, [76793] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3210), 1, + ACTIONS(3218), 1, anon_sym_RPAREN, [76800] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3212), 1, + ACTIONS(3220), 1, anon_sym_extra, [76807] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3214), 1, + ACTIONS(3222), 1, anon_sym_LPAREN, [76814] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3216), 1, + ACTIONS(3224), 1, anon_sym_DASH_GT, [76821] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3218), 1, + ACTIONS(3226), 1, anon_sym_RBRACE, [76828] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3220), 1, + ACTIONS(3228), 1, anon_sym_EQ, [76835] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3222), 1, + ACTIONS(3230), 1, anon_sym_RPAREN, [76842] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3224), 1, + ACTIONS(3232), 1, anon_sym_GT, [76849] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3226), 1, + ACTIONS(3234), 1, anon_sym_DASH_GT, [76856] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2707), 1, + ACTIONS(2715), 1, anon_sym_DOT, [76863] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3228), 1, + ACTIONS(3236), 1, sym_identifier, [76870] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3230), 1, + ACTIONS(3238), 1, anon_sym_EQ_GT, [76877] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3232), 1, + ACTIONS(3240), 1, anon_sym_EQ, [76884] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3234), 1, + ACTIONS(3242), 1, anon_sym_LPAREN, [76891] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3236), 1, + ACTIONS(3244), 1, sym_identifier, [76898] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3238), 1, + ACTIONS(3246), 1, anon_sym_RBRACE, [76905] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3240), 1, + ACTIONS(3248), 1, anon_sym_PIPE, [76912] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3242), 1, + ACTIONS(3250), 1, anon_sym_RBRACE, [76919] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3244), 1, + ACTIONS(3252), 1, anon_sym_EQ_GT, [76926] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3246), 1, + ACTIONS(3254), 1, anon_sym_EQ_GT, [76933] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3248), 1, + ACTIONS(3256), 1, anon_sym_RBRACE, [76940] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3250), 1, + ACTIONS(3258), 1, anon_sym_GT, [76947] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3252), 1, + ACTIONS(3260), 1, anon_sym_EQ_GT, [76954] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3254), 1, + ACTIONS(3262), 1, sym_identifier, [76961] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3256), 1, + ACTIONS(3264), 1, anon_sym_RPAREN, [76968] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3258), 1, + ACTIONS(3266), 1, anon_sym_DASH_GT, [76975] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3260), 1, + ACTIONS(3268), 1, sym_identifier, [76982] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3262), 1, + ACTIONS(3270), 1, sym_identifier, [76989] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3264), 1, + ACTIONS(3272), 1, anon_sym_RPAREN, [76996] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3266), 1, + ACTIONS(3274), 1, anon_sym_RPAREN, [77003] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3268), 1, + ACTIONS(3276), 1, anon_sym_EQ_GT, [77010] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3270), 1, + ACTIONS(3278), 1, anon_sym_EQ_GT, [77017] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2045), 1, + ACTIONS(2053), 1, anon_sym_effect, [77024] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2043), 1, + ACTIONS(2051), 1, anon_sym_type, [77031] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3272), 1, + ACTIONS(3280), 1, anon_sym_RPAREN, [77038] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3274), 1, + ACTIONS(3282), 1, anon_sym_GT, [77045] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3276), 1, + ACTIONS(3284), 1, anon_sym_RPAREN, [77052] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3278), 1, + ACTIONS(3286), 1, anon_sym_LPAREN, [77059] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3280), 1, + ACTIONS(3288), 1, sym_identifier, [77066] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2011), 1, + ACTIONS(2019), 1, anon_sym_RPAREN, [77073] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3282), 1, + ACTIONS(3290), 1, anon_sym_PIPE, [77080] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3284), 1, + ACTIONS(3292), 1, anon_sym_LBRACE, [77087] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3286), 1, + ACTIONS(3294), 1, anon_sym_EQ, [77094] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3288), 1, + ACTIONS(3296), 1, anon_sym_RBRACE, [77101] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3290), 1, + ACTIONS(3298), 1, sym_identifier, [77108] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3292), 1, + ACTIONS(3300), 1, anon_sym_GT, [77115] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3294), 1, + ACTIONS(3302), 1, anon_sym_else, [77122] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3296), 1, + ACTIONS(3304), 1, anon_sym_RPAREN, [77129] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3298), 1, + ACTIONS(3306), 1, anon_sym_GT, [77136] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3300), 1, + ACTIONS(3308), 1, anon_sym_COLON, [77143] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3302), 1, + ACTIONS(3310), 1, anon_sym_GT, [77150] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3304), 1, + ACTIONS(3312), 1, anon_sym_RPAREN, [77157] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3306), 1, + ACTIONS(3314), 1, anon_sym_RPAREN, [77164] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3308), 1, + ACTIONS(3316), 1, anon_sym_LBRACE, [77171] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3310), 1, + ACTIONS(3318), 1, anon_sym_RPAREN, [77178] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3312), 1, + ACTIONS(3320), 1, anon_sym_fn, [77185] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3314), 1, + ACTIONS(3322), 1, sym_identifier, [77192] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3316), 1, + ACTIONS(3324), 1, anon_sym_else, [77199] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3318), 1, + ACTIONS(3326), 1, anon_sym_EQ_GT, [77206] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3320), 1, + ACTIONS(3328), 1, anon_sym_RPAREN, [77213] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3322), 1, + ACTIONS(3330), 1, anon_sym_DASH_GT, [77220] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3324), 1, + ACTIONS(3332), 1, sym_identifier, [77227] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3326), 1, + ACTIONS(3334), 1, sym_identifier, [77234] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3328), 1, + ACTIONS(3336), 1, anon_sym_EQ_GT, [77241] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3330), 1, + ACTIONS(3338), 1, anon_sym_RPAREN, [77248] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3332), 1, + ACTIONS(3340), 1, anon_sym_PIPE, [77255] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3334), 1, + ACTIONS(3342), 1, anon_sym_DASH_GT, [77262] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3336), 1, + ACTIONS(3344), 1, anon_sym_EQ, [77269] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3338), 1, + ACTIONS(3346), 1, anon_sym_RPAREN, [77276] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3340), 1, + ACTIONS(3348), 1, anon_sym_GT, [77283] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3342), 1, + ACTIONS(3350), 1, sym_identifier, [77290] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3344), 1, + ACTIONS(3352), 1, anon_sym_RBRACK, [77297] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2001), 1, + ACTIONS(2009), 1, anon_sym_RPAREN, [77304] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3346), 1, + ACTIONS(3354), 1, anon_sym_RPAREN, [77311] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3348), 1, + ACTIONS(3356), 1, anon_sym_RPAREN, [77318] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3350), 1, + ACTIONS(3358), 1, anon_sym_LPAREN, [77325] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3352), 1, + ACTIONS(3360), 1, anon_sym_EQ, [77332] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3354), 1, + ACTIONS(3362), 1, sym_identifier, [77339] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3356), 1, + ACTIONS(3364), 1, sym_identifier, [77346] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3358), 1, + ACTIONS(3366), 1, anon_sym_LPAREN, [77353] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3360), 1, + ACTIONS(3368), 1, anon_sym_LPAREN, [77360] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3362), 1, + ACTIONS(3370), 1, anon_sym_LBRACE, [77367] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3364), 1, + ACTIONS(3372), 1, anon_sym_LPAREN, [77374] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3366), 1, + ACTIONS(3374), 1, anon_sym_EQ_GT, [77381] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3368), 1, + ACTIONS(3376), 1, sym_identifier, [77388] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3370), 1, + ACTIONS(3378), 1, anon_sym_DASH_GT, [77395] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3372), 1, + ACTIONS(3380), 1, anon_sym_LBRACE, [77402] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2966), 1, + ACTIONS(2974), 1, anon_sym_LPAREN, [77409] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3374), 1, + ACTIONS(3382), 1, sym_identifier, [77416] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3376), 1, + ACTIONS(3384), 1, sym_identifier, [77423] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3378), 1, + ACTIONS(3386), 1, anon_sym_LBRACE, [77430] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3380), 1, + ACTIONS(3388), 1, sym_identifier, [77437] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3382), 1, + ACTIONS(3390), 1, anon_sym_LPAREN, [77444] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3384), 1, + ACTIONS(3392), 1, sym_identifier, [77451] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3386), 1, + ACTIONS(3394), 1, anon_sym_RBRACK, [77458] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3388), 1, + ACTIONS(3396), 1, anon_sym_RBRACK, [77465] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3390), 1, + ACTIONS(3398), 1, sym_identifier, [77472] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3392), 1, + ACTIONS(3400), 1, anon_sym_LPAREN, [77479] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3394), 1, + ACTIONS(3402), 1, sym_identifier, [77486] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3396), 1, + ACTIONS(3404), 1, sym_identifier, [77493] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3398), 1, + ACTIONS(3406), 1, anon_sym_RPAREN, [77500] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3400), 1, + ACTIONS(3408), 1, anon_sym_DASH_GT, [77507] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3402), 1, + ACTIONS(3410), 1, anon_sym_GT, [77514] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3404), 1, + ACTIONS(3412), 1, anon_sym_DASH_GT, [77521] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3406), 1, + ACTIONS(3414), 1, anon_sym_QMARK, [77528] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3408), 1, + ACTIONS(3416), 1, anon_sym_EQ, [77535] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3410), 1, + ACTIONS(3418), 1, anon_sym_LPAREN, [77542] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3412), 1, + ACTIONS(3420), 1, anon_sym_RPAREN, [77549] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3414), 1, + ACTIONS(3422), 1, anon_sym_EQ, [77556] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3416), 1, + ACTIONS(3424), 1, anon_sym_GT, [77563] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3418), 1, + ACTIONS(3426), 1, anon_sym_LPAREN, [77570] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3420), 1, + ACTIONS(3428), 1, anon_sym_RPAREN, [77577] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3422), 1, + ACTIONS(3430), 1, sym_identifier, [77584] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3424), 1, + ACTIONS(3432), 1, anon_sym_EQ, [77591] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3426), 1, + ACTIONS(3434), 1, anon_sym_GT, [77598] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3428), 1, + ACTIONS(3436), 1, anon_sym_LBRACE, [77605] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3430), 1, + ACTIONS(3438), 1, anon_sym_LPAREN, [77612] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3432), 1, + ACTIONS(3440), 1, anon_sym_EQ, [77619] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3434), 1, + ACTIONS(3442), 1, anon_sym_LPAREN, [77626] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3436), 1, + ACTIONS(3444), 1, anon_sym_LBRACE, [77633] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2804), 1, + ACTIONS(2812), 1, anon_sym_RBRACE, [77640] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3438), 1, + ACTIONS(3446), 1, anon_sym_RBRACE, [77647] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3440), 1, + ACTIONS(3448), 1, sym_identifier, [77654] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3442), 1, + ACTIONS(3450), 1, anon_sym_LPAREN, [77661] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3444), 1, + ACTIONS(3452), 1, anon_sym_module, [77668] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3446), 1, + ACTIONS(3454), 1, anon_sym_RBRACK, [77675] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3448), 1, + ACTIONS(3456), 1, anon_sym_QMARK, [77682] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(1991), 1, + ACTIONS(1999), 1, anon_sym_RPAREN, [77689] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3450), 1, + ACTIONS(3458), 1, anon_sym_LPAREN, [77696] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3452), 1, + ACTIONS(3460), 1, anon_sym_LPAREN, [77703] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3454), 1, + ACTIONS(3462), 1, sym_identifier, [77710] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3456), 1, + ACTIONS(3464), 1, anon_sym_LPAREN, [77717] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3458), 1, + ACTIONS(3466), 1, anon_sym_QMARK, [77724] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3460), 1, + ACTIONS(3468), 1, anon_sym_fn, [77731] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3462), 1, + ACTIONS(3470), 1, anon_sym_module, [77738] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3464), 1, + ACTIONS(3472), 1, anon_sym_LPAREN, [77745] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3466), 1, + ACTIONS(3474), 1, sym_identifier, [77752] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2802), 1, + ACTIONS(2810), 1, anon_sym_DOT, [77759] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3468), 1, + ACTIONS(3476), 1, sym_identifier, [77766] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3470), 1, + ACTIONS(3478), 1, anon_sym_fn, [77773] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3472), 1, + ACTIONS(3480), 1, anon_sym_module, [77780] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3474), 1, + ACTIONS(3482), 1, anon_sym_LPAREN, [77787] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3476), 1, + ACTIONS(3484), 1, anon_sym_LBRACE, [77794] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3478), 1, + ACTIONS(3486), 1, sym_identifier, [77801] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3480), 1, + ACTIONS(3488), 1, anon_sym_RBRACE, [77808] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3482), 1, + ACTIONS(3490), 1, anon_sym_GT, [77815] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3484), 1, + ACTIONS(3492), 1, anon_sym_LPAREN, [77822] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3486), 1, + ACTIONS(3494), 1, anon_sym_LPAREN, [77829] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3488), 1, + ACTIONS(3496), 1, anon_sym_GT, [77836] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3490), 1, + ACTIONS(3498), 1, anon_sym_LBRACE, [77843] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3492), 1, + ACTIONS(3500), 1, sym_identifier, [77850] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2810), 1, + ACTIONS(2818), 1, anon_sym_DOT, [77857] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3494), 1, + ACTIONS(3502), 1, sym_identifier, [77864] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3496), 1, + ACTIONS(3504), 1, sym_identifier, [77871] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3498), 1, + ACTIONS(3506), 1, anon_sym_RBRACE, [77878] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3500), 1, + ACTIONS(3508), 1, anon_sym_GT, [77885] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3502), 1, + ACTIONS(3510), 1, anon_sym_GT, [77892] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3504), 1, + ACTIONS(3512), 1, anon_sym_RBRACE, [77899] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3506), 1, + ACTIONS(3514), 1, anon_sym_LPAREN, [77906] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2882), 1, + ACTIONS(2890), 1, anon_sym_EQ_GT, [77913] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3508), 1, + ACTIONS(3516), 1, sym_identifier, [77920] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(2653), 1, + ACTIONS(2661), 1, anon_sym_RBRACE, [77927] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3510), 1, + ACTIONS(3518), 1, anon_sym_RBRACE, [77934] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3512), 1, + ACTIONS(3520), 1, anon_sym_RPAREN, [77941] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3514), 1, + ACTIONS(3522), 1, sym_identifier, [77948] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3516), 1, + ACTIONS(3524), 1, anon_sym_GT, [77955] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3518), 1, + ACTIONS(3526), 1, anon_sym_LPAREN, [77962] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3520), 1, + ACTIONS(3528), 1, anon_sym_RBRACE, [77969] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3522), 1, + ACTIONS(3530), 1, anon_sym_LBRACE, [77976] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3524), 1, + ACTIONS(3532), 1, anon_sym_COLON, [77983] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3526), 1, + ACTIONS(3534), 1, anon_sym_RPAREN, [77990] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3528), 1, + ACTIONS(3536), 1, anon_sym_LBRACE, [77997] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3530), 1, + ACTIONS(3538), 1, anon_sym_EQ_GT, [78004] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3532), 1, + ACTIONS(3540), 1, anon_sym_fn, [78011] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3534), 1, + ACTIONS(3542), 1, anon_sym_RPAREN, [78018] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3536), 1, + ACTIONS(3544), 1, anon_sym_fn, [78025] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3538), 1, + ACTIONS(3546), 1, anon_sym_LBRACE, [78032] = 2, ACTIONS(430), 1, sym_line_comment, - ACTIONS(3540), 1, + ACTIONS(3548), 1, anon_sym_RPAREN, }; @@ -73480,14 +73505,14 @@ static const TSParseActionEntry ts_parse_actions[] = { [483] = {.entry = {.count = 1, .reusable = false}}, SHIFT(335), [485] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1402), [488] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1557), - [491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 2, 23), - [493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 2, 23), - [495] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 28), - [498] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 28), + [491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 2, 24), + [493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 2, 24), + [495] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 30), + [498] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), REDUCE(sym_update_expression, 4, 0, 30), [501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 13), [503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 13), - [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 30), - [507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 30), + [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 32), + [507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 32), [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_constructor, 4, 1, 4), [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 4, 1, 4), [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), @@ -73499,14 +73524,14 @@ static const TSParseActionEntry ts_parse_actions[] = { [527] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_constructor, 5, 1, 4), [529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_send_call, 6, 0, 0), [531] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_send_call, 6, 0, 0), - [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 56), - [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 56), - [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 75), - [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 75), - [541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 56), - [543] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 56), - [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 109), - [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 109), + [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 6, 0, 59), + [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 6, 0, 59), + [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 7, 0, 79), + [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 7, 0, 79), + [541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_perform_expression, 7, 0, 59), + [543] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_perform_expression, 7, 0, 59), + [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 9, 0, 113), + [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 9, 0, 113), [549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3, 0, 0), [551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3, 0, 0), [553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_literal, 3, 0, 0), @@ -73548,8 +73573,8 @@ static const TSParseActionEntry ts_parse_actions[] = { [626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_literal, 4, 0, 0), [628] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_literal, 4, 0, 0), [630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(735), - [632] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 23), - [634] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 23), + [632] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 2, 24), + [634] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 2, 24), [636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), [638] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_expression, 4, 0, 0), [640] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_expression, 4, 0, 0), @@ -73558,8 +73583,8 @@ static const TSParseActionEntry ts_parse_actions[] = { [648] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recv_call, 4, 0, 0), [650] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recv_call, 4, 0, 0), [652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), - [654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 4, 0, 26), - [656] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 4, 0, 26), + [654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_resume_expression, 4, 0, 27), + [656] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_resume_expression, 4, 0, 27), [658] = {.entry = {.count = 1, .reusable = false}}, SHIFT(836), [660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), [662] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression_statement, 1, 0, 0), @@ -73590,28 +73615,28 @@ static const TSParseActionEntry ts_parse_actions[] = { [713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 12), [715] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 4, 0, 21), [717] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 4, 0, 21), - [719] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 29), - [721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 29), - [723] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 33), - [725] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 33), - [727] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 37), - [729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 37), - [731] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 43), - [733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 43), - [735] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 48), - [737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 48), - [739] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 67), - [741] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 67), - [743] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 84), - [745] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 84), - [747] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 95), - [749] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 95), + [719] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 4, 0, 31), + [721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 4, 0, 31), + [723] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 5, 0, 35), + [725] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 5, 0, 35), + [727] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_expression, 5, 0, 40), + [729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_expression, 5, 0, 40), + [731] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 5, 0, 46), + [733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 5, 0, 46), + [735] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 6, 0, 51), + [737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 6, 0, 51), + [739] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 7, 0, 71), + [741] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 7, 0, 71), + [743] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_lambda_expression, 8, 0, 88), + [745] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_lambda_expression, 8, 0, 88), + [747] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 8, 0, 99), + [749] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 8, 0, 99), [751] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1264), [753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), [755] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(174), [758] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(730), - [761] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 143), - [763] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 143), + [761] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 147), + [763] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 147), [765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1461), [767] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), [769] = {.entry = {.count = 1, .reusable = false}}, SHIFT(341), @@ -73622,77 +73647,77 @@ static const TSParseActionEntry ts_parse_actions[] = { [779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), [781] = {.entry = {.count = 1, .reusable = false}}, SHIFT(340), [783] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [785] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 44), - [787] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 5, 0, 44), - [789] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 6, 0, 47), - [791] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 47), - [793] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 49), - [795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 49), - [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 103), - [799] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 103), - [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 97), - [803] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 97), - [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 106), - [807] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 106), - [809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 107), - [811] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 107), - [813] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 69), - [815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 69), - [817] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 70), - [819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 70), - [821] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 7, 0, 78), - [823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 78), - [825] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 79), - [827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 79), - [829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 115), - [831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 115), - [833] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 86), - [835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 86), - [837] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 89), - [839] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 89), - [841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 118), - [843] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 118), - [845] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 98), - [847] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 98), - [849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 121), - [851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 121), - [853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 122), - [855] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 122), - [857] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 124), - [859] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 124), - [861] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 127), - [863] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 127), + [785] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 5, 0, 47), + [787] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 5, 0, 47), + [789] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 6, 0, 50), + [791] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 6, 0, 50), + [793] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 52), + [795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 52), + [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 107), + [799] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 107), + [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 101), + [803] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 101), + [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 110), + [807] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 110), + [809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 111), + [811] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 111), + [813] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 73), + [815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 73), + [817] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 74), + [819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 74), + [821] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_declaration, 7, 0, 82), + [823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_declaration, 7, 0, 82), + [825] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 83), + [827] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 83), + [829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 119), + [831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 119), + [833] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 90), + [835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 90), + [837] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 93), + [839] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 93), + [841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 122), + [843] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 122), + [845] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 102), + [847] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 102), + [849] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 125), + [851] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 125), + [853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 126), + [855] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 126), + [857] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 128), + [859] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 128), + [861] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 131), + [863] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 131), [865] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(712), - [868] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 130), - [870] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 130), - [872] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 131), - [874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 131), - [876] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 133), - [878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 133), - [880] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 136), - [882] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 136), - [884] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 142), - [886] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 142), - [888] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 145), - [890] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 145), - [892] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 146), - [894] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 146), - [896] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 147), - [898] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 147), - [900] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 151), - [902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 151), - [904] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 154), - [906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 154), - [908] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 155), - [910] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 155), - [912] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 158), - [914] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 158), - [916] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 159), - [918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 159), + [868] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 134), + [870] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 134), + [872] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 135), + [874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 135), + [876] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 137), + [878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 137), + [880] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 140), + [882] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 140), + [884] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 146), + [886] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 146), + [888] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 149), + [890] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 149), + [892] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 150), + [894] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 150), + [896] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 151), + [898] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 151), + [900] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 155), + [902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 155), + [904] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 158), + [906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 158), + [908] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 159), + [910] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 159), + [912] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 162), + [914] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 162), + [916] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 163), + [918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 163), [920] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, 0, 10), [922] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3, 0, 10), - [924] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 162), - [926] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 14, 0, 162), + [924] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 14, 0, 166), + [926] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 14, 0, 166), [928] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(76), [931] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(192), [934] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), SHIFT(714), @@ -73737,1234 +73762,1236 @@ static const TSParseActionEntry ts_parse_actions[] = { [1020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1015), [1022] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 1, 0, 0), [1024] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_union_type, 1, 0, 0), - [1026] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 101), - [1028] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 8, 0, 101), + [1026] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 105), + [1028] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 8, 0, 105), [1030] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 4, 0, 0), [1032] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 4, 0, 0), [1034] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_type_identifier, 1, 0, 0), SHIFT(1079), - [1037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 73), - [1039] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 7, 0, 73), - [1041] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 45), - [1043] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 5, 0, 45), + [1037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 7, 0, 77), + [1039] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 7, 0, 77), + [1041] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 48), + [1043] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 5, 0, 48), [1045] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), [1047] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_target, 1, 0, 3), - [1049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1615), - [1051] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 102), - [1053] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 9, 0, 102), - [1055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), - [1057] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), - [1059] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), SHIFT_REPEAT(1615), - [1062] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), SHIFT_REPEAT(1715), - [1065] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 8), - [1067] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 5, 0, 8), - [1069] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), - [1071] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_target, 2, 0, 7), - [1073] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 31), - [1075] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 5, 0, 31), - [1077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), - [1079] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), - [1081] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_alias, 1, -1, 0), - [1083] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), - [1085] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 3, 0, 0), - [1087] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 102), - [1089] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 8, 0, 102), - [1091] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), - [1093] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 2), - [1095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1444), - [1097] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1511), - [1099] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), - [1101] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variant, 4, 0, 4), - [1103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), - [1105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1706), - [1107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 74), - [1109] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 7, 0, 74), - [1111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 8), - [1113] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 4, 0, 8), - [1115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 74), - [1117] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 8, 0, 74), - [1119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 31), - [1121] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 6, 0, 31), - [1123] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 152), - [1125] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 152), - [1127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 42), - [1129] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 42), - [1131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 20), - [1133] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 5, 0, 20), - [1135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 101), - [1137] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 9, 0, 101), - [1139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 62), - [1141] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 62), - [1143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 45), - [1145] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 6, 0, 45), - [1147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1595), - [1149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 64), - [1151] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 64), - [1153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 46), - [1155] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 46), - [1157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 65), - [1159] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 65), - [1161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 31), - [1163] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 6, 0, 31), - [1165] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 132), - [1167] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 132), - [1169] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 68), - [1171] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 68), - [1173] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_legacy_import_path, 2, 0, 0), - [1175] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), - [1177] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 46), - [1179] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 46), - [1181] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 50), - [1183] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 50), - [1185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 71), - [1187] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 71), - [1189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 72), - [1191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 7, 0, 72), - [1193] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 120), - [1195] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 120), - [1197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 108), - [1199] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 108), - [1201] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 134), - [1203] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 134), - [1205] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1361), - [1208] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 135), - [1210] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 135), - [1212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), - [1214] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 4, 0, 8), - [1216] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), - [1218] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), - [1220] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 51), - [1222] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 51), - [1224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 141), - [1226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 141), - [1228] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 123), - [1230] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 123), - [1232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 31), - [1234] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 5, 0, 31), - [1236] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 144), - [1238] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 144), - [1240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 100), - [1242] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 8, 0, 100), - [1244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), - [1246] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 114), - [1248] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 114), - [1250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 57), - [1252] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 57), - [1254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 99), - [1256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 99), - [1258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 148), - [1260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 148), - [1262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), - [1264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_validation, 2, 0, 0), - [1266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 96), - [1268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 96), - [1270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 153), - [1272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 153), - [1274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 27), - [1276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 4, 0, 27), - [1278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), - [1280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), - [1282] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1560), - [1285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 116), - [1287] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 116), - [1289] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), - [1291] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), - [1293] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 80), - [1295] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 80), - [1297] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1661), - [1300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 27), - [1302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 27), - [1304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 81), - [1306] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 81), - [1308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 128), - [1310] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 128), - [1312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 104), - [1314] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 104), - [1316] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 117), - [1318] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 117), - [1320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 160), - [1322] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 160), - [1324] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 83), - [1326] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 8, 0, 83), - [1328] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 129), - [1330] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 129), - [1332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 64), - [1334] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 64), - [1336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 83), - [1338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 83), - [1340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 65), - [1342] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 65), - [1344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 35), - [1346] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 5, 0, 35), - [1348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 42), - [1350] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 42), - [1352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 85), - [1354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 85), - [1356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 105), - [1358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 105), - [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 8), - [1362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 5, 0, 8), - [1364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 87), - [1366] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 87), - [1368] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 119), - [1370] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 9, 0, 119), - [1372] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 88), - [1374] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 88), - [1376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 90), - [1378] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 8, 0, 90), - [1380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 40), - [1382] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 40), - [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 73), - [1386] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 8, 0, 73), - [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 57), - [1390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 57), - [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 40), - [1394] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 40), - [1396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 63), - [1398] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 6, 0, 63), - [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1078), - [1402] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 7, 0, 82), - [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 82), - [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1038), - [1408] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 5, 0, 31), - [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 31), - [1412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), - [1414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), - [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), - [1418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1056), - [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 52), - [1422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 6, 0, 52), - [1424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), - [1426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), - [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), - [1430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 3, 0, 8), - [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 0), - [1434] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 0), - [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), - [1438] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 2, 0, 0), - [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 15), - [1442] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 2, 0, 15), - [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), - [1446] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_body, 2, 0, 0), - [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), - [1450] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 1), - [1452] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 3, 0, 6), - [1454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), - [1456] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 3, 0, 9), - [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), - [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 31), - [1462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 4, 0, 31), - [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 32), - [1466] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 4, 0, 32), - [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), - [1470] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 3, 0, 0), - [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), - [1474] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_body, 3, 0, 0), - [1476] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 4, 0, 0), - [1478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), - [1480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1747), - [1482] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1747), - [1485] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1373), - [1488] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1374), - [1491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1753), - [1493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), - [1495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [1497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), - [1499] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), - [1501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), - [1503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(356), - [1505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1502), - [1507] = {.entry = {.count = 1, .reusable = false}}, SHIFT(263), - [1509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [1511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), - [1513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), - [1515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), - [1517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1504), - [1519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), - [1521] = {.entry = {.count = 1, .reusable = false}}, SHIFT(315), - [1523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [1525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), - [1527] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), - [1529] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), - [1531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), - [1533] = {.entry = {.count = 1, .reusable = false}}, SHIFT(314), - [1535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), - [1537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 39), - [1539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 39), - [1541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 39), - [1543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 39), - [1545] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), - [1547] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1627), - [1549] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1590), - [1551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1790), - [1553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1729), - [1555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1770), - [1557] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1741), - [1559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1478), - [1561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), - [1563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1525), - [1565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), - [1567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(584), - [1569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(516), - [1571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(529), - [1573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(595), - [1575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(553), - [1577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), - [1579] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1627), - [1582] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1590), - [1585] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1790), - [1588] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1729), - [1591] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1770), - [1594] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1741), - [1597] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1478), - [1600] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(874), - [1603] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1525), - [1606] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(968), - [1609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(567), - [1611] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), - [1614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1549), - [1616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(522), - [1618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), - [1620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(580), - [1622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), - [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(582), - [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(574), - [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(592), - [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), - [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(560), - [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), - [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(646), - [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(647), - [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(650), - [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(657), - [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), - [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), - [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), - [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), - [1652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), - [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), - [1656] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), - [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), - [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), - [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), - [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(581), - [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), - [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), - [1670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), - [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), - [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [1676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), - [1678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 22), - [1680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 18), - [1682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), - [1684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 10), - [1686] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 36), - [1688] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 53), - [1690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 10), - [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1154), - [1694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), - [1696] = {.entry = {.count = 1, .reusable = false}}, SHIFT(999), - [1698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1465), - [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [1702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(939), - [1704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1430), - [1706] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1209), - [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1209), - [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1674), - [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), - [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), - [1728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), - [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), - [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), - [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), - [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), - [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), - [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), - [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(747), - [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(749), - [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(750), - [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(751), - [1758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), - [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), - [1762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(763), - [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), - [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), - [1768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), - [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), - [1772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350), - [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), - [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(357), - [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1663), - [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), - [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [1784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1014), - [1786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [1788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), - [1790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [1792] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1014), - [1795] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), - [1798] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), - [1800] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(939), - [1803] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1430), - [1806] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), - [1809] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(720), - [1812] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), - [1815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(758), - [1817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [1819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), - [1821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), - [1823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), - [1825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), - [1827] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1014), - [1830] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), - [1833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), - [1835] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(939), - [1838] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1430), - [1841] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), - [1844] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(720), - [1847] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), - [1850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), - [1852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(748), - [1854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [1856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(525), - [1858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1552), - [1860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1563), - [1862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1569), - [1864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1464), - [1866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1610), - [1868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(636), - [1870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), - [1872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(651), - [1874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(587), - [1876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1273), - [1878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), - [1880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(548), - [1882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1687), - [1884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(543), - [1886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1545), - [1888] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), - [1890] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1552), - [1893] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1563), - [1896] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1569), - [1899] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1770), - [1902] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1464), - [1905] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1610), - [1908] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(968), - [1911] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1529), - [1914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), - [1916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1006), - [1918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1029), - [1920] = {.entry = {.count = 1, .reusable = false}}, SHIFT(921), - [1922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1414), - [1924] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1748), - [1926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), - [1928] = {.entry = {.count = 1, .reusable = false}}, SHIFT(485), - [1930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), - [1932] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1740), - [1934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(991), - [1936] = {.entry = {.count = 1, .reusable = false}}, SHIFT(483), - [1938] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1714), - [1940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), - [1942] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doc_comment, 1, 0, 0), - [1944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), - [1946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1049), - [1948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), - [1950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), - [1952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1052), - [1954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), - [1956] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), SHIFT_REPEAT(973), - [1959] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 58), - [1961] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 41), - [1963] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), - [1965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1009), - [1967] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 76), - [1969] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 59), - [1971] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), - [1973] = {.entry = {.count = 1, .reusable = false}}, SHIFT(952), - [1975] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1526), - [1977] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), - [1979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1702), - [1981] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 138), - [1983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), - [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1222), - [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1567), - [1989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1620), - [1991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1642), - [1993] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), - [1995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1625), - [1997] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 8), - [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1091), - [2001] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), - [2003] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), - [2005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 93), - [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1020), - [2009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1537), - [2011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), - [2013] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 74), - [2015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), - [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1202), - [2019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1503), - [2021] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), - [2023] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1001), - [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(950), - [2027] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), - [2029] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 149), - [2031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1448), - [2033] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 157), - [2035] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 111), - [2037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), - [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1769), - [2041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1792), - [2043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1644), - [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1572), - [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1592), - [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1467), - [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), - [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1631), - [2055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 126), - [2057] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 61), - [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1085), - [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1176), - [2063] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 8), - [2065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1053), - [2067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1155), - [2069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), - [2071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1655), - [2073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1509), - [2075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1519), - [2077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1565), - [2079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), - [2081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), - [2083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1755), - [2085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1756), - [2087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1571), - [2089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1708), - [2091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1757), - [2093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1487), - [2095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1710), - [2097] = {.entry = {.count = 1, .reusable = false}}, SHIFT(925), - [2099] = {.entry = {.count = 1, .reusable = false}}, SHIFT(489), - [2101] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 113), - [2103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), - [2105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(473), - [2107] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 27), - [2109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1618), - [2111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 74), - [2113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), - [2115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), - [2117] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 60), - [2119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), - [2121] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), - [2123] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 125), - [2125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 94), - [2127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), - [2129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 77), - [2131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 137), - [2133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 20), - [2135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), - [2137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 156), - [2139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 139), - [2141] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 42), - [2143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 140), - [2145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 112), - [2147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 161), - [2149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 150), - [2151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), - [2153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 92), - [2155] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 73), - [2157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), - [2159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), - [2161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), - [2163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1238), - [2165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [2167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), - [2169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1088), - [2171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), - [2173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1084), - [2175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), - [2177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1089), - [2179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), - [2181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), - [2183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), - [2185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), - [2187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), - [2189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), - [2191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1063), - [2193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [2195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1025), - [2197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [2199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1066), - [2201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), - [2203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1070), - [2205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [2207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), - [2209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [2211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1017), - [2213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), - [2215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1071), - [2217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [2219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), - [2221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), - [2223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1094), - [2225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), - [2227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1086), - [2229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), - [2231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1087), - [2233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), - [2235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1072), - [2237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [2239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1039), - [2241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), - [2243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1068), - [2245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), - [2247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1083), - [2249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), - [2251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1082), - [2253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [2255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), - [2257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), - [2259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1064), - [2261] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1468), - [2263] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1760), - [2265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [2267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), - [2269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1274), - [2271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), - [2273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), - [2275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(311), - [2277] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), - [2279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [2281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), - [2283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), - [2285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), - [2287] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), - [2289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), - [2291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), - [2293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), - [2295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), - [2297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), - [2299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [2301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [2303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), - [2305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), - [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(557), - [2309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), - [2311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), - [2313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), - [2315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), - [2317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), - [2319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [2321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), - [2323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [2325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), - [2327] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1435), - [2330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), - [2332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 22), - [2334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 91), - [2336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), - [2338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1258), - [2340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1635), - [2342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 110), - [2344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1530), - [2346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(998), - [2348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), - [2350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1518), - [2352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), - [2354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1455), - [2356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), - [2358] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1030), - [2361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_list_repeat1, 2, 0, 0), - [2363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1435), - [2365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), - [2367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), - [2369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), - [2371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), - [2373] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1274), - [2375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), - [2377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(598), - [2379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), - [2381] = {.entry = {.count = 1, .reusable = true}}, SHIFT(639), - [2383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(601), - [2385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(644), - [2387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), - [2389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(649), - [2391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), - [2393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1252), - [2395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(609), - [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), - [2399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1136), - [2401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), - [2403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), - [2405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1133), - [2407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), - [2409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(610), - [2411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), - [2413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), - [2415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(697), - [2417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1106), - [2419] = {.entry = {.count = 1, .reusable = false}}, SHIFT(272), - [2421] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), - [2423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1235), - [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(496), - [2427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(513), - [2429] = {.entry = {.count = 1, .reusable = false}}, SHIFT(323), - [2431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), - [2433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1789), - [2435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), - [2437] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), - [2439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), - [2441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), - [2443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1127), - [2445] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), - [2447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1129), - [2449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1125), - [2451] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(160), - [2454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1134), - [2456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), - [2458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), - [2460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1143), - [2462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), - [2464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1037), - [2466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1518), - [2469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), - [2471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1123), - [2473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), - [2475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1138), - [2477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1124), - [2479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1528), - [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1451), - [2483] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1274), - [2486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), - [2488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 54), - [2490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(970), - [2492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), - [2494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(971), - [2496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 0), - [2498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 38), - [2500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), - [2502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1388), - [2504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [2506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1128), - [2508] = {.entry = {.count = 1, .reusable = false}}, SHIFT(94), - [2510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 24), - [2512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), - [2514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1469), - [2516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), - [2518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), - [2520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), - [2522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), - [2524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), - [2526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), - [2528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), - [2530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), - [2532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), - [2534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), - [2536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), - [2538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), - [2540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(732), - [2542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), - [2544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1473), - [2546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), - [2548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), - [2550] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1505), - [2553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), - [2555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(743), - [2557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 22), - [2559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [2561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(746), - [2563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [2565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), - [2567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1424), - [2569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1550), - [2571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [2573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), - [2575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), - [2577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), - [2579] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(59), - [2582] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), - [2584] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1469), - [2587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), - [2589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), - [2591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [2593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [2595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), - [2597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), - [2599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), - [2601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), - [2603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [2607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293), - [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), - [2611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), - [2613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 22), - [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298), - [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), - [2619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [2621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301), - [2623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), - [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304), - [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), - [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), - [2631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), - [2633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), - [2635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), - [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [2641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), - [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1505), - [2645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), - [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), - [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(637), - [2651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(948), - [2653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), - [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), - [2661] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(948), - [2664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), - [2666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1453), - [2668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), - [2670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), - [2672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(849), - [2674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1578), - [2676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), - [2678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1491), - [2680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), - [2682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), - [2684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), - [2686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), - [2688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), - [2690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [2692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(502), - [2694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), - [2696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [2698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(471), - [2700] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), - [2702] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1549), - [2705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1602), - [2709] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), - [2711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), - [2713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), - [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), - [2719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), - [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [2725] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), - [2727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [2729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), - [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), - [2733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), - [2735] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1473), - [2738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [2740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [2742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352), - [2744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), - [2746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [2748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [2750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1396), - [2752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), - [2754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), - [2756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), - [2758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(625), - [2760] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1343), - [2763] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), - [2765] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), - [2767] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1491), - [2770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), - [2772] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1396), - [2775] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), - [2777] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1278), - [2780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), - [2782] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 55), SHIFT_REPEAT(951), - [2785] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 55), - [2787] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1453), - [2790] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), - [2792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [2794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), - [2796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(832), - [2798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(944), - [2800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), - [2802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1713), - [2804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1245), - [2806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), - [2808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), - [2810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1739), - [2812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(942), - [2814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1272), - [2816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [2818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), - [2820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1411), - [2822] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 66), - [2824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1233), - [2826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1158), - [2828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1054), - [2830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), - [2832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1163), - [2834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), - [2836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1168), - [2838] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 22), - [2840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1075), - [2842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), - [2844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1058), - [2846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [2848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), - [2850] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1277), - [2852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), - [2854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), - [2856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), - [2858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), - [2860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1080), - [2862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), - [2864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(955), - [2866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1187), - [2868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1081), - [2870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), - [2872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1169), - [2874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1217), - [2876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), - [2878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 34), - [2880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), - [2882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [2884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1246), - [2886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), - [2888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1585), - [2890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), - [2892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), - [2894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1206), - [2896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), - [2898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1099), - [2900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), - [2902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(965), - [2904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1182), - [2906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1092), - [2908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), - [2910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1093), - [2912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), - [2914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1666), - [2916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1062), - [2918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), - [2920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), - [2922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), - [2924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(963), - [2926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1146), - [2928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1214), - [2930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1189), - [2932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), - [2934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), - [2936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1446), - [2938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1221), - [2940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), - [2942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1188), - [2944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1227), - [2946] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), - [2948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(959), - [2950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1184), - [2952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1167), - [2954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1225), - [2956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), - [2958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), - [2960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 22), - [2962] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 38), - [2964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1485), - [2966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1244), - [2968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1161), - [2970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), - [2972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1248), - [2974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), - [2976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1250), - [2978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1367), - [2980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1150), - [2982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1195), - [2984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1257), - [2986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1196), - [2988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1260), - [2990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1171), - [2992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(960), - [2994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1177), - [2996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), - [2998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(962), - [3000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1149), - [3002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), - [3004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1534), - [3006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [3008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), - [3010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1144), - [3012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), - [3014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), - [3016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), - [3018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), - [3020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), - [3022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [3024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), - [3026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1673), - [3028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1730), - [3030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), - [3032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), - [3034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), - [3036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [3038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1785), - [3040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), - [3042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [3044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), - [3046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(954), - [3048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1074), - [3050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), - [3052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1275), - [3054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(612), - [3056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [3058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), - [3060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), - [3062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1022), - [3064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), - [3066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1044), - [3068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), - [3070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), - [3072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(470), - [3074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), - [3076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(498), - [3078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [3080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), - [3082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1497), - [3084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [3086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [3088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1786), - [3090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1776), - [3092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(731), - [3094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [3096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), - [3098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(753), - [3100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(597), - [3102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1759), - [3104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), - [3106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1447), - [3108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), - [3110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1501), - [3112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), - [3114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), - [3116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), - [3118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1012), - [3120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1449), - [3122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1450), - [3124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), - [3126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1454), - [3128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), - [3130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1218), - [3132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(652), - [3134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), - [3136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1057), - [3138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), - [3140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), - [3142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1472), - [3144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), - [3146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), - [3148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1145), - [3150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1611), - [3152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), - [3154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), - [3156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [3158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(851), - [3160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1494), - [3162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1425), - [3164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), - [3166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(615), - [3168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), - [3170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), - [3172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), - [3174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), - [3176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), - [3178] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [3180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(956), - [3182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1619), - [3184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1228), - [3186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1386), - [3188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), - [3190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), - [3192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1141), - [3194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), - [3196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(858), - [3198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1587), - [3200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1709), - [3202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), - [3204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(556), - [3206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(563), - [3208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1232), - [3210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1131), - [3212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1101), - [3214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [3216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1027), - [3218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), - [3220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(964), - [3222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1139), - [3224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), - [3226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1076), - [3228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), - [3230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [3232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [3234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [3236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1562), - [3238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(760), - [3240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), - [3242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(507), - [3244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [3246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), - [3248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [3250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1764), - [3252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [3254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1419), - [3256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(995), - [3258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1065), - [3260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), - [3262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1437), - [3264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1720), - [3266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1438), - [3268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), - [3270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), - [3272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1142), - [3274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), - [3276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1132), - [3278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [3280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1476), - [3282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1554), - [3284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1261), - [3286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(966), - [3288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(607), - [3290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(605), - [3292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), - [3294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), - [3296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), - [3298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), - [3300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [3302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1734), - [3304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(602), - [3306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), - [3308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(829), - [3310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1122), - [3312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1678), - [3314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1696), - [3316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1387), - [3318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), - [3320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), - [3322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1041), - [3324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1692), - [3326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1498), - [3328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), - [3330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(599), - [3332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), - [3334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1021), - [3336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(961), - [3338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1452), - [3340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(611), - [3342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), - [3344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(596), - [3346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1140), - [3348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1541), - [3350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1231), - [3352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), - [3354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1456), - [3356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1457), - [3358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1216), - [3360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [3362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), - [3364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), - [3366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), - [3368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1564), - [3370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1095), - [3372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1408), - [3374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1575), - [3376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), - [3378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1350), - [3380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1463), - [3382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1229), - [3384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), - [3386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(978), - [3388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), - [3390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), - [3392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), - [3394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(566), - [3396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1596), - [3398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(767), - [3400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), - [3402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1603), - [3404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), - [3406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351), - [3408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [3410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1251), - [3412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(969), - [3414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), - [3416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), - [3418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1254), - [3420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), - [3422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1471), - [3424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(957), - [3426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1024), - [3428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), - [3430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), - [3432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(958), - [3434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1265), - [3436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), - [3438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), - [3440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1654), - [3442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(997), - [3444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1458), - [3446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1204), - [3448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), - [3450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1262), - [3452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), - [3454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(719), - [3456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), - [3458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), - [3460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1705), - [3462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1486), - [3464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1256), - [3466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(736), - [3468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), - [3470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), - [3472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1489), - [3474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1268), - [3476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1207), - [3478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1442), - [3480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), - [3482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), - [3484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), - [3486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1205), - [3488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1727), - [3490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), - [3492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [3494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1495), - [3496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1426), - [3498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1743), - [3500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1745), - [3502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1746), - [3504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1749), - [3506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), - [3508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1758), - [3510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(707), - [3512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1135), - [3514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1763), - [3516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1622), - [3518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), - [3520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1508), - [3522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(943), - [3524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1043), - [3526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [3528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(931), - [3530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [3532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1777), - [3534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [3536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1781), - [3538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), - [3540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), + [1049] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), SHIFT(1615), + [1052] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 9, 0, 106), + [1054] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 9, 0, 106), + [1056] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), + [1058] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), + [1060] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), SHIFT_REPEAT(1615), + [1063] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 17), SHIFT_REPEAT(1715), + [1066] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 23), + [1068] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 5, 0, 23), + [1070] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), + [1072] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_target, 2, 0, 7), + [1074] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), SHIFT(1615), + [1077] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 5, 0, 38), + [1079] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 5, 0, 38), + [1081] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 2, 0, 7), SHIFT(1715), + [1084] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_alias, 1, -1, 0), + [1086] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_alias, 1, -1, 0), + [1088] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_type, 3, 0, 0), + [1090] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_type, 3, 0, 0), + [1092] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 106), + [1094] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 8, 0, 106), + [1096] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 2), + [1098] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 2), + [1100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1444), + [1102] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1511), + [1104] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 4, 0, 4), + [1106] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variant, 4, 0, 4), + [1108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), + [1110] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1706), + [1112] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_import_target, 1, 0, 3), SHIFT(1715), + [1115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 7, 0, 78), + [1117] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 7, 0, 78), + [1119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 4, 0, 23), + [1121] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 4, 0, 23), + [1123] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 8, 0, 78), + [1125] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 8, 0, 78), + [1127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_declaration, 6, 0, 38), + [1129] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_declaration, 6, 0, 38), + [1131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 156), + [1133] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 156), + [1135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 45), + [1137] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 45), + [1139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 5, 0, 20), + [1141] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 5, 0, 20), + [1143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 9, 0, 105), + [1145] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 9, 0, 105), + [1147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 66), + [1149] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 66), + [1151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 6, 0, 48), + [1153] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 6, 0, 48), + [1155] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1595), + [1157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 68), + [1159] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 68), + [1161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 49), + [1163] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 49), + [1165] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 69), + [1167] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 69), + [1169] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 6, 0, 33), + [1171] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 6, 0, 33), + [1173] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 136), + [1175] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 136), + [1177] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 72), + [1179] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 72), + [1181] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_legacy_import_path, 2, 0, 0), + [1183] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_legacy_import_path, 2, 0, 0), + [1185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 49), + [1187] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 49), + [1189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 53), + [1191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 53), + [1193] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 75), + [1195] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 75), + [1197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 76), + [1199] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 7, 0, 76), + [1201] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 124), + [1203] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 124), + [1205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 112), + [1207] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 112), + [1209] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 138), + [1211] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 138), + [1213] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_union_type_repeat1, 2, 0, 0), SHIFT_REPEAT(1361), + [1216] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 139), + [1218] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 139), + [1220] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 4, 0, 8), + [1222] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 4, 0, 8), + [1224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), + [1226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 2, 0, 0), + [1228] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, 0, 54), + [1230] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 6, 0, 54), + [1232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 145), + [1234] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 145), + [1236] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 127), + [1238] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 127), + [1240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 33), + [1242] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 5, 0, 33), + [1244] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 11, 0, 148), + [1246] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 11, 0, 148), + [1248] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 104), + [1250] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 8, 0, 104), + [1252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1361), + [1254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 118), + [1256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 118), + [1258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 60), + [1260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 60), + [1262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 103), + [1264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 103), + [1266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 152), + [1268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 152), + [1270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_validation, 2, 0, 0), + [1272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_validation, 2, 0, 0), + [1274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 100), + [1276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 100), + [1278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 12, 0, 157), + [1280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 12, 0, 157), + [1282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 4, 0, 28), + [1284] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 4, 0, 28), + [1286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), + [1288] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), + [1290] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1560), + [1293] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 120), + [1295] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 120), + [1297] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), + [1299] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_import_target_repeat1, 2, 0, 16), + [1301] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 84), + [1303] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 84), + [1305] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_legacy_import_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1661), + [1308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 28), + [1310] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 28), + [1312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 7, 0, 85), + [1314] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 7, 0, 85), + [1316] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 132), + [1318] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 132), + [1320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 108), + [1322] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 108), + [1324] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 121), + [1326] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 121), + [1328] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 13, 0, 164), + [1330] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 13, 0, 164), + [1332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 8, 0, 87), + [1334] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 8, 0, 87), + [1336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 10, 0, 133), + [1338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 10, 0, 133), + [1340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 68), + [1342] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 68), + [1344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 87), + [1346] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 87), + [1348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 7, 0, 69), + [1350] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 7, 0, 69), + [1352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, 0, 37), + [1354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 5, 0, 37), + [1356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 45), + [1358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 45), + [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 89), + [1362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 89), + [1364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 9, 0, 109), + [1366] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 9, 0, 109), + [1368] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_declaration, 5, 0, 8), + [1370] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_signature_declaration, 5, 0, 8), + [1372] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 91), + [1374] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 91), + [1376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 9, 0, 123), + [1378] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 9, 0, 123), + [1380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 8, 0, 92), + [1382] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_declaration, 8, 0, 92), + [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 8, 0, 94), + [1386] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 8, 0, 94), + [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 43), + [1390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 43), + [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 8, 0, 77), + [1394] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_declaration, 8, 0, 77), + [1396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 6, 0, 60), + [1398] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 6, 0, 60), + [1400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_declaration, 5, 0, 43), + [1402] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_module_declaration, 5, 0, 43), + [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 67), + [1406] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 6, 0, 67), + [1408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1078), + [1410] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 7, 0, 86), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 7, 0, 86), + [1414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1038), + [1416] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 5, 0, 38), + [1418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 5, 0, 38), + [1420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), + [1422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1051), + [1424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), + [1426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1056), + [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_declaration, 6, 0, 55), + [1430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_extern_declaration, 6, 0, 55), + [1432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), + [1434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), + [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 8), + [1438] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 3, 0, 8), + [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1, 0, 0), + [1442] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1, 0, 0), + [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 0), + [1446] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 2, 0, 0), + [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 2, 0, 15), + [1450] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 2, 0, 15), + [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 2, 0, 0), + [1454] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_body, 2, 0, 0), + [1456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 1), + [1458] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 1), + [1460] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 3, 0, 6), + [1462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 3, 0, 6), + [1464] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 3, 0, 9), + [1466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 3, 0, 9), + [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 33), + [1470] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 4, 0, 33), + [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_declaration, 4, 0, 34), + [1474] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_declaration, 4, 0, 34), + [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 3, 0, 0), + [1478] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 3, 0, 0), + [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_namespace_body, 3, 0, 0), + [1482] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_namespace_body, 3, 0, 0), + [1484] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_tail, 4, 0, 0), + [1486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_tail, 4, 0, 0), + [1488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1747), + [1490] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1747), + [1493] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1373), + [1496] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), SHIFT(1374), + [1499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1753), + [1501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [1503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [1505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [1507] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), + [1509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [1511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(356), + [1513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1502), + [1515] = {.entry = {.count = 1, .reusable = false}}, SHIFT(263), + [1517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [1519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [1521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [1523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [1525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1504), + [1527] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [1529] = {.entry = {.count = 1, .reusable = false}}, SHIFT(315), + [1531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [1533] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), + [1535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), + [1537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), + [1539] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), + [1541] = {.entry = {.count = 1, .reusable = false}}, SHIFT(314), + [1543] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), + [1545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 42), + [1547] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 42), + [1549] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select_arm, 3, 0, 42), + [1551] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select_arm, 3, 0, 42), + [1553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [1555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1627), + [1557] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1590), + [1559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1790), + [1561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1729), + [1563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1770), + [1565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1741), + [1567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1478), + [1569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(874), + [1571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1525), + [1573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), + [1575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(584), + [1577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(516), + [1579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(529), + [1581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(595), + [1583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(553), + [1585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), + [1587] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1627), + [1590] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1590), + [1593] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1790), + [1596] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1729), + [1599] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1770), + [1602] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1741), + [1605] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1478), + [1608] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(874), + [1611] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1525), + [1614] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_module_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(968), + [1617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(567), + [1619] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), REDUCE(sym_field_pattern, 1, 0, 0), + [1622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1549), + [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(522), + [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), + [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(580), + [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), + [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(582), + [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(574), + [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(592), + [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), + [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(560), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), + [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(646), + [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(647), + [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(650), + [1650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(657), + [1652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), + [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), + [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), + [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), + [1660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), + [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), + [1664] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), + [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(675), + [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), + [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(687), + [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(581), + [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [1676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [1678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), + [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [1682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [1684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), + [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 5, 0, 22), + [1688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_entry, 3, 0, 18), + [1690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), + [1692] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignment, 3, 0, 10), + [1694] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 3, 0, 39), + [1696] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_handler_arm, 4, 0, 56), + [1698] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 10), + [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1154), + [1702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [1704] = {.entry = {.count = 1, .reusable = false}}, SHIFT(999), + [1706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1465), + [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(939), + [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1430), + [1714] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1209), + [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1209), + [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [1720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [1722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [1724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1674), + [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [1728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), + [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(733), + [1758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(747), + [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(749), + [1762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(750), + [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(751), + [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [1768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), + [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(763), + [1772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), + [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), + [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), + [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), + [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350), + [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1604), + [1784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(357), + [1786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1663), + [1788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), + [1790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [1792] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1014), + [1794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [1796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [1798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [1800] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1014), + [1803] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), + [1806] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), + [1808] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(939), + [1811] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1430), + [1814] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), + [1817] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(720), + [1820] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), + [1823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(758), + [1825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [1827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1060), + [1829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), + [1831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(885), + [1833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(898), + [1835] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1014), + [1838] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1465), + [1841] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), + [1843] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(939), + [1846] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1430), + [1849] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), + [1852] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(720), + [1855] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_select_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1209), + [1858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [1860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(748), + [1862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [1864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(525), + [1866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1552), + [1868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1563), + [1870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1569), + [1872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1464), + [1874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1610), + [1876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(636), + [1878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(648), + [1880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(651), + [1882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(587), + [1884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1273), + [1886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), + [1888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(548), + [1890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1687), + [1892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(543), + [1894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1545), + [1896] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), + [1898] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1552), + [1901] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1563), + [1904] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1569), + [1907] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1770), + [1910] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1464), + [1913] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1610), + [1916] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_signature_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(968), + [1919] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_path_repeat1, 2, 0, 0), SHIFT_REPEAT(1529), + [1922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1529), + [1924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1006), + [1926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1029), + [1928] = {.entry = {.count = 1, .reusable = false}}, SHIFT(921), + [1930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1414), + [1932] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1748), + [1934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(996), + [1936] = {.entry = {.count = 1, .reusable = false}}, SHIFT(485), + [1938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), + [1940] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1740), + [1942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(991), + [1944] = {.entry = {.count = 1, .reusable = false}}, SHIFT(483), + [1946] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1714), + [1948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(987), + [1950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_doc_comment, 1, 0, 0), + [1952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), + [1954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1049), + [1956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), + [1958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1050), + [1960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1052), + [1962] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), + [1964] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_doc_comment_repeat1, 2, 0, 0), SHIFT_REPEAT(973), + [1967] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 61), + [1969] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 2, 0, 44), + [1971] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 1, 0, 4), + [1973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1009), + [1975] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 4, 0, 80), + [1977] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_declaration, 3, 0, 62), + [1979] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_module_item, 1, 0, 0), + [1981] = {.entry = {.count = 1, .reusable = false}}, SHIFT(952), + [1983] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1526), + [1985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(985), + [1987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1702), + [1989] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 142), + [1991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), + [1993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1222), + [1995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1567), + [1997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1620), + [1999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1642), + [2001] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 1, 0, 0), + [2003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1625), + [2005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 4, 0, 23), + [2007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1091), + [2009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), + [2011] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_symbol_path, 2, 0, 0), + [2013] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 97), + [2015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1020), + [2017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1537), + [2019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1683), + [2021] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 78), + [2023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), + [2025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1202), + [2027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1503), + [2029] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 1, 0, 0), + [2031] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1001), + [2033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(950), + [2035] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 4), + [2037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 153), + [2039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1448), + [2041] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 161), + [2043] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 115), + [2045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), + [2047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1769), + [2049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1792), + [2051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1644), + [2053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1572), + [2055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1592), + [2057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1467), + [2059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), + [2061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1631), + [2063] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 130), + [2065] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 3, 0, 65), + [2067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1085), + [2069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1176), + [2071] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 2, 0, 23), + [2073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1053), + [2075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1155), + [2077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1337), + [2079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1655), + [2081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1509), + [2083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1519), + [2085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1565), + [2087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), + [2089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1570), + [2091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1755), + [2093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1756), + [2095] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1571), + [2097] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1708), + [2099] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1757), + [2101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1487), + [2103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1710), + [2105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(925), + [2107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(489), + [2109] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 6, 0, 117), + [2111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), + [2113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(473), + [2115] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 2, 0, 29), + [2117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1618), + [2119] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 78), + [2121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), + [2123] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 2, 0, 0), + [2125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_ascription, 4, 0, 63), + [2127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_ref, 2, 0, 4), + [2129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_set, 4, 0, 0), + [2131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 7, 0, 129), + [2133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 5, 0, 98), + [2135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1008), + [2137] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_value, 4, 0, 81), + [2139] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 141), + [2141] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 4, 0, 20), + [2143] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_arguments, 3, 0, 0), + [2145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 10, 0, 160), + [2147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 8, 0, 143), + [2149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_module, 3, 0, 64), + [2151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 8, 0, 144), + [2153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 6, 0, 116), + [2155] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 11, 0, 165), + [2157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 9, 0, 154), + [2159] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_item, 1, 0, 0), + [2161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_function, 5, 0, 96), + [2163] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_signature_type, 7, 0, 77), + [2165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [2167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [2169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), + [2171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1238), + [2173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [2175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), + [2177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1088), + [2179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [2181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1084), + [2183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), + [2185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1089), + [2187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [2189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [2191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1069), + [2193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), + [2195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), + [2197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), + [2199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1063), + [2201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [2203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1025), + [2205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [2207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1066), + [2209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [2211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1070), + [2213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [2215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1097), + [2217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [2219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1017), + [2221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), + [2223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1071), + [2225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [2227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1045), + [2229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [2231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1094), + [2233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [2235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1086), + [2237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [2239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1087), + [2241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), + [2243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1072), + [2245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [2247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1039), + [2249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), + [2251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1068), + [2253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), + [2255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1083), + [2257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [2259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1082), + [2261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [2263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1046), + [2265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), + [2267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1064), + [2269] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1468), + [2271] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1760), + [2273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [2275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), + [2277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1274), + [2279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), + [2281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), + [2283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(311), + [2285] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 2, 0, 0), + [2287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [2289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [2291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [2293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [2295] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_symbol_path, 1, 0, 0), + [2297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), + [2299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [2301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), + [2303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), + [2305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [2307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [2309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [2311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [2313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), + [2315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(557), + [2317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), + [2319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [2321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), + [2323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [2325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [2327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [2329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), + [2331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [2333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [2335] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1435), + [2338] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_parameter_list_repeat1, 2, 0, 0), + [2340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 22), + [2342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 6, 0, 95), + [2344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 26), + [2346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1258), + [2348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1635), + [2350] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 7, 0, 114), + [2352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1530), + [2354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(998), + [2356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(992), + [2358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1518), + [2360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), + [2362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1455), + [2364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 1, 0, 0), + [2366] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1030), + [2369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_list_repeat1, 2, 0, 0), + [2371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1435), + [2373] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1, 0, 0), + [2375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), + [2377] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 2, 0, 0), + [2379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), + [2381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1274), + [2383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), + [2385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(598), + [2387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), + [2389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(639), + [2391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(601), + [2393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(644), + [2395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), + [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(649), + [2399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(976), + [2401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1252), + [2403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(609), + [2405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(662), + [2407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1136), + [2409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), + [2411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(670), + [2413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1133), + [2415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(682), + [2417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(610), + [2419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), + [2421] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [2423] = {.entry = {.count = 1, .reusable = true}}, SHIFT(697), + [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1106), + [2427] = {.entry = {.count = 1, .reusable = false}}, SHIFT(272), + [2429] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2, 0, 0), + [2431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1235), + [2433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(496), + [2435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(513), + [2437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(323), + [2439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), + [2441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1789), + [2443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), + [2445] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 5, 0, 4), + [2447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), + [2449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), + [2451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1127), + [2453] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_list, 1, 0, 0), + [2455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1129), + [2457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1125), + [2459] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(160), + [2462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1134), + [2464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), + [2466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), + [2468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1143), + [2470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 4), + [2472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1037), + [2474] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(1518), + [2477] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_declaration_repeat1, 2, 0, 0), + [2479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1123), + [2481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), + [2483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1138), + [2485] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1124), + [2487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1528), + [2489] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1451), + [2491] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(1274), + [2494] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_handler_expression_repeat1, 2, 0, 0), + [2496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 4, 0, 57), + [2498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(970), + [2500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 4, 0, 4), + [2502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(971), + [2504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 3, 0, 0), + [2506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 3, 0, 41), + [2508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_pattern, 2, 0, 0), + [2510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1388), + [2512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [2514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1128), + [2516] = {.entry = {.count = 1, .reusable = false}}, SHIFT(94), + [2518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pattern, 2, 0, 25), + [2520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 1, 0, 0), + [2522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1469), + [2524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), + [2526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [2528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), + [2530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [2532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [2534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [2536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), + [2538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [2540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), + [2542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), + [2544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 1, 0, 4), + [2546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [2548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(732), + [2550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 1, 0, 0), + [2552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1473), + [2554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), + [2556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 2, 0, 0), + [2558] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1505), + [2561] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_extern_parameter_list_repeat1, 2, 0, 0), + [2563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(743), + [2565] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declaration, 3, 0, 22), + [2567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [2569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(746), + [2571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [2573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), + [2575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1424), + [2577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1550), + [2579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [2581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [2583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), + [2585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), + [2587] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(59), + [2590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), + [2592] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_declarations_repeat1, 2, 0, 0), SHIFT_REPEAT(1469), + [2595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [2597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [2599] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [2601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [2603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [2605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), + [2607] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 2, 0, 0), + [2609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [2611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [2613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [2615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293), + [2617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [2619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), + [2621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 22), + [2623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298), + [2625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [2627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301), + [2631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), + [2633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304), + [2635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), + [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), + [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [2641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), + [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [2645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), + [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [2649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), + [2651] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1505), + [2653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 1, 0, 0), + [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(637), + [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(948), + [2661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), + [2663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [2665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [2667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), + [2669] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(948), + [2672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_pattern_repeat1, 2, 0, 0), + [2674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1453), + [2676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 2, 0, 0), + [2678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), + [2680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(849), + [2682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1578), + [2684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 2, 0, 0), + [2686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1491), + [2688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), + [2690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_pattern, 2, 0, 0), + [2692] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter_list, 2, 0, 0), + [2694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [2696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(853), + [2698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [2700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(502), + [2702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_list, 1, 0, 0), + [2704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [2706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(471), + [2708] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), + [2710] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(1549), + [2713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [2715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1602), + [2717] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_declarations, 2, 0, 0), + [2719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), + [2721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter_list, 1, 0, 0), + [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [2725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), + [2727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_assignments, 1, 0, 0), + [2729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [2731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [2733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument_list, 1, 0, 0), + [2735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [2737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member_list, 2, 0, 0), + [2739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [2741] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), + [2743] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_import_member_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1473), + [2746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [2748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [2750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352), + [2752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [2754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [2756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [2758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1396), + [2760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_handler_params, 1, 0, 0), + [2762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(616), + [2764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [2766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(625), + [2768] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1343), + [2771] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_effect_list_repeat1, 2, 0, 0), + [2773] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), + [2775] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_assignments_repeat1, 2, 0, 0), SHIFT_REPEAT(1491), + [2778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [2780] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), SHIFT_REPEAT(1396), + [2783] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_handler_params_repeat1, 2, 0, 0), + [2785] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1278), + [2788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_parameter_list_repeat1, 2, 0, 0), + [2790] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 58), SHIFT_REPEAT(951), + [2793] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 58), + [2795] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(1453), + [2798] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_named_argument_list_repeat1, 2, 0, 0), + [2800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [2802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [2804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(832), + [2806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(944), + [2808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), + [2810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1713), + [2812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1245), + [2814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), + [2816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [2818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1739), + [2820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(942), + [2822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1272), + [2824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [2826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [2828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1411), + [2830] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_member, 3, 0, 70), + [2832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1233), + [2834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1158), + [2836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1054), + [2838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [2840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1163), + [2842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), + [2844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1168), + [2846] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_parameter, 3, 0, 22), + [2848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1075), + [2850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), + [2852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1058), + [2854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [2856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), + [2858] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1277), + [2860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), + [2862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), + [2864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), + [2866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [2868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1080), + [2870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [2872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(955), + [2874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1187), + [2876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1081), + [2878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [2880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1169), + [2882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1217), + [2884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(629), + [2886] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 2, 0, 36), + [2888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1059), + [2890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [2892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1246), + [2894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(618), + [2896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1585), + [2898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(990), + [2900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), + [2902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1206), + [2904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), + [2906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1099), + [2908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [2910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(965), + [2912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1182), + [2914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1092), + [2916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), + [2918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1093), + [2920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), + [2922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1666), + [2924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1062), + [2926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [2928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1031), + [2930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), + [2932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(963), + [2934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1146), + [2936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1214), + [2938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1189), + [2940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1466), + [2942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1208), + [2944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1446), + [2946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1221), + [2948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), + [2950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1188), + [2952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1227), + [2954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_parameter, 1, 0, 4), + [2956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(959), + [2958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1184), + [2960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1167), + [2962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1225), + [2964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1032), + [2966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [2968] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_operation_declaration, 3, 0, 22), + [2970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_pattern_repeat1, 2, 0, 41), + [2972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1485), + [2974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1244), + [2976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1161), + [2978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), + [2980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1248), + [2982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), + [2984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1250), + [2986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1367), + [2988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1150), + [2990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1195), + [2992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1257), + [2994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1196), + [2996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1260), + [2998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1171), + [3000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(960), + [3002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1177), + [3004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1406), + [3006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(962), + [3008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1149), + [3010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), + [3012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1534), + [3014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [3016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), + [3018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1144), + [3020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), + [3022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), + [3024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [3026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), + [3028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [3030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [3032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), + [3034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1673), + [3036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1730), + [3038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [3040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), + [3042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(986), + [3044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [3046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1785), + [3048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(989), + [3050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [3052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), + [3054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(954), + [3056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1074), + [3058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1658), + [3060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1275), + [3062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(612), + [3064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [3066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), + [3068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [3070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1022), + [3072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), + [3074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1044), + [3076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), + [3078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), + [3080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(470), + [3082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1742), + [3084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(498), + [3086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [3088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), + [3090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1497), + [3092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [3094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [3096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1786), + [3098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1776), + [3100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(731), + [3102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [3104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), + [3106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(753), + [3108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(597), + [3110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1759), + [3112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(941), + [3114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1447), + [3116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(935), + [3118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1501), + [3120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), + [3122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), + [3124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [3126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1012), + [3128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1449), + [3130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1450), + [3132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), + [3134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1454), + [3136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), + [3138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1218), + [3140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(652), + [3142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), + [3144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1057), + [3146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [3148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), + [3150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1472), + [3152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(937), + [3154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), + [3156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1145), + [3158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1611), + [3160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1601), + [3162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), + [3164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [3166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(851), + [3168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1494), + [3170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1425), + [3172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), + [3174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(615), + [3176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), + [3178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), + [3180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [3182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(855), + [3184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), + [3186] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [3188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(956), + [3190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1619), + [3192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1228), + [3194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1386), + [3196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1677), + [3198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), + [3200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1141), + [3202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1684), + [3204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(858), + [3206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1587), + [3208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1709), + [3210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [3212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(556), + [3214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(563), + [3216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1232), + [3218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1131), + [3220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1101), + [3222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [3224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1027), + [3226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [3228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(964), + [3230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1139), + [3232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [3234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1076), + [3236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1428), + [3238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [3240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [3242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [3244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1562), + [3246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(760), + [3248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), + [3250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(507), + [3252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [3254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), + [3256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [3258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1764), + [3260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [3262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1419), + [3264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(995), + [3266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1065), + [3268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), + [3270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1437), + [3272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1720), + [3274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1438), + [3276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [3278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [3280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1142), + [3282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1659), + [3284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1132), + [3286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [3288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1476), + [3290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1554), + [3292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1261), + [3294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(966), + [3296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(607), + [3298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(605), + [3300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(977), + [3302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), + [3304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), + [3306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1067), + [3308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [3310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1734), + [3312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(602), + [3314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [3316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(829), + [3318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1122), + [3320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1678), + [3322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1696), + [3324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1387), + [3326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [3328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), + [3330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1041), + [3332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1692), + [3334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1498), + [3336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [3338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(599), + [3340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), + [3342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1021), + [3344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(961), + [3346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1452), + [3348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(611), + [3350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1543), + [3352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(596), + [3354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1140), + [3356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1541), + [3358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1231), + [3360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), + [3362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1456), + [3364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1457), + [3366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1216), + [3368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [3370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(932), + [3372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), + [3374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), + [3376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1564), + [3378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1095), + [3380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1408), + [3382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1575), + [3384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), + [3386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1350), + [3388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1463), + [3390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1229), + [3392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1582), + [3394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(978), + [3396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1103), + [3398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), + [3400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(988), + [3402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(566), + [3404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1596), + [3406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(767), + [3408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), + [3410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1603), + [3412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), + [3414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351), + [3416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [3418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1251), + [3420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(969), + [3422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [3424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1616), + [3426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1254), + [3428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(972), + [3430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1471), + [3432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(957), + [3434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1024), + [3436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), + [3438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), + [3440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(958), + [3442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1265), + [3444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), + [3446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), + [3448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1654), + [3450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(997), + [3452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1458), + [3454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1204), + [3456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), + [3458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1262), + [3460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), + [3462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(719), + [3464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(993), + [3466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [3468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1705), + [3470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1486), + [3472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1256), + [3474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(736), + [3476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1488), + [3478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), + [3480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1489), + [3482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1268), + [3484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1207), + [3486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1442), + [3488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), + [3490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1723), + [3492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), + [3494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1205), + [3496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1727), + [3498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), + [3500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [3502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1495), + [3504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1426), + [3506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1743), + [3508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1745), + [3510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1746), + [3512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1749), + [3514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), + [3516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1758), + [3518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(707), + [3520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1135), + [3522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1763), + [3524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1622), + [3526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [3528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1508), + [3530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(943), + [3532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1043), + [3534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [3536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(931), + [3538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [3540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1777), + [3542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [3544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1781), + [3546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), + [3548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), }; #ifdef __cplusplus diff --git a/tree-sitter-osprey/test/corpus/osprey.txt b/tree-sitter-osprey/test/corpus/osprey.txt index 4e1f90c4..3e1afd24 100644 --- a/tree-sitter-osprey/test/corpus/osprey.txt +++ b/tree-sitter-osprey/test/corpus/osprey.txt @@ -11,13 +11,24 @@ fn add(a: int, b: int) -> int = a + b (function_declaration name: (identifier) parameters: (parameter_list - (parameter name: (identifier) type: (type_identifier (identifier))) - (parameter name: (identifier) type: (type_identifier (identifier)))) - return_type: (type_identifier (identifier)) + (parameter + name: (identifier) + type: (type_identifier + (identifier))) + (parameter + name: (identifier) + type: (type_identifier + (identifier)))) + return_type: (type_identifier + (identifier)) body: (expression (binary_expression - left: (expression (primary_expression (identifier))) - right: (expression (primary_expression (identifier)))))))) + left: (expression + (primary_expression + (identifier))) + right: (expression + (primary_expression + (identifier)))))))) ================================================================================ Union type declaration @@ -32,9 +43,12 @@ type Color = Red | Green | Blue (type_declaration name: (identifier) definition: (union_type - (variant name: (identifier)) - (variant name: (identifier)) - (variant name: (identifier)))))) + (variant + name: (identifier)) + (variant + name: (identifier)) + (variant + name: (identifier)))))) ================================================================================ Effect declaration with function-typed operation @@ -51,8 +65,11 @@ effect Log { info: fn(string) -> Unit } (operation_declaration name: (identifier) type: (function_type - (type_list (type_identifier (identifier))) - (type_identifier (identifier))))))) + (type_list + (type_identifier + (identifier))) + (type_identifier + (identifier))))))) ================================================================================ Short lambda @@ -69,11 +86,18 @@ let f = |x| => x * 2 value: (expression (primary_expression (lambda_expression - (parameter_list (parameter name: (identifier))) + (parameter_list + (parameter + name: (identifier))) body: (expression (binary_expression - left: (expression (primary_expression (identifier))) - right: (expression (primary_expression (literal (integer)))))))))))) + left: (expression + (primary_expression + (identifier))) + right: (expression + (primary_expression + (literal + (integer)))))))))))) ================================================================================ Match with constructor destructuring and wildcard @@ -92,13 +116,23 @@ let r = match x { name: (identifier) value: (expression (match_expression - value: (expression (primary_expression (identifier))) + value: (expression + (primary_expression + (identifier))) (match_arm - pattern: (pattern name: (identifier) (field_pattern (identifier))) - body: (expression (primary_expression (identifier)))) + pattern: (pattern + name: (identifier) + (field_pattern + (identifier))) + body: (expression + (primary_expression + (identifier)))) (match_arm pattern: (pattern) - body: (expression (primary_expression (literal (integer)))))))))) + body: (expression + (primary_expression + (literal + (integer)))))))))) ================================================================================ if / else-if chain (expression form, else required) [GRAMMAR-IF-ELSE] @@ -116,16 +150,35 @@ let t = if score >= 90 { "A" } else if score >= 80 { "B" } else { "C" } (if_expression condition: (expression (binary_expression - left: (expression (primary_expression (identifier))) - right: (expression (primary_expression (literal (integer)))))) - consequence: (expression (primary_expression (literal (string)))) + left: (expression + (primary_expression + (identifier))) + right: (expression + (primary_expression + (literal + (integer)))))) + consequence: (expression + (primary_expression + (literal + (string)))) alternative: (if_expression condition: (expression (binary_expression - left: (expression (primary_expression (identifier))) - right: (expression (primary_expression (literal (integer)))))) - consequence: (expression (primary_expression (literal (string)))) - alternative: (expression (primary_expression (literal (string)))))))))) + left: (expression + (primary_expression + (identifier))) + right: (expression + (primary_expression + (literal + (integer)))))) + consequence: (expression + (primary_expression + (literal + (string)))) + alternative: (expression + (primary_expression + (literal + (string)))))))))) ================================================================================ Pipe chain (left-associative) with UFCS-style calls @@ -143,11 +196,254 @@ let n = items |> map(double) |> sum() (pipe_expression left: (expression (pipe_expression - left: (expression (primary_expression (identifier))) + left: (expression + (primary_expression + (identifier))) right: (expression (call_expression - callee: (expression (primary_expression (identifier))) - (argument_list (expression (primary_expression (identifier)))))))) + callee: (expression + (primary_expression + (identifier))) + (argument_list + (expression + (primary_expression + (identifier)))))))) right: (expression (call_expression - callee: (expression (primary_expression (identifier)))))))))) + callee: (expression + (primary_expression + (identifier)))))))))) + +================================================================================ +Namespaces and structured imports [MODULES-NAMESPACE] [MODULES-IMPORT] +================================================================================ + +namespace billing; +import billing::Tax::{addTax, zero as noTax} +import "billing/api" as billingApi +import std.io.file + +-------------------------------------------------------------------------------- + +(source_file + (statement + (namespace_declaration + (namespace_name + (identifier)))) + (statement + (import_statement + (import_target + (namespace_name + (identifier)) + (identifier)) + (import_tail + (import_member_list + (import_member + (identifier)) + (import_member + (identifier) + (identifier)))))) + (statement + (import_statement + (import_target + (namespace_name + (string))) + (import_tail + (identifier)))) + (statement + (import_statement + (legacy_import_path + (identifier) + (identifier) + (identifier))))) + +================================================================================ +State module, exports, opacity, and signature [MODULES-MODULE] [MODULES-SIGNATURE] +================================================================================ + +signature StoreSig { + opaque type Store + type Count = int + let zero: Count + fn empty() -> Store + effect StoreFx { load: fn() -> Store } + module Nested : NestedSig + extra +} + +state module Storage::Memory : StoreSig + extra { + mut count = 0 + export opaque type Store = int + export fn empty() -> Store = count + export effect StoreFx { load: fn() -> Store } + export module Nested { export let value = 1 } +} + +-------------------------------------------------------------------------------- + +(source_file + (statement + (signature_declaration + (identifier) + (signature_item + (signature_type + (identifier))) + (signature_item + (signature_type + (identifier) + (type_identifier + (identifier)))) + (signature_item + (signature_value + (identifier) + (type_identifier + (identifier)))) + (signature_item + (signature_function + (identifier) + (type_identifier + (identifier)))) + (signature_item + (effect_declaration + (identifier) + (operation_declaration + (identifier) + (function_type + (type_identifier + (identifier)))))) + (signature_item + (signature_module + (symbol_path + (identifier)) + (signature_ascription + (symbol_path + (identifier))))))) + (statement + (module_declaration + (symbol_path + (identifier) + (identifier)) + (signature_ascription + (symbol_path + (identifier))) + (module_item + (let_declaration + (identifier) + (expression + (primary_expression + (literal + (integer)))))) + (module_item + (export_declaration + (type_declaration + (identifier) + (union_type + (variant + (identifier)))))) + (module_item + (export_declaration + (function_declaration + (identifier) + (type_identifier + (identifier)) + (expression + (primary_expression + (identifier)))))) + (module_item + (export_declaration + (effect_declaration + (identifier) + (operation_declaration + (identifier) + (function_type + (type_identifier + (identifier))))))) + (module_item + (export_declaration + (module_declaration + (symbol_path + (identifier)) + (module_item + (export_declaration + (let_declaration + (identifier) + (expression + (primary_expression + (literal + (integer))))))))))))) + +================================================================================ +Qualified value, type, constructor, and effect paths [MODULES-FLAVOR-PROJECTION] +================================================================================ + +fn run(x: billing::Money) -> billing::Result = { + let money = billing::Money { cents: 1 } + perform billing::Ledger.post(money) + billing::Tax::addTax(x) +} + +-------------------------------------------------------------------------------- + +(source_file + (statement + (function_declaration + (identifier) + (parameter_list + (parameter + (identifier) + (type_identifier + (qualified_path + (identifier) + (identifier))))) + (generic_type + (qualified_path + (identifier) + (identifier)) + (type_list + (type_identifier + (identifier)))) + (expression + (primary_expression + (block + (statement + (let_declaration + (identifier) + (expression + (primary_expression + (type_constructor + (qualified_path + (identifier) + (identifier)) + (field_assignments + (field_assignment + (identifier) + (expression + (primary_expression + (literal + (integer))))))))))) + (statement + (expression_statement + (expression + (primary_expression + (perform_expression + (qualified_path + (identifier) + (identifier)) + (identifier) + (argument_list + (expression + (primary_expression + (identifier))))))))) + (statement + (expression_statement + (expression + (call_expression + (expression + (primary_expression + (qualified_path + (identifier) + (identifier) + (identifier)))) + (argument_list + (expression + (primary_expression + (identifier)))))))))))))) diff --git a/vscode-extension/language-configuration-ml.json b/vscode-extension/language-configuration-ml.json index 4032b443..1d6f4467 100644 --- a/vscode-extension/language-configuration-ml.json +++ b/vscode-extension/language-configuration-ml.json @@ -14,14 +14,14 @@ "wordPattern": "[a-zA-Z_][a-zA-Z0-9_]*|[0-9]+(?:\\.[0-9]+)?", "onEnterRules": [ { - "beforeText": "^\\s*(?:.*\\b(?:do|match)|.*(?:=>|=)|(?:effect|handler)\\b.*)\\s*$", + "beforeText": "^\\s*(?:.*\\b(?:do|match)|.*(?:=>|=)|(?:effect|handler|module|signature|state|import)\\b.*)\\s*$", "action": { "indent": "indent" } } ], "indentationRules": { - "increaseIndentPattern": "^\\s*(?:.*\\b(?:do|match)|.*(?:=>|=)|(?:effect|handler)\\b.*)\\s*$", + "increaseIndentPattern": "^\\s*(?:.*\\b(?:do|match)|.*(?:=>|=)|(?:effect|handler|module|signature|state|import)\\b.*)\\s*$", "decreaseIndentPattern": "^\\s*(?:end|else)\\b.*$" }, "folding": { diff --git a/vscode-extension/package.json b/vscode-extension/package.json index 7908ec31..0548b972 100644 --- a/vscode-extension/package.json +++ b/vscode-extension/package.json @@ -107,6 +107,10 @@ } ], "snippets": [ + { + "language": "osprey", + "path": "./snippets/osprey.json" + }, { "language": "osprey-ml", "path": "./snippets/osprey-ml.json" diff --git a/vscode-extension/snippets/osprey-ml.json b/vscode-extension/snippets/osprey-ml.json index 2faee79c..fd275b44 100644 --- a/vscode-extension/snippets/osprey-ml.json +++ b/vscode-extension/snippets/osprey-ml.json @@ -38,5 +38,40 @@ "prefix": "main", "description": "A main binding (ML flavor)", "body": ["main = do", " ${1:print \"Hello, Osprey!\"}"] + }, + "File namespace": { + "prefix": "namespace", + "description": "A file-scoped logical namespace [MODULES-NAMESPACE]", + "body": ["namespace ${1:app}", "", "${0}"] + }, + "Module": { + "prefix": "module", + "description": "A closed ML module [MODULES-MODULE]", + "body": ["module ${1:Name}", " ${0}"] + }, + "State module": { + "prefix": "state", + "description": "A punctuation-free ML state owner [MODULES-STATE-MODULE]", + "body": ["state ${1:Store}", " ${0}"] + }, + "Module signature": { + "prefix": "signature", + "description": "An explicit ML module signature [MODULES-SIGNATURE]", + "body": ["signature ${1:Api}", " ${2:value} : ${3:Type}"] + }, + "Qualified import": { + "prefix": "import", + "description": "Import a logical module with :: qualification [MODULES-IMPORT]", + "body": ["import ${1:namespace}::${2:Module}${3: as Alias}"] + }, + "Exported binding": { + "prefix": "export", + "description": "Export one module binding [MODULES-EXPORTS]", + "body": ["export ${1:name} = ${2:value}"] + }, + "Opaque exported type": { + "prefix": "opaque", + "description": "Export an opaque ML type [MODULES-OPAQUE-TYPES]", + "body": ["export opaque type ${1:Name} = ${2:Representation}"] } } diff --git a/vscode-extension/snippets/osprey.json b/vscode-extension/snippets/osprey.json new file mode 100644 index 00000000..4f0b00e3 --- /dev/null +++ b/vscode-extension/snippets/osprey.json @@ -0,0 +1,37 @@ +{ + "File namespace": { + "prefix": "namespace", + "description": "A file-scoped logical namespace [MODULES-NAMESPACE]", + "body": ["namespace ${1:app};", "", "${0}"] + }, + "Module": { + "prefix": "module", + "description": "A closed Default-flavor module [MODULES-MODULE]", + "body": ["module ${1:Name} {", " ${0}", "}"] + }, + "State module": { + "prefix": "state", + "description": "A durable state owner [MODULES-STATE-MODULE]", + "body": ["state module ${1:Store} {", " ${0}", "}"] + }, + "Module signature": { + "prefix": "signature", + "description": "An explicit module signature [MODULES-SIGNATURE]", + "body": ["signature ${1:Api} {", " fn ${2:value}() -> ${3:Type}", "}"] + }, + "Qualified import": { + "prefix": "import", + "description": "Import a logical module with :: qualification [MODULES-IMPORT]", + "body": ["import ${1:namespace}::${2:Module}${3: as Alias}"] + }, + "Exported function": { + "prefix": "export", + "description": "Export one module function [MODULES-EXPORTS]", + "body": ["export fn ${1:name}(${2:params}) = ${3:body}"] + }, + "Opaque exported type": { + "prefix": "opaque", + "description": "Export an opaque type alias [MODULES-OPAQUE-TYPES]", + "body": ["export opaque type ${1:Name} = ${2:Representation}"] + } +} diff --git a/vscode-extension/syntaxes/osprey-ml.tmLanguage.json b/vscode-extension/syntaxes/osprey-ml.tmLanguage.json index 0a129dd8..483ab471 100644 --- a/vscode-extension/syntaxes/osprey-ml.tmLanguage.json +++ b/vscode-extension/syntaxes/osprey-ml.tmLanguage.json @@ -9,6 +9,7 @@ { "include": "#numbers" }, { "include": "#booleans" }, { "include": "#effect-operations" }, + { "include": "#modules" }, { "include": "#function-heads" }, { "include": "#types" }, { "include": "#operators" }, @@ -55,7 +56,60 @@ }, { "name": "keyword.declaration.osprey-ml", - "match": "\\b(mut|effect|handler|type)\\b" + "match": "\\b(mut|effect|handler|type|namespace|import|module|signature|export|opaque|state|as)\\b" + } + ] + }, + "modules": { + "patterns": [ + { + "name": "meta.namespace.declaration.osprey-ml", + "match": "^\\s*(namespace)\\s+(\\\"(?:\\\\.|[^\\\"\\\\])*\\\"|[a-zA-Z_][a-zA-Z0-9_]*)", + "captures": { + "1": { "name": "keyword.declaration.namespace.osprey-ml" }, + "2": { "name": "entity.name.namespace.osprey-ml" } + } + }, + { + "name": "meta.module.declaration.osprey-ml", + "match": "^\\s*(module|state)\\s+([a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z_][a-zA-Z0-9_]*)*)(?:\\s*:\\s*([a-zA-Z_][a-zA-Z0-9_:]*))?", + "captures": { + "1": { "name": "keyword.declaration.module.osprey-ml" }, + "2": { "name": "entity.name.type.module.osprey-ml" }, + "3": { "name": "entity.name.type.interface.osprey-ml" } + } + }, + { + "name": "meta.signature.declaration.osprey-ml", + "match": "^\\s*(signature)\\s+([A-Z][a-zA-Z0-9_]*)", + "captures": { + "1": { "name": "keyword.declaration.signature.osprey-ml" }, + "2": { "name": "entity.name.type.interface.osprey-ml" } + } + }, + { + "name": "meta.import.osprey-ml", + "match": "^\\s*(import)\\s+(\\\"(?:\\\\.|[^\\\"\\\\])*\\\"|[a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z_][a-zA-Z0-9_]*)*)(?:\\s+(as)\\s+([a-zA-Z_][a-zA-Z0-9_]*))?", + "captures": { + "1": { "name": "keyword.control.import.osprey-ml" }, + "2": { "name": "entity.name.type.module.osprey-ml" }, + "3": { "name": "keyword.control.import.alias.osprey-ml" }, + "4": { "name": "entity.name.namespace.alias.osprey-ml" } + } + }, + { + "name": "meta.export.declaration.osprey-ml", + "match": "^\\s*(export)\\b", + "captures": { + "1": { "name": "storage.modifier.export.osprey-ml" } + } + }, + { + "name": "meta.path.qualified.osprey-ml", + "match": "\\b[a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z_][a-zA-Z0-9_]*)+\\b", + "captures": { + "0": { "name": "entity.name.namespace.osprey-ml" } + } } ] }, @@ -176,6 +230,10 @@ }, "operators": { "patterns": [ + { + "name": "keyword.operator.qualifier.osprey-ml", + "match": "::" + }, { "name": "keyword.operator.mutation.osprey-ml", "match": ":=" diff --git a/vscode-extension/syntaxes/osprey.tmGrammar.json b/vscode-extension/syntaxes/osprey.tmGrammar.json index 75036530..9f76da11 100644 --- a/vscode-extension/syntaxes/osprey.tmGrammar.json +++ b/vscode-extension/syntaxes/osprey.tmGrammar.json @@ -59,7 +59,7 @@ }, { "name": "keyword.declaration.osprey", - "match": "\\b(fn|let|mut|type|import|extern|module)\\b" + "match": "\\b(fn|let|mut|type|import|extern|namespace|module|signature|export|opaque|state|as|extra)\\b" }, { "name": "keyword.fiber.osprey", @@ -181,15 +181,30 @@ }, "modules": { "patterns": [ + { + "name": "meta.namespace.declaration.osprey", + "match": "\\b(namespace)\\s+(\\\"(?:\\\\.|[^\\\"\\\\])*\\\"|[a-zA-Z_][a-zA-Z0-9_]*)", + "captures": { + "1": { + "name": "keyword.declaration.namespace.osprey" + }, + "2": { + "name": "entity.name.namespace.osprey" + } + } + }, { "name": "meta.module.declaration.osprey", - "begin": "\\b(module)\\s+([A-Z][a-zA-Z0-9_]*)\\s*\\{", + "begin": "\\b(?:(state)\\s+)?(module)\\s+([a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z_][a-zA-Z0-9_]*)*)(?:\\s*:\\s*[a-zA-Z_][a-zA-Z0-9_:]*(?:\\s*\\+\\s*extra)?)?\\s*\\{", "end": "\\}", "beginCaptures": { "1": { - "name": "keyword.declaration.module.osprey" + "name": "storage.modifier.state.osprey" }, "2": { + "name": "keyword.declaration.module.osprey" + }, + "3": { "name": "entity.name.type.module.osprey" } }, @@ -200,11 +215,50 @@ ] }, { - "name": "meta.module.access.osprey", - "match": "\\b([A-Z][a-zA-Z0-9_]*)\\.", + "name": "meta.signature.declaration.osprey", + "begin": "\\b(signature)\\s+([A-Z][a-zA-Z0-9_]*)\\s*\\{", + "end": "\\}", + "beginCaptures": { + "1": { + "name": "keyword.declaration.signature.osprey" + }, + "2": { + "name": "entity.name.type.interface.osprey" + } + }, + "patterns": [ + { + "include": "source.osprey" + } + ] + }, + { + "name": "meta.import.osprey", + "match": "\\b(import)\\s+(\\\"(?:\\\\.|[^\\\"\\\\])*\\\"|[a-zA-Z_][a-zA-Z0-9_]*(?:(?:::|\\.)[a-zA-Z_][a-zA-Z0-9_]*)*)(?:(::)(\\*|\\{[^}]*\\}))?(?:\\s+(as)\\s+([a-zA-Z_][a-zA-Z0-9_]*))?", "captures": { "1": { + "name": "keyword.control.import.osprey" + }, + "2": { "name": "entity.name.type.module.osprey" + }, + "3": { + "name": "keyword.operator.qualifier.osprey" + }, + "5": { + "name": "keyword.control.import.alias.osprey" + }, + "6": { + "name": "entity.name.namespace.alias.osprey" + } + } + }, + { + "name": "meta.path.qualified.osprey", + "match": "\\b[a-zA-Z_][a-zA-Z0-9_]*(?:::[a-zA-Z_][a-zA-Z0-9_]*)+\\b", + "captures": { + "0": { + "name": "entity.name.namespace.osprey" } } } @@ -263,6 +317,10 @@ }, "operators": { "patterns": [ + { + "name": "keyword.operator.qualifier.osprey", + "match": "::" + }, { "name": "keyword.operator.arrow.osprey", "match": "=>" diff --git a/website/package.json b/website/package.json index 62dba239..c308c2fb 100644 --- a/website/package.json +++ b/website/package.json @@ -6,7 +6,7 @@ "scripts": { "start": "npm run update-playground && npm run copy-spec && npm run generate-docs && eleventy --serve", "dev": "npm run update-playground && npm run copy-spec && npm run generate-docs && eleventy --serve --watch", - "build": "npm run update-playground && npm run generate-docs && eleventy", + "build": "npm run update-playground && npm run copy-spec && npm run generate-docs && eleventy", "copy-spec": "node scripts/copy-spec.js", "generate-docs": "bash scripts/generate-docs.sh && npm run add-ml-twins", "add-ml-twins": "python3 scripts/add-ml-twins.py", diff --git a/website/src/spec/0001-introduction.md b/website/src/spec/0001-introduction.md index 285b53f6..5f7a7deb 100644 --- a/website/src/spec/0001-introduction.md +++ b/website/src/spec/0001-introduction.md @@ -2,7 +2,7 @@ layout: page title: "Introduction" description: "Osprey Language Specification: Introduction" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0001-introduction/" diff --git a/website/src/spec/0002-lexicalstructure.md b/website/src/spec/0002-lexicalstructure.md index 8e1a09e7..2d0d8fb7 100644 --- a/website/src/spec/0002-lexicalstructure.md +++ b/website/src/spec/0002-lexicalstructure.md @@ -2,7 +2,7 @@ layout: page title: "Lexical Structure" description: "Osprey Language Specification: Lexical Structure" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0002-lexicalstructure/" @@ -29,10 +29,16 @@ ID := [a-zA-Z_][a-zA-Z0-9_]* ``` fn let mut type match extern import module where -effect perform handle in +effect perform handle in resume spawn await yield select ``` +**Contextual keywords.** `out` and `in` mark variance inside a +type-parameter list only (`type Source`, `effect Emit` — +[TYPE-VARIANCE-DECL](/spec/0004-typesystem/#generics-and-variance)). `out` is an +ordinary identifier everywhere else; `in` remains the hard keyword of +`handle … in` and is merely *accepted* in type-parameter position. + ## Literals ### Integer Literals diff --git a/website/src/spec/0003-syntax.md b/website/src/spec/0003-syntax.md index d60c3e2d..710cf084 100644 --- a/website/src/spec/0003-syntax.md +++ b/website/src/spec/0003-syntax.md @@ -2,7 +2,7 @@ layout: page title: "Syntax" description: "Osprey Language Specification: Syntax" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0003-syntax/" @@ -100,12 +100,21 @@ result = calculateValue data ## Function Declarations ```ebnf -fnDecl ::= docComment? "fn" ID "(" paramList? ")" ("->" type)? effectSet? +fnDecl ::= docComment? "fn" ID ("<" typeParamList ">")? "(" paramList? ")" + ("->" type)? effectSet? ("=" expr | "{" blockBody "}") paramList ::= param ("," param)* param ::= ID (":" type)? +effectSet ::= "!" effectRef | "!" "[" effectRef ("," effectRef)* "]" +effectRef ::= ID ("<" typeList ">")? ``` +The optional `` declares the function's type parameters +([TYPE-GENERICS-FN](/spec/0004-typesystem/#generics-and-variance)); variance +markers are not permitted there. `effectSet` is the declared effect row — +each reference may apply type arguments to a generic effect +([EFFECTS-GENERIC-ROWS](/spec/0017-algebraiceffects/#generic-effects)). + ```osprey fn double(x) = x * 2 fn add(x, y) = x + y @@ -166,6 +175,8 @@ The foreign function must use the C ABI (`extern "C"` and `#[no_mangle]` in Rust ```ebnf typeDecl ::= docComment? "type" ID ("<" typeParamList ">")? "=" (unionType | recordType) +typeParamList ::= typeParam ("," typeParam)* +typeParam ::= ("in" | "out")? ID unionType ::= variant ("|" variant)* recordType ::= "{" fieldDeclarations "}" variant ::= ID ("{" fieldDeclarations "}")? @@ -174,11 +185,20 @@ fieldDeclaration ::= ID ":" type constraint? constraint ::= "where" function_name ``` +`typeParam`'s optional `in`/`out` marker declares the parameter's variance +([TYPE-VARIANCE-DECL](/spec/0004-typesystem/#generics-and-variance)); `in` and +`out` are contextual keywords reserved only inside `<…>` +([Lexical Structure](/spec/0002-lexicalstructure/#keywords)). + ```osprey type Color = Red | Green | Blue type Shape = Circle { radius: int } | Rectangle { width: int, height: int } + +type Pair = Pair { first: T, second: U } +type Feed = Feed { supply: T } | Dry +type Gate = Gate { admit: (T) -> bool } | Open ``` ```osprey-ml @@ -357,7 +377,9 @@ label = Done code => "done (${code})" ``` -Pattern semantics, exhaustiveness, and the ternary shorthand are in [Pattern Matching](/spec/0007-patternmatching/). +Pattern semantics, exhaustiveness, and the two-arm shorthands — the ternary +and the Default-flavor `if`/`else if`/`else` expression ([GRAMMAR-IF-ELSE]) — +are in [Pattern Matching](/spec/0007-patternmatching/). ## Variable Binding diff --git a/website/src/spec/0004-typesystem.md b/website/src/spec/0004-typesystem.md index 4e36a18e..c56f7eec 100644 --- a/website/src/spec/0004-typesystem.md +++ b/website/src/spec/0004-typesystem.md @@ -2,7 +2,7 @@ layout: page title: "Type System" description: "Osprey Language Specification: Type System" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0004-typesystem/" @@ -11,6 +11,7 @@ permalink: "/spec/0004-typesystem/" # Type System - [Hindley-Milner Inference](#hindley-milner-inference) +- [Generics and Variance](#generics-and-variance) - [Built-in Types](#built-in-types) - [Result Auto-Unwrapping](#result-auto-unwrapping) - [Function Types](#function-types) @@ -75,6 +76,12 @@ map (`{}` at an ambiguous position, [TYPE-MAP](#map-k-v--type-map)); an `extern` boundary; an unconstrained polymorphic variable a caller must pin; or a return type that is *load-bearing* because it forces `Result` to auto-unwrap to `T` at the function boundary ([Result Auto-Unwrapping](#result-auto-unwrapping)). +Declared type-parameter binders (`fn pick(…)`, `type Source`, +`effect State`) are **declaration sites, not inference sites** — a binder +introduces the parameter the annotations refer to (and carries its variance), +so it is never redundant where the parameter is actually used +([Generics and Variance](#generics-and-variance)); a binder whose parameter +appears nowhere in the signature IS redundant and must go. Record and union field declarations (`type Point = { x: int, y: int }`, `Circle { radius: int }`) are **definition sites, not inference sites** — their `field: Type` annotations *define* the type and are always required, never @@ -115,6 +122,103 @@ unify(R1, R2) := Inference produces polymorphic variables (``, ``, …), not `any`. The `any` type is opt-in; see [The `any` Type](#the-any-type). +## Generics and Variance + +> **Flavor layer — shared core.** Both surfaces lower to the same +> variance-carrying `TypeParam` nodes ([FLAVOR-BOUNDARY]); the ML spellings are +> specified in [ML Flavor Syntax](/spec/0024-mlflavorsyntax/#generics-flavor-ml-generics). + +`[TYPE-GENERICS-DECL]` **Type declarations bind type parameters; constructions +may pin them explicitly.** `type Pair = …` binds `T`/`U` across every +variant field. A construction site may apply explicit type arguments — +`Pair { first: 1, second: "a" }` — which unify with the +instantiation the fields would otherwise infer; an argument that contradicts a +field is a type error. Explicit construction arguments follow +[TYPE-NO-REDUNDANT-ANNOTATION]: write them only when the fields alone cannot +pin the instantiation. + +`[TYPE-GENERICS-FN]` **Functions bind type parameters with `fn name`.** +A binder makes every use of `T` in the signature the SAME inference variable; +without it, `T` in an annotation names a nominal type. The binder is +load-bearing exactly when a parameter must relate two or more positions +(`fn pick(first: T, second: T)` pins both arguments to one type) or when a +caller must pin an otherwise-unconstrained variable. HM inference is +unchanged: unannotated functions stay implicitly polymorphic, and a +polymorphic function is still monomorphised independently at each call site. +Variance markers are **not** permitted on function binders (variance is +declaration-site on types and effects only — [TYPE-VARIANCE-DECL]). + +```osprey +fn pick(first: T, second: T) = first +let n = pick(10, 20) +let s = pick("left", "right") +``` + +```osprey-ml +pick : (T, T) -> T +pick (first, second) = first +n = pick (10, 20) +s = pick ("left", "right") +``` + +In the ML flavor the binder lives on the signature line (`pick : …`); a +binding without a signature cannot declare type parameters. + +`[TYPE-VARIANCE-DECL]` **Type parameters declare variance at the declaration +site**: `out T` (covariant — `T` only flows out), `in T` (contravariant — `T` +only flows in), unannotated (invariant — exact match). `out` and `in` are +contextual keywords, reserved only inside type-parameter lists +([Lexical Structure](/spec/0002-lexicalstructure/#keywords)). + +```osprey +type Feed = Feed { supply: T } | Dry +type Gate = Gate { admit: (T) -> bool } | Open +``` + +```osprey-ml +type Feed out T = + Feed + supply : T + Dry +type Gate in T = + Gate + admit : T -> bool + Open +``` + +`[TYPE-VARIANCE-POSITIONS]` **Variance is position-checked.** Walking a +declaration's field (or effect-operation) types: fields and function results +are OUTPUT positions; function parameters flip the polarity (INPUT); a nested +constructor's argument composes the position with that constructor's declared +variance (an invariant argument position demands both directions, so only +invariant parameters may sit there). A covariant parameter in an input +position, or a contravariant parameter in an output position, is a compile +error. Effect operations check the same way: operation parameters are inputs, +operation results outputs ([Algebraic Effects](/spec/0017-algebraiceffects/#generic-effects)). + +`[TYPE-VARIANCE-ASSIGN]` **Variance directs assignability structurally, and +the leaves match exactly.** Plain HM unification is untouched — every +well-typed expression keeps a principal type. At *assignment sites* (call +arguments, annotated bindings, return positions), a variance-declared +constructor's arguments are matched directionally: covariant (`out`) +arguments recurse expected-accepts-actual, contravariant (`in`) arguments +recurse with the roles flipped, invariant arguments unify exactly. The +recursion continues only through variance-declared constructors and bottoms +out in **exact unification** — the coercive +[Result auto-unwrap](#result-auto-unwrapping) never applies under a +container, because it is a representation-changing coercion the compiler +emits only at direct value sites; admitting it inside a payload would accept +values whose stored representation is wrong. Function-typed payloads keep +their flexibility representation-safely: unification itself normalizes +function returns through `Result` (the function-value ABI strips the +wrapper), so a `Feed<(int) -> Result>` matches a +`Feed<(int) -> int)` slot. + +Built-in constructors' declared variance: `Result`, +`List`, `Fiber`, `Map` (keys invariant); `Channel` +and `Ptr` are invariant. Function types are structurally contravariant in +parameters and covariant in returns, as before. + ## Built-in Types All primitive types are lowercase. diff --git a/website/src/spec/0005-functioncalls.md b/website/src/spec/0005-functioncalls.md index 83be26ca..2948e63b 100644 --- a/website/src/spec/0005-functioncalls.md +++ b/website/src/spec/0005-functioncalls.md @@ -2,7 +2,7 @@ layout: page title: "Function Calls" description: "Osprey Language Specification: Function Calls" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0005-functioncalls/" diff --git a/website/src/spec/0006-stringinterpolation.md b/website/src/spec/0006-stringinterpolation.md index 53ef6ebb..34ca97fc 100644 --- a/website/src/spec/0006-stringinterpolation.md +++ b/website/src/spec/0006-stringinterpolation.md @@ -2,7 +2,7 @@ layout: page title: "String Interpolation" description: "Osprey Language Specification: String Interpolation" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0006-stringinterpolation/" diff --git a/website/src/spec/0007-patternmatching.md b/website/src/spec/0007-patternmatching.md index 8e39215b..e73e2684 100644 --- a/website/src/spec/0007-patternmatching.md +++ b/website/src/spec/0007-patternmatching.md @@ -2,7 +2,7 @@ layout: page title: "Pattern Matching" description: "Osprey Language Specification: Pattern Matching" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0007-patternmatching/" @@ -10,7 +10,11 @@ permalink: "/spec/0007-patternmatching/" # Pattern Matching -`match` is the only branching construct in Osprey. Record patterns are matched structurally by field name, not by field order. See [Type System](/spec/0004-typesystem/) for type unification rules. +`match` is the only branching construct in Osprey's canonical AST — every +surface conditional (the ternary, `?:`, and the Default flavor's +`if`/`else` [GRAMMAR-IF-ELSE]) desugars to it at lowering. Record patterns +are matched structurally by field name, not by field order. See +[Type System](/spec/0004-typesystem/) for type unification rules. > **Flavor layer — mixed.** A `match` lowers to `Expr::Match` over `MatchArm`s, each carrying a `Pattern` (`Wildcard`, `Literal`, `Constructor { name, fields, sub_patterns }`, `TypeAnnotated`, `Structural`, `List`, `Binding`). Only the *spelling* of these patterns is a surface (CST) concern: this chapter shows the Default flavor — a one-field variant is `Success { value }`, where the ML flavor writes `Success value` ([`[FLAVOR-ML-MATCH]`](/spec/0024-mlflavorsyntax/#match)) — but both flavors lower to the **same** `Pattern::Constructor { name, fields }`. Everything else here — exhaustiveness checking, `any`/union narrowing, and arm semantics — is shared-core: it runs on the canonical AST and is flavor-blind ([`[FLAVOR-BOUNDARY]`](/spec/0023-languageflavors/#the-one-law)). See [Language Flavors](/spec/0023-languageflavors/) and [ML Flavor Syntax](/spec/0024-mlflavorsyntax/). @@ -213,4 +217,46 @@ status = match isActive true => "Active" false => "Inactive" +``` + +## if / else (Syntactic Sugar) [GRAMMAR-IF-ELSE] + +The Default flavor also spells the boolean two-arm match the way mainstream +languages do. `if` is an **expression** — it always yields a value, so the +`else` branch is mandatory and each branch is a single expression in braces: + +```ebnf +if_expr ::= "if" expr "{" expr "}" "else" ( "{" expr "}" | if_expr ) +``` + +```osprey +fn tier(score) = if score >= 2000 { Epic } else if score >= 500 { Solid } else { Starter } +``` + +Desugars to the boolean match — no new AST node crosses the +[FLAVOR-BOUNDARY], so it emits IR byte-identical to the explicit form: + +```osprey +fn tier(score) = match score >= 2000 { + true => Epic + false => match score >= 500 { + true => Solid + false => Starter + } +} +``` + +`else if` is simply a nested `if` expression in the `else` position, giving +flat multi-way chains without indentation creep. An `if` with no `else` is a +parse error — there is no value for the false path +(`examples/failscompilation/if_without_else.ospo`). + +The ML flavor deliberately omits `if`/`else`: it writes the `match` directly. + +```osprey-ml +tier score = match score >= 2000 + true => Epic + false => match score >= 500 + true => Solid + false => Starter ``` \ No newline at end of file diff --git a/website/src/spec/0008-blockexpressions.md b/website/src/spec/0008-blockexpressions.md index 2c072558..ff60b409 100644 --- a/website/src/spec/0008-blockexpressions.md +++ b/website/src/spec/0008-blockexpressions.md @@ -2,7 +2,7 @@ layout: page title: "Block Expressions" description: "Osprey Language Specification: Block Expressions" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0008-blockexpressions/" diff --git a/website/src/spec/0009-booleanoperations.md b/website/src/spec/0009-booleanoperations.md index 70179805..bba4c3f8 100644 --- a/website/src/spec/0009-booleanoperations.md +++ b/website/src/spec/0009-booleanoperations.md @@ -2,7 +2,7 @@ layout: page title: "Boolean Operations" description: "Osprey Language Specification: Boolean Operations" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0009-booleanoperations/" diff --git a/website/src/spec/0010-loopconstructsandfunctionaliterators.md b/website/src/spec/0010-loopconstructsandfunctionaliterators.md index 22aa8cef..ab555235 100644 --- a/website/src/spec/0010-loopconstructsandfunctionaliterators.md +++ b/website/src/spec/0010-loopconstructsandfunctionaliterators.md @@ -2,7 +2,7 @@ layout: page title: "Iterators and Iteration" description: "Osprey Language Specification: Iterators and Iteration" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0010-loopconstructsandfunctionaliterators/" diff --git a/website/src/spec/0011-lightweightfibersandconcurrency.md b/website/src/spec/0011-lightweightfibersandconcurrency.md index bc83c6a9..53b619bc 100644 --- a/website/src/spec/0011-lightweightfibersandconcurrency.md +++ b/website/src/spec/0011-lightweightfibersandconcurrency.md @@ -2,7 +2,7 @@ layout: page title: "Fibers and Concurrency" description: "Osprey Language Specification: Fibers and Concurrency" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0011-lightweightfibersandconcurrency/" diff --git a/website/src/spec/0012-built-infunctions.md b/website/src/spec/0012-built-infunctions.md index 67db84a8..013ef2ed 100644 --- a/website/src/spec/0012-built-infunctions.md +++ b/website/src/spec/0012-built-infunctions.md @@ -2,7 +2,7 @@ layout: page title: "Built-in Functions" description: "Osprey Language Specification: Built-in Functions" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0012-built-infunctions/" diff --git a/website/src/spec/0013-errorhandling.md b/website/src/spec/0013-errorhandling.md index 25239fe4..fa8486c3 100644 --- a/website/src/spec/0013-errorhandling.md +++ b/website/src/spec/0013-errorhandling.md @@ -2,7 +2,7 @@ layout: page title: "Error Handling" description: "Osprey Language Specification: Error Handling" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0013-errorhandling/" diff --git a/website/src/spec/0014-http.md b/website/src/spec/0014-http.md index 6b3ff8b6..f306e678 100644 --- a/website/src/spec/0014-http.md +++ b/website/src/spec/0014-http.md @@ -2,7 +2,7 @@ layout: page title: "HTTP" description: "Osprey Language Specification: HTTP" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0014-http/" diff --git a/website/src/spec/0015-websockets.md b/website/src/spec/0015-websockets.md index aad72f41..3891e109 100644 --- a/website/src/spec/0015-websockets.md +++ b/website/src/spec/0015-websockets.md @@ -2,7 +2,7 @@ layout: page title: "WebSockets" description: "Osprey Language Specification: WebSockets" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0015-websockets/" diff --git a/website/src/spec/0016-securityandsandboxing.md b/website/src/spec/0016-securityandsandboxing.md index 74c567d1..6ba6a68a 100644 --- a/website/src/spec/0016-securityandsandboxing.md +++ b/website/src/spec/0016-securityandsandboxing.md @@ -2,7 +2,7 @@ layout: page title: "Security and Sandboxing" description: "Osprey Language Specification: Security and Sandboxing" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0016-securityandsandboxing/" diff --git a/website/src/spec/0017-algebraiceffects.md b/website/src/spec/0017-algebraiceffects.md index 1c6f0848..30f22914 100644 --- a/website/src/spec/0017-algebraiceffects.md +++ b/website/src/spec/0017-algebraiceffects.md @@ -2,7 +2,7 @@ layout: page title: "Algebraic Effects" description: "Osprey Language Specification: Algebraic Effects" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0017-algebraiceffects/" @@ -21,7 +21,9 @@ Effect declarations, `perform` expressions, effect annotations on function types - **Implicit tail-resume.** An arm whose body is an ordinary expression returns that value to the `perform` site, which continues. This is the cheap default and handlers may own mutable state with it (see [Handler-Owned State]). - **Explicit `resume`.** An arm whose body contains a `resume` expression captures the performer's *delimited continuation*: `resume(v)` runs the rest of the handled computation with `v` as the operation's result and yields its answer back to the arm, so the arm can run code **after** the performer continues. Single-shot (each continuation is resumed at most once) and **deep** (the handler stays installed for the resumed computation). See [Resuming Handlers]. **Status: executable for single-shot deep continuations via the thread-as-continuation runtime in [plan 0008](https://github.com/Nimblesite/osprey/blob/main/docs/plans/0008-algebraic-effects-resume.md).** -Multi-shot resume (resuming one continuation more than once) remains a follow-up. +Multi-shot resume (resuming one continuation more than once) is **rejected at +runtime** with a clear fatal message rather than silently returning a wrong +answer; a multi-shot-capable runtime remains a follow-up ([plan 0016](https://github.com/Nimblesite/osprey/blob/main/docs/plans/0016-algebraic-effects-and-handlers.md) §Phase A). ## Keywords @@ -32,10 +34,13 @@ effect perform handle in resume ## Effect Declarations ```ebnf -effectDecl ::= docComment? "effect" IDENT "{" opDecl* "}" +effectDecl ::= docComment? "effect" IDENT ("<" typeParamList ">")? "{" opDecl* "}" opDecl ::= IDENT ":" fnType ``` +`typeParamList` is the shared production from [Syntax](/spec/0003-syntax/#type-declarations) +— effects accept type parameters (with variance) exactly as type declarations do. + ```osprey effect State { get : fn() -> int @@ -49,9 +54,98 @@ effect State set : int => unit ``` +### Generic Effects + +`[EFFECTS-GENERIC-DECL]` **Effects accept type arguments for full +polymorphism.** `effect State` binds `T` across every operation signature; +one declaration serves every instantiation. Type parameters may carry variance +(`effect Ask`, `effect Emit`), position-checked against the +operation signatures: operation parameters are input positions, operation +results output positions ([TYPE-VARIANCE-POSITIONS](/spec/0004-typesystem/#generics-and-variance)). + +```osprey +effect Stash { + put : fn(T) -> Unit + take : fn() -> T +} +``` + +```osprey-ml +effect Stash T + put : T => Unit + take : Unit => T +``` + +`[EFFECTS-GENERIC-INSTANTIATION]` **Each `handle` site and each effect-row +entry instantiates the effect independently.** A handler's arms pin its +instantiation: a non-resuming arm's value substitutes for the operation's +result, so `take => "stash-words"` pins `Stash` (an arm handling a +`Unit`-resulted operation may yield anything — the value is discarded). Inside +the handled body, `perform` sites resolve against the innermost enclosing +instantiation of their effect, matching the runtime's innermost-wins handler +stack; inside a function, the declared effect row provides the instantiation. +Two instantiations of one effect coexist in one program: + +```osprey +let words = handle Stash + take => "stash-words" + put v => print("put: ${v}") +in relabel() +let count = handle Stash + take => 41 + put v => print("put: ${v}") +in bumped() +``` + +`[EFFECTS-GENERIC-ROWS]` **Effect rows carry type arguments.** A row entry +`!State` (or `![State, Log]`) pins the instantiation the function's +`perform` sites check against; performing an operation with arguments that +contradict the row is a compile error. A bare row entry on a generic effect +leaves the instantiation to inference. The row is the function's declared +interface to its dynamically-scoped handler: the checker verifies each side +against its declared instantiation independently (it does not globally prove +that every runtime handler matches every performer's row) — the runtime's +instantiation-keyed dispatch ([EFFECTS-GENERIC-RUNTIME]) is what turns a +handler/row mismatch into a loud unhandled-effect abort instead of undefined +behaviour. + +```osprey +fn bumped() -> int !Stash = { + let n = perform Stash.take() + n + 1 +} +``` + +```osprey-ml +bumped : Unit -> int ! Stash +bumped () = + n = perform Stash.take () + n + 1 +``` + +`[EFFECTS-GENERIC-RUNTIME]` **Instantiations are erased in the ABI and keyed +in dispatch.** A generic effect's operations keep ONE ABI program-wide: every +type-parameter-mentioning slot travels as a uniform boxed machine word, boxed +at `perform` sites and unboxed at handler-arm entry (and inversely for +results) against the signature inference resolved per site. Handlers +register on the runtime stack under their RESOLVED instantiation +(`Stash$int`), and `perform` sites look up under theirs — so a handler only +satisfies performs of the same instantiation, and the innermost +same-instantiation handler wins. A mismatch (or an instantiation the checker +could not resolve at a site) misses the lookup and aborts loudly with +`unhandled effect: …`, never confusing values of different types. +Monomorphic effects keep their bare names — their programs compile +byte-identically to before. The C runtime treats keys as opaque strings and +needs no changes. + ## Effectful Function Types -A function declares the effects it may perform with `!E` after its return type. `E` is either a single effect or a bracketed set. +A function declares the effects it may perform with `!E` after its return type. `E` is either a single effect reference or a bracketed set; each reference may apply type arguments to a generic effect (`!State`, `![State, Log]` — [EFFECTS-GENERIC-ROWS](#generic-effects)). + +```ebnf +effectSet ::= "!" effectRef | "!" "[" effectRef ("," effectRef)* "]" +effectRef ::= IDENT ("<" typeList ">")? +``` ```osprey fn read() -> string !IO = perform IO.readLine() @@ -212,13 +306,28 @@ Semantics: - **Deep.** The handler stays installed for the resumed computation: if the continuation performs the effect again, the same arm runs again. -- **Single-shot.** Each continuation is resumed at most once. Multi-shot resume - remains a follow-up. +- **Single-shot.** Each continuation is resumed at most once. Resuming an + already-consumed continuation (multi-shot) is **rejected at runtime** with + `fatal: continuation already resumed (multi-shot resume is not supported)` + and a nonzero exit — the thread-as-continuation model cannot re-run a + completed stack, and a loud abort beats silently returning the stale first + result. A multi-shot-capable runtime remains a follow-up + ([plan 0016](https://github.com/Nimblesite/osprey/blob/main/docs/plans/0016-algebraic-effects-and-handlers.md) §Phase A). - **Abort.** An arm that returns *without* resuming discards the continuation; its value becomes the result of the whole `handle … in` — the basis for exceptions and early exit. - An arm whose body is a plain value (no `resume`) is the implicit tail-resume of [Handler-Owned State]; the two styles coexist per effect. +- **Serialized concurrent performs [EFFECTS-FIBER-PERFORM].** Fibers spawned + inside the handled body may perform into the same resuming handler + concurrently; each perform claims the handler's operation channel + exclusively for its full suspend→resume round-trip, and queued performs are + dispatched in turn. Answers are therefore deterministic per performer — + never interleaved or cross-delivered. +- **`resume` is lexical to the arm.** A lambda written inside an arm runs when + *called*, not where it is written, so the arm's continuation is not live + inside it: `resume` inside a lambda body is a **type error** (`` `resume` is + only valid inside a handler arm ``), exactly as at top level. ```osprey effect Audit { step: fn(string) -> int } @@ -314,6 +423,13 @@ The compiler enforces three static checks on effect programs. Each failure is a | No circular effect dependency | Stack overflow | | No handler that performs the same effect it handles | Infinite loop | +> **Status — enforcement is at runtime today.** This section specifies the +> designed state. In the current Rust compiler the first two checks are +> enforced by a **runtime abort** (`unhandled effect: .`, nonzero +> exit) rather than a compile error, and the self-performing-handler check is +> not yet enforced. The compile-time checks land with effect rows on function +> types — [plan 0016 §Phase C](https://github.com/Nimblesite/osprey/blob/main/docs/plans/0016-algebraic-effects-and-handlers.md). + ### Circular Dependency Example ```osprey diff --git a/website/src/spec/0018-memorymanagement.md b/website/src/spec/0018-memorymanagement.md index bd2d3427..116efe23 100644 --- a/website/src/spec/0018-memorymanagement.md +++ b/website/src/spec/0018-memorymanagement.md @@ -2,7 +2,7 @@ layout: page title: "Memory Management" description: "Osprey Language Specification: Memory Management" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0018-memorymanagement/" diff --git a/website/src/spec/0019-foreignfunctioninterface.md b/website/src/spec/0019-foreignfunctioninterface.md index 9e5a298a..91631f39 100644 --- a/website/src/spec/0019-foreignfunctioninterface.md +++ b/website/src/spec/0019-foreignfunctioninterface.md @@ -2,7 +2,7 @@ layout: page title: "Foreign Function Interface" description: "Osprey Language Specification: Foreign Function Interface" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0019-foreignfunctioninterface/" diff --git a/website/src/spec/0020-languageserverandeditors.md b/website/src/spec/0020-languageserverandeditors.md index feacb5c1..6f376acc 100644 --- a/website/src/spec/0020-languageserverandeditors.md +++ b/website/src/spec/0020-languageserverandeditors.md @@ -2,7 +2,7 @@ layout: page title: "Language Server & Editor Integrations" description: "Osprey Language Specification: Language Server & Editor Integrations" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0020-languageserverandeditors/" @@ -278,16 +278,13 @@ Every binding is hoverable, not just top-level declarations: ### Documentation comments `[LSP-HOVER-DOCS]` -A binding can be documented exactly like a function. A `///` documentation -comment immediately above any declaration — `fn` **or** `let`/`mut` — is captured -by the grammar (a `doc_comment` node, distinct from a `//` line comment), -lowered onto the AST node's `doc` field, and rendered in hover as prose beneath -the signature/type line. This is the same path functions already used; the -feature is that **variables get it too**, satisfying "document variables like we -can document functions". The grammar attaches `optional($.doc_comment)` to the -declaration forms in [`tree-sitter-osprey/grammar.js`](https://github.com/Nimblesite/osprey/blob/main/tree-sitter-osprey/grammar.js); -lowering lives in [`osprey-syntax/src/lower.rs`](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-syntax/src/lower.rs) -(`doc_text`). +Every declaration form can be documented — `fn`, `let`/`mut`, `type`, `effect`, +`extern`, and `module` — in **both flavors** (`///` in Default, `(** … *)` in +ML). The doc comment is lowered into the structured +[`DocComment`](/spec/0026-documentationcomments/) on the AST node's `doc` field, and +hover renders it as Markdown (summary, body, then recognised sections) beneath +the signature/type line. See [Documentation Comments](/spec/0026-documentationcomments/) +for the full model, sigils, sections, and body markup. ```osprey /// The greeting shown to the operator on connect. @@ -297,6 +294,14 @@ let banner = "hello" Hovering `banner` shows `banner: string` followed by _"The greeting shown to the operator on connect."_ +**Doc-link hover `[DOC-LINK]`.** A `[Symbol]` intra-doc link inside a doc +comment is itself hoverable: putting the cursor on `[helper]` or +`[Console.emit]` shows the referenced declaration's own hover. Rendering lives +in [`osprey-lsp/src/features.rs`](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-lsp/src/features.rs) +(`doc_link_target` / `resolve_link`); doc capture lives in +[`osprey-syntax/src/docparse.rs`](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-syntax/src/docparse.rs) +and each flavor's lowerer. + ## Position encoding `[LSP-ENCODING]` The server negotiates `positionEncoding` at `initialize` (default **UTF-16**). diff --git a/website/src/spec/0021-debugger.md b/website/src/spec/0021-debugger.md index 6bd292a4..689ff27d 100644 --- a/website/src/spec/0021-debugger.md +++ b/website/src/spec/0021-debugger.md @@ -2,7 +2,7 @@ layout: page title: "Debugger" description: "Osprey Language Specification: Debugger" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0021-debugger/" diff --git a/website/src/spec/0022-webassemblytarget.md b/website/src/spec/0022-webassemblytarget.md index 166b53c2..83c51d16 100644 --- a/website/src/spec/0022-webassemblytarget.md +++ b/website/src/spec/0022-webassemblytarget.md @@ -2,7 +2,7 @@ layout: page title: "WebAssembly Target" description: "Osprey Language Specification: WebAssembly Target" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0022-webassemblytarget/" diff --git a/website/src/spec/0023-languageflavors.md b/website/src/spec/0023-languageflavors.md index 4171a362..da757c4d 100644 --- a/website/src/spec/0023-languageflavors.md +++ b/website/src/spec/0023-languageflavors.md @@ -2,7 +2,7 @@ layout: page title: "Language Flavors" description: "Osprey Language Specification: Language Flavors" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0023-languageflavors/" @@ -289,6 +289,11 @@ Default flat multi-parameter vs ML curried/nested chain. See | Record construction | `T { f: v }` | `T` + indented `f = v` | `Expr::TypeConstructor` | | Record update | `r { f: v }` | layout update | `Expr::Update` | | Effect declaration | `effect E { op: fn(T)->U }` | `effect E` + `op : T => U` | `Stmt::Effect` + `EffectOperation` | +| Generic type params | `type Box` / `type Feed` | `type Box T` / `type Feed out T` | `Stmt::Type { type_params: Vec }` | +| Fn type params | `fn pick(a: T, b: T)` | `pick : (T, T) -> T` + binding | `Stmt::Function { type_params }` | +| Generic effect | `effect Stash { … }` | `effect Stash T` + ops | `Stmt::Effect { type_params }` | +| Effect row w/ args | `!Stash` / `![A, B]` | `! Stash` / `! [A, B]` | `Stmt::Function { effects: Vec }` | +| Ctor type args | `Box { item: 7 }` | `Box(item = 7)` | `Expr::TypeConstructor { type_args }` | | Perform | `perform E.op(a)` | `perform E.op a` | `Expr::Perform` | † See [Currying Canonicalisation](#currying-canonicalisation): Default @@ -569,12 +574,25 @@ is a single language — one type checker, one effect system, one runtime, one standard library, one backend — fronted by two **first-class, permanent** syntaxes. Neither surface is the diluted one. -- **Default flavor (`.osp`)** — C-style braces, `fn`, `f(x: a, y: b)` calls with - named arguments. The surface a **systems programmer** reaches for: explicit, - familiar, block-structured. -- **ML flavor (`.ospml`)** — offside-rule layout, curry-by-default, whitespace - application `f a b`, `\x => e` lambdas, `:=` mutation. The surface an **FP - devotee** reaches for: terse, expression-first, ML/Haskell-shaped. +- **Default flavor (`.osp`)** — the **populist** surface. C-style braces, `fn`, + `f(x: a, y: b)` calls with named arguments, `if`/`else if`/`else` + ([GRAMMAR-IF-ELSE]), the `? :` ternary. It deliberately borrows shapes from + Kotlin, Swift, Go, Dart, C#, and Java **wherever that aids adoption**: a + mainstream developer should read a `.osp` file cold and follow it. Every such + convenience is pure surface — it desugars at lowering, never adding AST. +- **ML flavor (`.ospml`)** — the **uncompromising** surface. Offside-rule + layout, curry-by-default, whitespace application `f a b`, `\x => e` lambdas, + `:=` mutation. It takes the most elegant constructs the ML family ever + produced and goes all the way: no braces, no C-isms, no concession to + mainstream familiarity. Populist sugar (e.g. `if`/`else`) is deliberately + **omitted** here — ML writes the `match` directly. + +**Strategy (2026-07, supersedes earlier "walk the line" framing).** The Default +flavor no longer balances adoption against ML purity — the two-flavor +architecture removes the need. Default optimizes for **accessibility** and +mainstream adoption; ML optimizes for **extreme elegance** with zero +compromise. Each flavor goes further in its own direction *because* the other +exists, and both still erase to the same canonical AST ([FLAVOR-BOUNDARY]). **The "no compromise" claim, stated precisely.** The ML flavor is *not* "braces optional" and the Default flavor is *not* a deprecated transitional dialect (see diff --git a/website/src/spec/0024-mlflavorsyntax.md b/website/src/spec/0024-mlflavorsyntax.md index 06cee2b4..cf7d9a96 100644 --- a/website/src/spec/0024-mlflavorsyntax.md +++ b/website/src/spec/0024-mlflavorsyntax.md @@ -2,7 +2,7 @@ layout: page title: "ML Flavor Syntax" description: "Osprey Language Specification: ML Flavor Syntax" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0024-mlflavorsyntax/" @@ -29,6 +29,7 @@ subordinate to that contract. Implementation is tracked in - [Bindings and Mutation](#bindings-and-mutation) - [Functions and Currying](#functions-and-currying) - [Function Calls](#function-calls) +- [Modules and Namespaces](#modules-and-namespaces) - [Effects](#effects) - [Handlers](#handlers) - [Match](#match) @@ -62,8 +63,13 @@ subordinate to that contract. Implementation is tracked in precedence-climbing) parser in [`crates/osprey-syntax/src/ml/`](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-syntax/src/ml/) (see [`[FLAVOR-ML-LAYOUT]`](#layout-model)). -- **Phase 0 — first-class handler values + effects: deferred.** ML - handler/effect syntax errors loudly until this shared-core feature lands. +- **Modules and namespaces: implemented.** File/block namespaces, layout + modules and signatures, concise state modules, explicit exports, layout + imports, and `::` symbol paths lower to the shared module AST specified by + [Modules and Namespaces](/spec/0025-modulesandnamespaces/). +- **First-class handler values: deferred.** ML effect declarations, + `perform`, and the existing fused `handle ... in ...` form are implemented; + only reusable handler values/installers await the shared-core feature. The parsing techniques and the offside rule are cited in the [References](#references) section. @@ -123,6 +129,27 @@ in the [References](#references) section. String interpolation keeps `${…}`. Parentheses remain available for grouping and precedence; they are not mandatory call punctuation. +## Comments + +`[FLAVOR-ML-COMMENTS]` The ML flavor has two ordinary comment forms and one +documentation form: + +- **`// …`** — a line comment to end of line. +- **`(* … *)`** — a block comment in the ML-family (SML/OCaml/F#) convention. + It **nests**, so a commented-out region containing another `(* *)` closes + correctly; an unterminated block comment is a lexical error. Layout ignores + comment content entirely (it is trivia the layout lexer skips). +- **`(** … *)`** — a **documentation comment** (the odoc double-star + convention), specified in + [Documentation Comments](/spec/0026-documentationcomments/) `[DOC-SIGIL-ML]`. It + attaches to the following declaration and lowers to the same `DocComment` the + Default flavor's `///` produces. An empty `(**)` or an all-star banner + `(*****)` is an ordinary comment, not a doc. + +The Default (brace) flavor's ordinary line comment is `//` and its doc comment +is `///` ([0026](/spec/0026-documentationcomments/) `[DOC-SIGIL-DEFAULT]`); the ML +block forms are the layout-flavor idiom for the same roles. + ## Bindings and Mutation `[FLAVOR-ML-BIND]` `=` **binds**, `:=` **mutates**. There is no `let`: a bare @@ -261,6 +288,127 @@ Lowering: whitespace application `f a b` → nested `Expr::Call`, one argument e `f(x: a, y: b)`); a single parenthesised expression `f (a)` is just grouping and lowers to `Call(f, [a])`. +## Modules and Namespaces + +`[FLAVOR-ML-MODULES]` Module semantics are defined by +[Modules and Namespaces](/spec/0025-modulesandnamespaces/). This section defines +only the ML projection: layout supplies every body boundary, `::` qualifies +logical symbols, and visibility is written exactly once. + +```ebnf +namespaceDecl ::= "namespace" namespaceName (INDENT item+ DEDENT)? +namespaceName ::= ID | STRING +moduleDecl ::= "module" symbolPath (":" symbolPath)? INDENT item+ DEDENT +stateDecl ::= "state" symbolPath (":" symbolPath)? INDENT item+ DEDENT +signatureDecl ::= "signature" ID INDENT signatureItem+ DEDENT +symbolPath ::= ID ("::" ID)* +``` + +A namespace header without an indented body is file-scoped. An indented body is +one block contribution to the open namespace: + +```osprey-ml +namespace billing + +module Tax + ... +``` + +```osprey-ml +namespace billing + module Tax + ... +``` + +A named signature is the whole public contract of an ascribed module. Signature +items are public by definition, and implementation declarations do not repeat +`export`: + +```osprey-ml +signature TaxApi + type Money + type Rate = int + addTax : Money -> Money + +module Tax : TaxApi + type Money = int + type Rate = int + + addTax cents = cents +``` + +In a signature, bare `type T` is abstract; `type T = R` is manifest. Writing +`opaque type T` there is redundant and rejected. An ascribed module exports +exactly its signature, so any explicit `export` inside it is also rejected. + +An un-ascribed module marks each public declaration group exactly once. The +inference-first form exports the definition directly; when a type contract is +genuinely load-bearing, an exported value signature transfers visibility to +the immediately following same-name bare definition: + +```osprey-ml +module Tax + defaultRate = 10 + + export addTax cents = + cents + cents * defaultRate / 100 + + export zero cents = cents + export opaque type UserId = int +``` + +Prefixing both a signature and its definition with `export` is an error, as is +an orphan signature. `export mut` is always an error: module-owned cells are +private. + +The state-owning form is deliberately `state Name`, never the redundant +`state module Name`: + +```osprey-ml +state Counter + mut count = 0 + + export effect CounterFx + read : Unit => int + + export run action = + handle CounterFx + read => count + in + action () +``` + +State never leaks through an ordinary accessor. `run` installs the capability; +the private cell is read only inside its handler arm. First-class exported +handler values will provide the still-cleaner factory form described in +[Handlers](#handlers) once that shared-core feature lands. + +Imports use the same logical targets as the shared model, but explicit member +selection is a layout list rather than Default's brace list: + +```ebnf +importDecl ::= "import" importTarget ("as" ID)? + | "import" importTarget INDENT importMember+ DEDENT + | "import" importTarget INDENT "*" DEDENT +importMember ::= ID ("as" ID)? +``` + +```osprey-ml +import billing::Tax +import billing::Tax as T +import billing::Tax + addTax + zero as noTax +import "billing/api" as api + +gross = T::addTax 100 +``` + +`::` is namespace/module/member qualification; `.` remains value field access. +Qualified whitespace application is still curried (`Tax::add 1 2`). Calling a +flat multi-parameter API uses the explicit uncurried form +`Tax::add (1, 2)`, matching Default `Tax::add(1, 2)`. + ## Effects `[FLAVOR-ML-EFFECT]` An effect declaration is a layout block of operation @@ -269,8 +417,9 @@ and currying type. An operation is a request with a **payload** and a **result** not a curried function. ```ebnf -effectDecl ::= "effect" ID INDENT opSig+ DEDENT +effectDecl ::= "effect" ID typeParam* INDENT opSig+ DEDENT opSig ::= ID ":" type "=>" type +typeParam ::= ("in" | "out")? ID ``` ```osprey-ml @@ -304,6 +453,51 @@ Lowering: `effect E` + arms → `Stmt::Effect { operations }`, where each > that yield a result: it appears in `effect` operations, `handler` arms, and > `match` arms, always meaning "the left yields the right." +## Generics ([FLAVOR-ML-GENERICS]) + +`[FLAVOR-ML-GENERICS]` The ML flavor spells every generic binder by +juxtaposition on declarations and by an angle-bracket binder on signatures — +all lowering to the same variance-carrying `TypeParam` nodes the Default +flavor produces ([TYPE-GENERICS-DECL], [TYPE-VARIANCE-DECL] in +[Type System](/spec/0004-typesystem/#generics-and-variance)): + +- **Type declarations** take whitespace parameters with optional variance + markers: `type Box T =`, `type Feed out T =`, `type Gate in T =` — twinning + Default `type Box`, `type Feed`, `type Gate`. +- **Effect declarations** likewise: `effect Stash T` twins + `effect Stash` ([EFFECTS-GENERIC-DECL](/spec/0017-algebraiceffects/#generic-effects)). +- **Function type parameters** bind on the signature line: + `pick : (T, T) -> T` twins `fn pick(first: T, second: T)`. A binding + without a signature cannot declare type parameters. Variance markers are + rejected on function binders. +- **Effect rows** apply type arguments with angle brackets: + `bumped : Unit -> int ! Stash` twins `fn bumped() -> int !Stash` + ([EFFECTS-GENERIC-ROWS](/spec/0017-algebraiceffects/#generic-effects)). +- **Construction sites** apply explicit type arguments on the inline record + form: `Box(item = 7)` twins `Box { item: 7 }` + ([TYPE-GENERICS-DECL](/spec/0004-typesystem/#generics-and-variance)). The + layout (indented) record form takes no type arguments — use the inline + form when the fields alone cannot pin the instantiation. + +```osprey-ml +type Feed out T = + Feed + supply : T + Dry + +effect Stash T + put : T => Unit + take : Unit => T + +pick : (T, T) -> T +pick (first, second) = first +``` + +`out` stays an ordinary identifier outside type-parameter position; `in` (the +hard keyword of `handle … in`) is accepted contextually inside a parameter +list. A generic signature is distinguished from a `name < expr` comparison by +requiring the whole `name :` shape before committing. + ## Handlers `[FLAVOR-ML-HANDLER]` Handlers are **first-class values**. `handler E` followed @@ -441,6 +635,12 @@ is in [FLAVOR-LAYER](/spec/0023-languageflavors/#flavor-concern-vs-shared-core-c | `\x y => e` | curried `Expr::Lambda` chain | | `f a b` | nested one-arg `Expr::Call` — `Call(Call(f,[a]),[b])` | | `f (a, b)` (saturated) | single multi-arg `Expr::Call` — `Call(f, [a, b])` | +| `namespace n` + following declarations | file-scoped `Stmt::Namespace` | +| `module M : S` + layout body | `Stmt::Module { kind: Plain, signature: S }` | +| `state M` + layout body | `Stmt::Module { kind: State }` | +| `signature S` + layout items | `Stmt::Signature` | +| layout member import | `Stmt::Import` + explicit `ImportSelection` | +| `A::B::value` | `Expr::Path(SymbolPath)` | | `type T =` + variant/field layout | `Stmt::Type` + `TypeVariant` | | `[a, b, c]` / `xs[i]` | `Expr::List` / `Expr::Index` | | layout block | `Expr::Block` | @@ -600,4 +800,6 @@ layout lexer. contract, currying canonicalisation, and shared-core handler-value feature. - [Algebraic Effects](/spec/0017-algebraiceffects/) — effect semantics shared by both flavors. +- [Modules and Namespaces](/spec/0025-modulesandnamespaces/) — shared namespace, + module, signature, import, export, and state-ownership semantics. - [Plan 0013 — ML Flavor Frontend](https://github.com/Nimblesite/osprey/blob/main/docs/plans/0013-ml-flavor-frontend.md). \ No newline at end of file diff --git a/website/src/spec/0025-modulesandnamespaces.md b/website/src/spec/0025-modulesandnamespaces.md index cb7a024a..7b732db1 100644 --- a/website/src/spec/0025-modulesandnamespaces.md +++ b/website/src/spec/0025-modulesandnamespaces.md @@ -2,7 +2,7 @@ layout: page title: "Modules and Namespaces" description: "Osprey Language Specification: Modules and Namespaces" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/0025-modulesandnamespaces/" @@ -23,17 +23,29 @@ it belongs to a project; it does **not** decide the names it exports. > infer semantics from `.osp` vs `.ospml` once lowering has happened. See > [Language Flavors](/spec/0023-languageflavors/). -## Status - -`import` and `module` syntax are parsed today, and module bodies are checked in a -child scope. Cross-file resolution, open namespaces, explicit exports, -signatures, module-owned state rules, and project assembly are planned. This -chapter is the normative contract for those features and supersedes the -fiber-isolated module sketch in [Fibers and Concurrency](/spec/0011-lightweightfibersandconcurrency/#fiber-isolated-modules-planned). - -## Research Basis - -`[MODULES-RESEARCH]` The design combines .NET-style logical named groups with +## Status `[MODULES-STATUS]` + +The initial module system is implemented end to end in both flavors. The shared +AST, project loader, namespace graph, import/privacy/signature checks, resolved +linkage names, state-owner validation, handler-local state materialization, +type checking, native/LLVM codegen, project CLI, formatter, and same-document +editor features are active. Mixed `.osp`/`.ospml` projects build and run through +the same canonical graph. + +The implementation fails loudly at the remaining semantic boundaries. In +particular, opaque manifest aliases are rejected rather than flattened to their +private representation; owner-transparent/client-nominal alias checking needs a +non-flat interface-aware checker. Separate importer checking, parameterised and +recursive modules, ranked import suggestions, incremental cross-file LSP +indexing, module reference-page generation, and source-name restoration in +native debugger/stack frames remain planned and are unchecked in +[plan 0014](https://github.com/Nimblesite/osprey/blob/main/docs/plans/0014-modules-and-namespaces.md). This chapter remains the +normative contract for those pieces and supersedes the fiber-isolated module +sketch in [Fibers and Concurrency](/spec/0011-lightweightfibersandconcurrency/#fiber-isolated-modules-planned). + +## Research Basis `[MODULES-RESEARCH]` + +The design combines .NET-style logical named groups with ML-style abstraction boundaries and Osprey's algebraic effects. It deliberately does **not** adopt the usual .NET `Company.Product.Feature` hierarchy as an Osprey norm. @@ -88,9 +100,9 @@ These are not ornamental citations. They drive the rules below: names are logical, interfaces are explicit, abstract state does not leak, and mutable state has one owner. -## Comparative Practice +## Comparative Practice `[MODULES-COMPARATIVE-PRACTICE]` -`[MODULES-COMPARATIVE-PRACTICE]` The survey above yields concrete rules: +The survey above yields concrete rules: - **Use namespaces for logical grouping, not architecture.** .NET/F# names are a useful precedent for path-independent grouping, but Osprey does not copy the @@ -114,9 +126,9 @@ has one owner. Osprey may use similar labels for published libraries later, but app code should usually stay flat. -## Design Goals +## Design Goals `[MODULES-GOALS]` -`[MODULES-GOALS]` The module system must make the good structure the easy +The module system must make the good structure the easy structure: - **Path-independent names.** A namespace label comes from source text, not from @@ -131,22 +143,27 @@ structure: the default. - **Separate compilation by interface.** A file can be checked against imported signatures without loading every implementation detail. -- **State has a declared owner.** Top-level mutable state is forbidden outside a - state module or handler-owned state region. -- **Pure logic stays pure.** Modules expose state through effect-typed operations - or pure query/update functions, not exported cells. +- **State has a declared owner.** Namespace and plain-module mutable state is + forbidden. A state module may declare private cells, but only its algebraic- + effect handler arms may read or write them. +- **Pure logic stays pure.** State crosses a module boundary only through effect + operations. Ordinary functions may transform explicit values, but may not + inspect or mutate module-owned cells. - **Cross-flavor interop.** A `.osp` module and `.ospml` module import each other through canonical signatures. -## Canonical Project Model +## Canonical Project Model `[MODULES-MODEL]` -`[MODULES-MODEL]` The module system is a project graph. Concrete syntax is only +The module system is a project graph. Concrete syntax is only how each flavor contributes nodes and edges to that graph. The shared model contains: -- `SourceFile { path, flavor, namespace }` - a parsed file with one active - flavor and one namespace label, explicit or project-defaulted. +- `SourceFile { path, flavor, contributions }` - a parsed file with one active + flavor and one or more namespace contributions. Unscoped declarations + contribute to the project's default namespace. +- `NamespaceContribution { namespace, items, span }` - one file-scoped, + block-scoped, or project-defaulted contribution. - `Namespace { label, contributions }` - an open logical grouping of declarations from any number of files. - `Module { namespace, path, kind, exports, private_items, signature }` - a @@ -155,8 +172,8 @@ The shared model contains: - `ImportEdge { from_file, target, alias, imported_members }` - a dependency on a namespace/module/member surface, never on a physical file. - `SymbolId { namespace, path }` - the stable identity for exported declarations. -- `StateOwner { module, cells, access_paths }` - the single owner of private - durable state in a `state module`. +- `StateOwner { module, cells, installers }` - private cell declarations plus + the handler installers allowed to instantiate and access them. Every later phase consumes this model, not surface syntax: @@ -175,31 +192,39 @@ or named arguments. Those are flavor concerns described in [Syntax](/spec/0003-syntax/), [Language Flavors](/spec/0023-languageflavors/), and [ML Flavor Syntax](/spec/0024-mlflavorsyntax/). -## Surface Projection +## Surface Projection `[MODULES-FLAVOR-PROJECTION]` -`[MODULES-FLAVOR-PROJECTION]` Each flavor projects the same model into its own +Each flavor projects the same model into its own surface. The examples in this chapter are illustrative; the model above is the normative layer. | Concept | Shared model | Default flavor | ML flavor | | --- | --- | --- | --- | -| Namespace contribution | `Namespace { label }` | `namespace billing { ... }` or `namespace billing;` | `namespace billing` followed by layout declarations | +| Namespace contribution | `Namespace { label }` | `namespace billing { ... }` or `namespace billing;` | file-scoped `namespace billing`, or an indented block | | Module boundary | `Module { path, exports, private_items }` | `module Tax { ... }` | `module Tax` + indented body | -| State module | `Module { kind: state }` | `state module Store { ... }` | `state module Store` + indented body | -| Import edge | `ImportEdge` | `import billing::Tax::{addTax}` | same path form; calls use ML application | +| State module | `Module { kind: state }` | `state module Store { ... }` | `state Store` + indented body | +| Import edge | `ImportEdge` | `import billing::Tax::{addTax}` | `import billing::Tax` + indented member names | | Signature | `Signature { items }` | `signature StoreSig { ... }` | `signature StoreSig` + indented items | -| Export | exported item metadata | `export fn f(...) = ...` | `export f : ...` / `export f x = ...` | +| Export | exported item metadata | explicit `export fn f(...)` when unascribed | one `export` on a signature or inferred binding when unascribed; an ascribed module uses its signature | | Symbol path | `SymbolId { namespace, path }` | `billing::Tax::addTax` | same path; application remains whitespace | -## Namespaces +Default deliberately keeps braces, parentheses, explicit `fn`, named arguments, +and visible export markers: a C, C#, Java, Kotlin, or Dart programmer can read +the boundary without learning layout rules. ML deliberately removes structural +punctuation that layout and signatures already express. These are surface +choices only; both lower to the same graph. -`[MODULES-NAMESPACE]` A `namespace` declaration contributes declarations to an +## Namespaces `[MODULES-NAMESPACE]` + +A `namespace` declaration contributes declarations to an open logical namespace. Multiple files may contribute to the same namespace. Namespace labels are opaque. `billing`, `"billing/api"`, and `"ui/forms"` are three unrelated labels; no parent namespace is implied. ```ebnf -namespaceDecl ::= "namespace" namespaceName ("{" statement* "}" | ";") +defaultNamespaceDecl ::= "namespace" namespaceName ("{" statement* "}" | ";") +mlNamespaceDecl ::= "namespace" namespaceName + (NEWLINE INDENT statement+ DEDENT | NEWLINE) namespaceName ::= IDENT | STRING symbolPath ::= IDENT ("::" IDENT)* ``` @@ -247,7 +272,9 @@ namespace "billing/api"; The slash is part of the label. It does not create a `billing` parent namespace. -`[MODULES-FILE-SCOPED-NAMESPACE]` A file-scoped namespace declaration applies to +### File-scoped Namespaces `[MODULES-FILE-SCOPED-NAMESPACE]` + +A file-scoped namespace declaration applies to all declarations after it in the file: Default flavor: @@ -277,15 +304,22 @@ emptyInvoice id = ``` A file may contain either one file-scoped namespace declaration or any number of -block-scoped namespace declarations, not both. +block-scoped namespace declarations, not both. In ML, an indented body is a +block-scoped contribution; declarations at the namespace line's indentation make +the declaration file-scoped. Layout makes the distinction without braces or a +terminator. + +### Path Independence `[MODULES-PATH-INDEPENDENCE]` -`[MODULES-PATH-INDEPENDENCE]` The physical file path is never part of the +The physical file path is never part of the namespace identity. A file `src/weird/place/x.osp` may declare `namespace billing;` or `namespace "billing/api";`. The compiler may warn when path and namespace drift from project convention, but it must not change symbol identity or import resolution. -`[MODULES-NAMESPACE-STYLE]` Namespace style is flexible but flat-first: +### Namespace Style `[MODULES-NAMESPACE-STYLE]` + +Namespace style is flexible but flat-first: - Prefer one short lowercase label for app namespaces: `app`, `billing`, `ui`, `worker`. @@ -298,20 +332,28 @@ resolution. - Never mirror folders by default. If a team chooses folder-like slash labels, the label remains opaque and path-independent. -## Modules +## Modules `[MODULES-MODULE]` -`[MODULES-MODULE]` A `module` is a closed implementation boundary inside a -namespace. It may contain values, functions, types, effects, nested modules, and -private mutable state. It exports only declarations marked `export` or listed by -its signature. +A `module` is a closed, stateless implementation boundary inside a namespace. +It may contain immutable values, functions, types, effects, and nested plain +modules. A direct `mut` declaration is forbidden; ordinary local `mut` bindings +inside its functions and blocks retain their normal lexical semantics. An +unascribed module exports only declarations marked `export`; an ascribed module's +signature is its complete public surface. ```ebnf -moduleDecl ::= plainModuleDecl | stateModuleDecl -plainModuleDecl ::= "module" symbolPath signatureAscription? "{" moduleItem* "}" -stateModuleDecl ::= "state" "module" symbolPath signatureAscription? "{" moduleItem* "}" -signatureAscription ::= ":" symbolPath -moduleItem ::= exportDecl | statement -exportDecl ::= "export" statement +defaultModuleDecl ::= "module" symbolPath defaultSignatureAscription? + "{" defaultModuleItem* "}" +defaultStateDecl ::= "state" "module" symbolPath defaultSignatureAscription? + "{" defaultModuleItem* "}" +defaultModuleItem ::= "export"? statement +mlModuleDecl ::= "module" symbolPath mlSignatureAscription? + NEWLINE INDENT mlModuleItem+ DEDENT +mlStateDecl ::= "state" symbolPath mlSignatureAscription? + NEWLINE INDENT mlModuleItem+ DEDENT +mlModuleItem ::= "export"? statement +defaultSignatureAscription ::= ":" symbolPath ("+" "extra")? +mlSignatureAscription ::= ":" symbolPath ``` Default flavor: @@ -322,7 +364,7 @@ namespace billing; module Tax { let defaultRate = 10 - export fn addTax(cents: int) -> int = + export fn addTax(cents) = cents + cents * defaultRate / 100 } ``` @@ -335,28 +377,34 @@ namespace billing module Tax defaultRate = 10 - export addTax : int -> int export addTax cents = cents + cents * defaultRate / 100 ``` -`Tax.defaultRate` is private. `Tax.addTax` is exported. +`Tax::defaultRate` is private. `Tax::addTax` is exported. The `::` separator is +reserved for namespace/module paths; `.` remains value field/member access. + +### Namespaces Versus Modules `[MODULES-NAMESPACE-VS-MODULE]` -`[MODULES-NAMESPACE-VS-MODULE]` Namespaces are open and stateless. Modules are -closed and may own private implementation details. A namespace cannot be used as -a runtime value; a module can be referenced as a named declaration space and, -when it is a `state module`, has a runtime state owner. +Namespaces are open and stateless. Plain modules are closed and stateless. A +namespace cannot be used as a runtime value; a module is a named declaration +space. Only a state module declares an owner template for durable state, and that +state exists only inside an explicitly installed handler region. -## Imports +## Imports `[MODULES-IMPORT]` -`[MODULES-IMPORT]` Imports name namespaces or modules, not files. +Imports name namespaces or modules, not files. Default uses a compact braced +member list; ML uses an indented list with no braces or commas. ```ebnf -importStmt ::= "import" importTarget importTail? +defaultImportStmt ::= "import" importTarget defaultImportTail? +defaultImportTail ::= "as" IDENT + | "::" "{" importMember ("," importMember)* "}" + | "::" "*" +mlImportStmt ::= "import" importTarget + ("as" IDENT | "::" "*" + | NEWLINE INDENT importMember (NEWLINE importMember)* DEDENT)? importTarget ::= namespaceName ("::" symbolPath)? -importTail ::= "as" IDENT - | "::" "{" importMember ("," importMember)* "}" - | "::" "*" importMember ::= IDENT ("as" IDENT)? ``` @@ -376,7 +424,8 @@ ML flavor: ```osprey-ml import billing::Tax -import billing::Tax::{addTax} +import billing::Tax + addTax import billing::Tax as Tax import "billing/api" as billingApi @@ -384,7 +433,14 @@ gross = addTax 100 other = Tax::addTax 100 ``` -Resolution rules: +### Name Resolution `[MODULES-RESOLUTION]` + +Resolution is lexical and deterministic: local bindings and declarations win, +then the current module and its parents, imported aliases, imported members, +explicit namespace-qualified paths, and finally built-ins. An import never +silently replaces a nearer declaration. + +Additional import rules: - Identifier namespace labels can be used directly with `::`: `billing::Tax::addTax(100)`. @@ -392,8 +448,8 @@ Resolution rules: `import "billing/api" as billingApi`, then `billingApi::Tax::addTax(100)`. - `import billing::Tax` brings the exported module `Tax` into the local scope as `Tax`. -- `import billing::Tax::{x, y}` brings only listed exported members into local - scope. +- Default `import billing::Tax::{x, y}` and the equivalent ML indented member + list bring only the listed exports into local scope. - `import billing::Tax as Alias` brings `Alias` into local scope. - `import billing::Tax::*` is allowed only in examples, scripts, and tests unless the project enables `allow_wildcard_imports = true`; it is forbidden for state @@ -404,11 +460,13 @@ Resolution rules: Imports do not execute code, allocate module state, or load files by relative path. -## Exports And Visibility +## Exports And Visibility `[MODULES-EXPORTS]` -`[MODULES-EXPORTS]` Declarations are private by default inside modules and +Declarations are private by default inside modules and public by default inside namespaces. A module controls its public surface through -`export` or a signature. +`export` or a signature. In an ascribed module the signature already names every +export; ML therefore rejects redundant `export` markers there. Default may +repeat them as an explicit readability aid, but they cannot widen the signature. Default flavor: @@ -432,11 +490,13 @@ module Parser Expr | Stmt export parse : string -> Result - export parse source = + parse source = ... ``` -`[MODULES-OPAQUE-TYPES]` A module may export an opaque type, hiding its +### Opaque Types `[MODULES-OPAQUE-TYPES]` + +A module may export an opaque type, hiding its representation: Default flavor: @@ -457,11 +517,11 @@ module UserIds export opaque type UserId = int export parseUserId : string -> Result - export parseUserId raw = + parseUserId raw = ... export showUserId : UserId -> string - export showUserId id = + showUserId id = ... ``` @@ -469,14 +529,33 @@ Outside `UserIds`, `UserId` is distinct from `int`. Inside `UserIds`, the manifest representation is available. This is the Osprey form of ML abstract types and Leroy-style manifest types. -## Signatures +## Signatures `[MODULES-SIGNATURE]` -`[MODULES-SIGNATURE]` A `signature` is an explicit interface for a module. It +A `signature` is an explicit interface for a module. It lists the names, types, effects, and opacity visible to clients. ```ebnf -signatureDecl ::= "signature" IDENT "{" signatureItem* "}" -signatureItem ::= typeSpec | effectSpec | fnSpec | moduleSpec +defaultSignatureDecl ::= "signature" IDENT "{" signatureItem* "}" +mlSignatureDecl ::= "signature" IDENT NEWLINE + INDENT signatureItem+ DEDENT +signatureItem ::= abstractTypeSpec | manifestTypeSpec | valueSpec + | effectSpec | moduleSpec +abstractTypeSpec ::= "opaque" "type" IDENT /* Default */ + | "type" IDENT /* ML */ +manifestTypeSpec ::= "type" IDENT "=" typeExpr +valueSpec ::= "fn" IDENT typeParams? "(" signatureParams? ")" + ("->" typeExpr)? effectRow? /* Default */ + | IDENT ":" mlType effectRow? /* ML */ +effectSpec ::= "effect" IDENT effectSignatureBody +moduleSpec ::= "module" IDENT ":" symbolPath +signatureParams ::= signatureParam ("," signatureParam)* +signatureParam ::= IDENT ":" typeExpr +effectSignatureBody ::= "{" effectOperationSpec* "}" + | NEWLINE INDENT effectOperationSpec+ DEDENT +effectOperationSpec ::= IDENT ":" typeExpr /* Default fn type */ + | IDENT ":" mlType "=>" mlType +defaultSignatureAscription ::= ":" symbolPath ("+" "extra")? +mlSignatureAscription ::= ":" symbolPath ``` Default flavor: @@ -492,7 +571,7 @@ signature StoreSig { } module MemoryStore : StoreSig { - export opaque type Store = { values: [string] } + export type Store = { values: [string] } export effect StoreFx { load : fn() -> Store save : fn(Store) -> Unit @@ -505,44 +584,54 @@ ML flavor: ```osprey-ml signature StoreSig - opaque type Store + type Store effect StoreFx load : Unit => Store save : Store => Unit empty : Unit -> Store module MemoryStore : StoreSig - export opaque type Store = + type Store = Store values : [string] - export effect StoreFx + effect StoreFx load : Unit => Store save : Store => Unit - export empty : Unit -> Store - export empty () = + empty () = Store values = [] ``` +In an ML signature, bare `type Store` is abstract; repeating `opaque` would add +no information. The implementation supplies its representation, but clients see +only the abstract identity. The ascription already supplies the export list, so +the ML implementation repeats neither `export` nor signature punctuation. + Signature conformance is checked structurally: -- Every signature item must have a matching exported declaration. +- Every signature item must have a matching implementation declaration; the + ascription exports it. - Types must match after applying opacity rules. - Effect operations must match names, parameter types, return types, and effect rows. - Extra private declarations are allowed. -- Extra exported declarations are rejected unless the ascription is marked - `: StoreSig + extra`. +- Other implementation declarations stay private. In Default, + `: StoreSig + extra` opts into additionally exporting declarations explicitly + marked `export`; without `+ extra`, such extra exports are rejected. ML keeps + ascription exact: extend the named signature or use an unascribed module + instead of adding a redundant `+ extra`/`export` side channel. + +### Separate Checking `[MODULES-SEPARATE-CHECKING]` -`[MODULES-SEPARATE-CHECKING]` A compiler may type-check an importing file using +A compiler may type-check an importing file using only the imported module's signature. The implementation body is needed only when compiling that module or linking the final project. -## Parameterised Modules +## Parameterised Modules `[MODULES-FUNCTOR]` -`[MODULES-FUNCTOR]` A parameterised module is a module-level function from +A parameterised module is a module-level function from signatures to modules. This is planned after basic signatures. ```osprey @@ -555,30 +644,47 @@ module MakeRepo(Db: DatabaseSig, Clock: ClockSig) : RepoSig { Parameterised modules are the dependency-injection mechanism for reusable libraries. They are preferred over ambient globals. -## State Ownership +## State Ownership `[MODULES-STATE]` -`[MODULES-STATE]` Mutable state may appear only in three places: +Local mutation is unchanged: `mut` inside an ordinary function or block is a +lexical local and may be read or written by that scope. Durable module-owned +state is different. It may be declared only in a state module and may be +observed or changed only by that module's owning algebraic-effect handler arms +([EFFECTS-HANDLER-STATE](/spec/0017-algebraiceffects/#handler-owned-state)). -- inside a function or block as an ordinary local `mut`; -- inside an algebraic-effect handler's owned state region - ([EFFECTS-HANDLER-STATE](/spec/0017-algebraiceffects/#handler-owned-state)); -- inside a `state module`. +### Forbidden Top-level State `[MODULES-STATE-TOPLEVEL]` -Namespace-level `mut` is a compile-time error. +A direct `mut` in a namespace or plain module is a compile-time error: ```osprey namespace badState; mut count = 0 -// error [MODULES-STATE-TOPLEVEL]: -// mutable state must live in a function, handler, or state module +// error: mutable state must be local or owned by a state-module handler ``` -`[MODULES-STATE-MODULE]` A `state module` is the declared owner of durable -module state. All state cells are private, and no `mut` cell may be exported. +### State Modules `[MODULES-STATE-MODULE]` + +A state module declares private cell templates, exported effects, and one or +more handler installer functions. A cell declaration establishes its initial +value; every subsequent read or write of that cell must occur lexically inside +an operation arm of a `handle Effect ... in body` expression defined by the same +state module. The installer function itself may install that handler and invoke +the supplied body, but its ordinary code before and after the arms cannot touch +the cells. + +Default flavor keeps the complete boundary explicit: ```osprey -state module Counter { +signature CounterSig { + effect CounterFx { + next : fn() -> int + read : fn() -> int + } + fn run(action: fn() -> Unit) -> Unit +} + +state module Counter : CounterSig { mut count = 0 export effect CounterFx { @@ -586,55 +692,89 @@ state module Counter { read : fn() -> int } - export let counterHandler = handler CounterFx { - next => { - count = count + 1 - count - } - read => count - } + export fn run(action: fn() -> Unit) -> Unit = + handle CounterFx + next => { + count = count + 1 + count + } + read => count + in action() } ``` -Clients perform the effect; the module owns the cell: +The ML projection removes the redundant module keyword, braces, and exports +already supplied by the signature: + +```osprey-ml +signature CounterSig + effect CounterFx + next : Unit => int + read : Unit => int + run : (Unit -> Unit) -> Unit + +state Counter : CounterSig + mut count = 0 + + effect CounterFx + next : Unit => int + read : Unit => int + + run action = + handle CounterFx + next () => + count := count + 1 + count + read () => count + in action () +``` + +Clients import declarations, then explicitly invoke the installer around code +that performs the effect: ```osprey -import Counter::{CounterFx, counterHandler} +import app::Counter::{CounterFx, run} -fn allocate() -> int !CounterFx = - perform CounterFx.next() +fn allocate() -> int !CounterFx = perform CounterFx.next() -handle counterHandler in { +run(action: fn() => { print(toString(allocate())) -} +}) ``` +Each call to `run` instantiates a fresh `count` cell for that handler region. +Merely importing `Counter`, `CounterFx`, or `run` allocates nothing. First-class +handler values and reusable `install` syntax are a later ergonomic layer (plan +0016); the initial module implementation uses the existing fused +`handle Effect ... in body` form. + Rules: -- `state module` cells are private by construction. -- Exporting a `mut`, a pointer to a `mut`, or a closure that directly exposes - assignment is a compile-time error. -- A `state module` must export at least one handler, effect, or function that is - the declared access path. -- A namespace may contain at most one unannotated `state module`. Additional - state owners require `@state_boundary("reason")` and are reported by LSP and - docs tooling as architecture-visible state boundaries. -- Derived state should be expressed as pure functions over owner state. Cached - derived state is forbidden in Phase 1; a later `cache mut` feature must name - the owner state it derives from, so invalidation can be checked. +- State-module cells are private by construction. `export mut` is always an + error, as is exporting a pointer, reference, or closure that exposes a cell. +- An ordinary function, exported or private, cannot read or write a module cell. + Pure helpers remain legal when all state arrives through explicit parameters. +- A state module must export its effect surface and at least one installer that + establishes the owning handler region. +- A namespace may contain at most one state module in the initial module + system. There is no annotation, ordinary-function, or ambient-state escape + hatch; additional owners are a compile-time error. +- Cached derived cells are forbidden in Phase 1. Derived values are computed in + handler arms or by pure helpers over explicit values. -`[MODULES-STATE-SOURCE-OF-TRUTH]` The compiler and tooling treat each state -module as a **single source of truth** for the state it owns. Cross-module writes -are impossible. Cross-module reads happen through exported pure queries or -effect operations. This is the language-level answer to scattered app state. +### Single Source of Truth `[MODULES-STATE-SOURCE-OF-TRUTH]` -## Effects And Capabilities +The compiler and tooling treat each state module as the single source of truth +for its cells. Cross-module reads and writes are both mediated by exported effect +operations; direct cell references cannot cross the boundary. -`[MODULES-EFFECTS]` Modules do not hide effects. Exported functions and handlers -carry ordinary Osprey effect rows. Importing a module never grants ambient -permission; a caller must still handle or forward every effect. +## Effects And Capabilities `[MODULES-EFFECTS]` -State modules are encouraged to expose capabilities as algebraic effects: +Modules do not hide effects. Exported functions carry ordinary Osprey effect +rows. Importing a module never grants ambient permission; a caller must still +handle or forward every effect. + +State modules expose their state capability as algebraic effects: ```osprey signature LedgerSig { @@ -648,37 +788,52 @@ signature LedgerSig { This keeps application logic pure except for explicit `!Ledger`, while the module decides whether state is in memory, SQLite, HTTP, or a test fake. -## Initialisation +## Initialisation `[MODULES-INIT]` -`[MODULES-INIT]` Imports have no runtime effect. Module initialization is explicit. +Imports have no runtime effect. Module initialization is explicit. - Pure `let` declarations may be evaluated at compile time or lowered as constants. -- Effectful setup must live in an exported `init` function or handler factory. -- `state module` initial state is allocated only when its handler or instance is - explicitly constructed. +- Effectful setup for a plain module must live in an exported function. +- A state module's cell initializers run only when an installer creates its + handler region; each installation receives fresh cells. - Cyclic initialization between state modules is a compile-time error. ```osprey state module DbStore { mut conn = None - export fn init(path: string) -> Unit !Database = - conn = Some(perform Database.open(path)) + export effect DbStoreFx { + connect : fn(string) -> Unit + } + + export fn run(path: string, action: fn() -> Unit) -> Unit = + handle DbStoreFx + connect requestedPath => { + conn = Some(perform Database.open(requestedPath)) + } + in { + perform DbStoreFx.connect(path) + action() + } } ``` -## Project Assembly +Here the exported installer never accesses `conn` directly; only its `connect` +handler arm does. + +## Project Assembly `[MODULES-PROJECT]` -`[MODULES-PROJECT]` A project compile scans configured source roots, parses every +A project compile scans configured source roots, parses every `.osp` and `.ospml` file, resolves each file's flavor, and builds one project namespace graph. ```toml [project] name = "billing" -source_roots = ["src", "tests"] +source_roots = ["src"] default_namespace = "billing" +entry = "src/main.osp" [modules] allow_wildcard_imports = false @@ -693,14 +848,18 @@ Single-file mode remains valid for scripts and examples. Project mode adds: - duplicate-name and ambiguity diagnostics; - one entry point. -`[MODULES-ENTRYPOINT]` In project mode, executable top-level statements are +### Entry Point `[MODULES-ENTRYPOINT]` + +In project mode, executable top-level statements are allowed only in the designated entry file or in `fn main()`. Library files must contain declarations only. This avoids hidden initialization order and makes -multi-file apps deterministic. +multi-file apps deterministic. `entry` is relative to the manifest and must name +a file under one source root. Test source roots belong to a separate test +configuration; a normal build does not silently compile them. -## Cycles +## Cycles `[MODULES-CYCLES]` -`[MODULES-CYCLES]` Namespace declarations may be mutually visible after merging, +Namespace declarations may be mutually visible after merging, but module implementation cycles are restricted. - Pure type/function cycles are allowed only when ordinary Osprey recursion rules @@ -713,9 +872,9 @@ but module implementation cycles are restricted. Recursive modules are a later feature and must require explicit signatures, as in the ML literature. -## Name Mangling And ABI +## Name Mangling And ABI `[MODULES-ABI]` -`[MODULES-ABI]` Canonical symbol names include the namespace label and `::` path: +Canonical symbol names include the namespace label and `::` path: ```text billing::Tax::addTax @@ -728,21 +887,21 @@ stack traces use source-level names. Cross-flavor exports use the same ABI rules as [Cross-Flavor Interop](/spec/0023-languageflavors/#cross-flavor-interop). -## Diagnostics +## Diagnostics `[MODULES-DIAG]` -`[MODULES-DIAG]` Module diagnostics must be architecture-facing: +Module diagnostics must be architecture-facing: - unknown import: show candidate namespaces from the project graph; - ambiguous import: show all providers and suggest aliases; - exported private dependency: show the hidden type/value in the public signature; -- state scatter: show every state module in the namespace and require - `@state_boundary`; +- state scatter: show every state module in the namespace and require the state + to be consolidated behind one algebraic-effect boundary; - top-level mutable state: suggest `state module` or handler-owned state; - path drift: warn, never change semantics. -## Examples +## Examples `[MODULES-EXAMPLES]` -### Multi-file, Path-Independent Namespace +### Multi-file, Path-Independent Namespace `[MODULES-EXAMPLE-MULTIFILE]` `src/a.osp`: @@ -779,7 +938,7 @@ import "app/http" as httpApp let root = httpApp::route() ``` -### Centralised State +### Centralised State `[MODULES-EXAMPLE-STATE]` ```osprey namespace app; @@ -792,17 +951,20 @@ state module SessionStore { count : fn() -> int } - export let liveSessions = handler Sessions { - add id => { sessions = listAppend(sessions, id) } - count => listLength(sessions) - } + export fn run(action: fn() -> Unit) -> Unit = + handle Sessions + add id => { sessions = listAppend(sessions, id) } + count => listLength(sessions) + in action() } fn login(id: string) -> Unit !Sessions = perform Sessions.add(id) ``` -Application code cannot mutate `sessions`. It can only perform `Sessions`. +Application code invokes `SessionStore::run` around a body that performs +`Sessions`. It cannot access `sessions`, and importing the module creates no +session store. ## References diff --git a/website/src/spec/0026-documentationcomments.md b/website/src/spec/0026-documentationcomments.md new file mode 100644 index 00000000..8eb4b32f --- /dev/null +++ b/website/src/spec/0026-documentationcomments.md @@ -0,0 +1,480 @@ +--- +layout: page +title: "Documentation Comments" +description: "Osprey Language Specification: Documentation Comments" +date: 2026-07-12 +tags: ["specification", "reference", "documentation"] +author: "Christian Findlay" +permalink: "/spec/0026-documentationcomments/" +--- + +# Documentation Comments + +Osprey has a **single documentation system** with two idiomatic surface +spellings — one for each [language flavor](/spec/0023-languageflavors/). Both +spellings lower to the **same** structured `DocComment` attached to the +canonical AST, so the type checker, the LSP, and the doc exporter never see a +flavor difference ([FLAVOR-BOUNDARY]). A `///` comment in the Default flavor and +a `(** … *)` comment in the ML flavor that carry the same body produce a +byte-identical doc model and byte-identical rendered output. + +This chapter is the authoritative contract for that system: the sigils, the body +markup, the recognised sections, executable examples, and the shared model. + +- [Design Rationale](#design-rationale) +- [The Shared Doc Model](#the-shared-doc-model) +- [Default-Flavor Sigil](#default-flavor-sigil) +- [ML-Flavor Sigil](#ml-flavor-sigil) +- [Body Markup](#body-markup) +- [Recognised Sections](#recognised-sections) +- [Executable Examples (Doctests)](#executable-examples-doctests) +- [Attachment Rules](#attachment-rules) +- [Export & Tooling](#export--tooling) +- [Worked Example — One Function, Both Flavors](#worked-example--one-function-both-flavors) +- [Status](#status) +- [References](#references) + +## Design Rationale + +The design is not arbitrary — each decision traces to the literature on +documentation systems and program comprehension (full citations in +[References](#references)). + +- **Documentation is written for humans first, co-located with the code.** This + is Knuth's founding thesis of *literate programming* [Knuth 1984]: "let us + concentrate rather on explaining to *human beings* what we want a computer to + do." Doc comments live at the definition site and are authored as prose, not + as machine instructions. +- **Keep the mechanism simple and language-agnostic.** Ramsey's *noweb* + [Ramsey 1994] showed that a documentation tool should be minimal and not bound + to one language's quirks. Osprey applies this *across flavors*: one body + language, one model, two thin sigils — the flavor is a below-the-model detail. +- **Structure must reflect what developers actually need.** Empirical studies of + API learning [Robillard 2009; Robillard & DeLine 2011] find that the dominant + obstacle is missing *usage examples* and missing *intent/rationale*, not + missing type signatures (the compiler already has those). Osprey therefore + gives examples and prose first-class, recognised sections. +- **Prevent the known documentation failure modes.** Uddin & Robillard's + taxonomy of how API documentation fails [Uddin & Robillard 2015] enumerates + incompleteness, ambiguity, incorrectness, **obsolescence**, and fragmentation. + Osprey's structured sections attack incompleteness and fragmentation; its + **executable examples** attack obsolescence directly — a rotted example fails + the build. +- **Examples should be executable, not inert.** Documentation that the machine + runs and checks measurably aids comprehension [Wrenn & Krishnamurthi 2019] and + cannot silently drift from the code — the design principle behind Scribble's + binding-aware prose [Flatt, Barzilay & Findler 2009]. Osprey doctests are + extracted into the existing golden-output example harness. +- **Comments carry real comprehension weight.** That documentation *causally* + improves program comprehension is established experimentally + [Woodfield, Dunsmore & Shen 1981; Tenny 1988], and quality is measurable + [Steidl, Hummel & Jürgens 2013] — motivation for defining a precise model + rather than leaving "good docs" to taste. + +## The Shared Doc Model + +`[DOC-MODEL]` Both flavors lower into one structure on the canonical AST. It +replaces the earlier free-text `doc: Option` field. + +```rust +/// A structured documentation comment. BOTH flavors' surface syntaxes +/// (`///` / `//!` in Default, `(** … *)` in ML) lower into this one model; +/// the body markup is identical across flavors — only the sigil differs. +pub struct DocComment { + /// First sentence / first paragraph — the one-line summary. + pub summary: String, + /// Full Markdown body EXCLUDING the recognised structured sections. + /// `[Symbol]` intra-doc links are left unresolved here (a later pass + /// resolves them against the symbol table). + pub body: String, + /// `# Parameters` bullets (name → Markdown text), in author order. + pub params: Vec<(String, String)>, + /// `# Returns`. + pub returns: Option, + /// `# Raises` / `# Errors` — effect or error name → text. Aligns with + /// Osprey's `!Effect` rows and `Result` convention. + pub raises: Vec<(String, String)>, + /// Extracted ```osprey``` examples with optional expected output. + pub examples: Vec, + /// `# See also` — `[Symbol]` references and external links. + pub see_also: Vec, + /// `# Since` — version introduced. + pub since: Option, + /// `# Deprecated` — present ⇒ deprecated; text is the reason. + pub deprecated: Option, + /// Module/inner (`//!`) authorship, optional. + pub author: Option, + /// Whether this was an outer or an inner/module doc. + pub scope: DocScope, +} + +pub struct DocExample { + /// The Osprey snippet, compiled under the enclosing file's flavor. + pub code: String, + /// Expected stdout for the golden harness, when an `output` block follows. + pub expected_output: Option, + /// Compile-only (no run) for type-level examples. + pub run: bool, +} + +pub enum DocScope { Outer, Inner } +``` + +`params`, `raises`, and `see_also` are ordered vectors, not maps: rendering +order is the author's order. `body` keeps `[Symbol]` links unresolved so the +doc-body parser stays flavor- and symbol-table-agnostic. + +## Default-Flavor Sigil + +`[DOC-SIGIL-DEFAULT]` The Default flavor uses **`///`** for an *outer* doc +comment (documents the declaration that follows) and **`//!`** for an *inner* +doc comment (documents the enclosing module or file). This is the +modern-family consensus — Rust, Swift, C#, and F# all spell outer docs `///` — +so it reads native to the languages the Default flavor emulates. + +```osprey +/// Doubles its argument. +fn double(x) = x * 2 + +//! Arithmetic helpers used across the billing pipeline. +module Billing { … } +``` + +`///` out-prioritises the ordinary `//` line comment by maximal munch, so an +ordinary comment is never mistaken for a doc comment. A blank `///` line is a +paragraph break in the body. + +## ML-Flavor Sigil + +`[DOC-SIGIL-ML]` The ML flavor uses **`(** … *)`** — the OCaml/odoc convention, +where the doc sigil is a *specialisation* of the ordinary `(* … *)` block +comment (double star). It is instantly legible to any OCaml, F#, or SML reader, +and — being a block form — is layout-friendly: its content is one contiguous +region the offside-rule lexer skips wholesale, without forcing a per-line +prefix that would fight indentation. + +```osprey +(** Doubles its argument. *) +double x = x * 2 +``` + +Disambiguation from ordinary comments and ASCII-art banners: + +- `(**` opens a doc comment **only** when it is followed by content that is not + immediately another `*` or the close. This matches odoc. +- `(*` not followed by `*` is an ordinary comment. +- The empty `(**)` and all-star banners such as `(*****)` are ordinary + comments, never docs. +- `(* … *)` block comments **nest**; a doc comment nests the same way, so a + commented-out region inside a doc closes correctly. + +The ML flavor's ordinary comment forms remain `//` (line) and `(* … *)` (block). + +## Body Markup + +`[DOC-BODY-MARKDOWN]` The doc **body is CommonMark Markdown, identical in both +flavors**. Only the surrounding sigil differs; everything inside is the same +markup, parsed by one flavor-neutral parser and rendered by one backend. + +Two additions on top of plain CommonMark, both shared by both flavors: + +- **Intra-doc links** `[DOC-LINK]` — `[Symbol]` with no URL resolves against + Osprey's symbol table (the rustdoc convention). Bare (`[helper]`) and dotted + (`[Console.emit]`, resolving to the owner) forms are supported; a + `[text](url)` Markdown link is left alone. In the editor, hovering a + `[Symbol]` link shows the referenced element's own hover. Inline code that is + *not* a link uses backticks. +- **Example fences** — a ` ```osprey ` fenced block is an executable example + (see [Doctests](#executable-examples-doctests)); an optional following + ` ```output ` fence is its expected stdout. + +Markdown is chosen deliberately over the bespoke markups of ocamldoc (`{b }`, +`{[ ]}`) and Haddock (`/em/`, `` @code@ ``): Markdown is the lingua franca of +every modern best-in-class system (rustdoc, KDoc, DocC, TSDoc), and the bespoke +ML markups are the least-loved parts of those systems. ML programmers gain +Markdown; they lose nothing they valued. + +## Recognised Sections + +`[DOC-SECTIONS]` Structure is **convention-based**, not tag-based: a small set +of recognised Markdown `#` headings lower into the model's fields; everything +else is free body. This keeps the body a clean Markdown document with no tag +sigil, and degrades gracefully — an unrecognised heading is just prose. + +| Heading (case-insensitive) | Lowers to | Form | +|---|---|---| +| `# Parameters` | `params` | `- name: description` bullets | +| `# Returns` | `returns` | prose | +| `# Raises` / `# Errors` | `raises` | `- Name: description` bullets | +| `# Examples` | `examples` | ` ```osprey ` / ` ```output ` fences | +| `# See also` | `see_also` | `[Symbol]` links / URLs | +| `# Since` | `since` | a version string | +| `# Deprecated` | `deprecated` | reason prose | + +As a concession to ML muscle memory, the ocamldoc/Javadoc block tags +`@param name`, `@return`, `@raise Name`, `@see`, `@since`, and `@deprecated` are +accepted as **aliases** that lower into the same fields. The heading convention +is the canonical, documented form; the tags exist so an OCaml/F# author is never +surprised. + +## Executable Examples (Doctests) + +`[DOC-DOCTEST-HARNESS]` A ` ```osprey ` fenced block in a doc comment is an +**executable example**. An optional ` ```output ` fence immediately after it is +the example's expected stdout. + +Doctests are extracted into the **existing differential golden harness** +([crates/diff_examples.sh](https://github.com/Nimblesite/osprey/blob/main/crates/diff_examples.sh)) — there is no second +test runner. The extractor emits each example as a synthetic `.osp`/`.ospml` +program (compiled under the enclosing file's flavor) plus a `.expectedoutput` +from the `output` fence, and the harness compiles, runs, and byte-compares as it +does for every `examples/tested/` program. A doc example whose output drifts +fails CI, which is exactly the obsolescence defense the design calls for +[Uddin & Robillard 2015; Wrenn & Krishnamurthi 2019]. + +An example with no `output` fence is compiled but not run (a type-level or +illustrative snippet); `DocExample.run` records which. + +## Attachment Rules + +`[DOC-ATTACH]` A doc comment documents the declaration **immediately following** +it. Attachment is **before-only** in both flavors — Osprey does not adopt +Haddock's attach-after `-- ^` form, which doubles the parsing surface and +creates "which declaration owns this?" ambiguity. Every documentable +declaration is covered: + +- functions, `let`/`mut` bindings, `type` declarations, `effect` declarations, + `extern` declarations, and modules; +- and, granularly, type variants, record fields, effect operations, and + function parameters (the last also expressible via `# Parameters`). + +A doc comment separated from its declaration by a blank line still attaches; a +doc comment with no following declaration is a warning (a dangling doc). + +## Export & Tooling + +`[DOC-EXPORT]` The doc system feeds three consumers from the one model: + +- **LSP hover** renders the `DocComment` as Markdown beneath the signature + ([0020-LanguageServerAndEditors.md](/spec/0020-languageserverandeditors/) + `[LSP-HOVER-DOCS]`). +- **`osprey --docs --docs-dir `** exports Markdown-with-front-matter pages. + This already exports built-in functions from the same render model + (`BuiltinDocView`); the user-declaration path emits the same page shape from + `DocComment`, so built-in and user docs are visually uniform. +- **The website `generate-docs` pipeline** consumes that Markdown unchanged. + +Built-in documentation and user documentation therefore share one render model +and one exporter — the `BuiltinDocView` shape and `DocComment` converge on the +same rendered page. + +## Worked Example — One Function, Both Flavors + +The same function, documented in each flavor, lowering to the **identical** +`DocComment`. + +**Default flavor (`.osp`):** + +```osprey +/// Divides `numerator` by `denominator`, rounding toward zero. +/// +/// Use [safeDivide] when a zero denominator should be a recoverable +/// `Result` rather than a raised effect. +/// +/// # Parameters +/// - numerator: The value being divided. +/// - denominator: The divisor. Must be non-zero. +/// +/// # Returns +/// The integer quotient. +/// +/// # Raises +/// - DivByZero: When `denominator` is `0`. +/// +/// # Examples +/// ```osprey +/// print(divide(7, 2)) +/// ``` +/// ```output +/// 3 +/// ``` +/// +/// # Since +/// 0.4.0 +fn divide(numerator, denominator) = intDiv(numerator, denominator) +``` + +**ML flavor (`.ospml`):** + +```osprey +(** Divides [numerator] by [denominator], rounding toward zero. + + Use [safeDivide] when a zero denominator should be a recoverable + [Result] rather than a raised effect. + + # Parameters + - numerator: The value being divided. + - denominator: The divisor. Must be non-zero. + + # Returns + The integer quotient. + + # Raises + - DivByZero: When [denominator] is [0]. + + # Examples + ```osprey + print (divide 7 2) + ``` + ```output + 3 + ``` + + # Since + 0.4.0 *) +divide numerator denominator = intDiv (numerator, denominator) +``` + +Both lower to: + +```rust +DocComment { + summary: "Divides `numerator` by `denominator`, rounding toward zero.", + body: "Use [safeDivide] when a zero denominator should be a recoverable …", + params: [("numerator", "The value being divided."), + ("denominator", "The divisor. Must be non-zero.")], + returns: Some("The integer quotient."), + raises: [("DivByZero", "When `denominator` is `0`.")], + examples: [DocExample { code: "print(divide(7, 2))", + expected_output: Some("3\n"), run: true }], + since: Some("0.4.0"), + .. +} +``` + +The two surfaces differ only in the sigil (`///` per line vs one `(** … *)` +block) and in idiomatic inline-code habit — each reads native to its family, +and the lowered model is the same. + +## Status + +**Implemented — capture, model, hover, and links are live; doctest-harness +wiring and user-declaration `--docs` export remain.** + +Shipped and tested: + +- The structured `DocComment` / `DocExample` / `DocScope` model + ([crates/osprey-ast/src/doc.rs](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-ast/src/doc.rs)), on the + `doc` field of **every** declaration form (`fn`, `let`/`mut`, `type`, + `effect`, `extern`, `module`). +- The **shared flavor-neutral body parser** + ([crates/osprey-syntax/src/docparse.rs](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-syntax/src/docparse.rs)): + summary/body split, recognised `#` sections, `@tag` aliases, `[Symbol]` link + extraction, and ```osprey```/```output``` doctest extraction. One parser, + both flavors. +- **Default `///` + `//!`** lowering for all six declaration forms + ([default/lower.rs](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-syntax/src/default/lower.rs)). +- **ML `(** … *)`** lexing (nesting, banner/empty disambiguation), CST/parser + threading, and lowering + ([ml/lexer.rs](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-syntax/src/ml/lexer.rs), + [ml/lower.rs](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-syntax/src/ml/lower.rs)) — this **closes the + `[FLAVOR-LOWER-CONTRACT]` breach**: the ML flavor previously dropped every + comment and hardcoded `doc: None`. +- **Cross-flavor equivalence** is machine-checked: a `///` Default function and + its `(** *)` ML twin lower to an identical `DocComment` + (`crates/osprey-cli/tests/cross_flavor_equiv.rs`). +- **LSP hover** renders the structured `DocComment` (summary, body, sections) + for every declaration kind in both flavors, and a **`[Symbol]` intra-doc link + under the cursor hovers to the referenced element** — bare (`[helper]`) and + dotted (`[Console.emit]`) ([crates/osprey-lsp/src/features.rs](https://github.com/Nimblesite/osprey/blob/main/crates/osprey-lsp/src/features.rs)). + +Remaining (tracked in [plan 0018](https://github.com/Nimblesite/osprey/blob/main/docs/plans/0018-documentation-comments.md) +Phase 3): + +- Doctest **execution**: the extractor populates `DocExample`s; wiring them into + the golden harness so their output is byte-checked is not yet done. +- `osprey --docs` exporting **user** declarations (it exports builtins today). +- `//!` module-scope grammar in the Default tree-sitter grammar (the lexer and + lowerer already recognise `//!`; adding the grammar attachment point is the + remainder). + +## References + +Full academic grounding for the design decisions above. Citations verified +against primary bibliographic records; where a detail is unverifiable it is +flagged rather than invented. + +**Literate programming — the lineage.** + +- Knuth, D. E. (1984). "Literate Programming." *The Computer Journal*, 27(2), + 97–111. DOI: [10.1093/comjnl/27.2.97](https://doi.org/10.1093/comjnl/27.2.97). + The founding thesis: programs are literature addressed to humans; code and + explanatory prose are interwoven at the source. +- Knuth, D. E. (1983). *The WEB System of Structured Documentation* (Stanford + CS Report STAN-CS-83-980). The tangle/weave architecture and automatic + cross-referencing — the concrete system behind the 1984 paper. +- Ramsey, N. (1994). "Literate Programming Simplified." *IEEE Software*, 11(5), + 97–105. DOI: [10.1109/52.311070](https://doi.org/10.1109/52.311070). + Argues for a minimal, language-independent documentation mechanism (the + *noweb* tool) — the principle behind one shared model across flavors. + +**API documentation — design and empirical evidence.** + +- Kramer, D. (1999). "API documentation from source code comments: a case study + of Javadoc." *Proc. SIGDOC '99*, 147–153. ACM. DOI: + [10.1145/318372.318577](https://doi.org/10.1145/318372.318577). The design + rationale for authoring API docs as structured, co-located source comments. +- Robillard, M. P. (2009). "What Makes APIs Hard to Learn? Answers from + Developers." *IEEE Software*, 26(6), 27–34. DOI: + [10.1109/MS.2009.193](https://doi.org/10.1109/MS.2009.193). The dominant + obstacle to learning an API is missing examples and missing intent — the + evidence for first-class example and rationale sections. +- Robillard, M. P., & DeLine, R. (2011). "A field study of API learning + obstacles." *Empirical Software Engineering*, 16(6), 703–732. DOI: + [10.1007/s10664-010-9150-8](https://doi.org/10.1007/s10664-010-9150-8). The + journal-length evidence base for documenting intent, examples, and task→API + mappings. +- Uddin, G., & Robillard, M. P. (2015). "How API Documentation Fails." *IEEE + Software*, 32(4), 68–75. DOI: + [10.1109/MS.2014.80](https://doi.org/10.1109/MS.2014.80). A taxonomy of + documentation failure modes — incompleteness, ambiguity, incorrectness, + obsolescence, fragmentation — that the structured sections and doctests are + designed to prevent. + +**Executable / semantically-integrated documentation.** + +- Wrenn, J., & Krishnamurthi, S. (2019). "Executable Examples for Programming + Problem Comprehension." *Proc. ICER '19*, 131–139. ACM. DOI: + [10.1145/3291279.3339416](https://doi.org/10.1145/3291279.3339416). Empirical + support that machine-checked examples improve comprehension — the case for + doctests. +- Flatt, M., Barzilay, E., & Findler, R. B. (2009). "Scribble: closing the book + on ad hoc documentation tools." *Proc. ICFP '09*, 109–120. ACM. DOI: + [10.1145/1596550.1596569](https://doi.org/10.1145/1596550.1596569). The + definitive argument for binding-aware documentation where cross-references are + resolved and examples run — the basis for `[Symbol]` intra-doc links and + executable examples. + +**Comments and program comprehension.** + +- Woodfield, S. N., Dunsmore, H. E., & Shen, V. Y. (1981). "The effect of + modularization and comments on program comprehension." *Proc. ICSE '81*, + 215–223. IEEE Press. (Pre-DOI proceedings; cite by pages.) The classic + controlled experiment showing comments causally improve comprehension. +- Tenny, T. (1988). "Program readability: procedures versus comments." *IEEE + Transactions on Software Engineering*, 14(9), 1271–1279. DOI: + [10.1109/32.6171](https://doi.org/10.1109/32.6171). Comments carry real + comprehension weight, complementary to structure. +- Steidl, D., Hummel, B., & Jürgens, E. (2013). "Quality analysis of source code + comments." *Proc. ICPC '13*, 83–92. IEEE. DOI: + [10.1109/ICPC.2013.6613836](https://doi.org/10.1109/ICPC.2013.6613836). A + machine-assessable model of comment quality — motivation for a precise model + over undefined "good docs." + +**A note on Markdown.** Osprey's doc body is CommonMark. Markdown has no +seminal peer-reviewed source; its lineage is Gruber's 2004 informal +specification and the later CommonMark specification, cited here as **informal +specifications**, explicitly distinct from the peer-reviewed sources above. The +*executable* and *binding-aware* aspects of the design rest on the scholarly +sources (Wrenn & Krishnamurthi; Flatt, Barzilay & Findler), not on Markdown +itself. \ No newline at end of file diff --git a/website/src/spec/index.md b/website/src/spec/index.md index 8e70b0e9..774afd25 100644 --- a/website/src/spec/index.md +++ b/website/src/spec/index.md @@ -2,7 +2,7 @@ layout: page title: "Osprey Language Specification" description: "Complete language specification and syntax reference for the Osprey programming language" -date: 2026-07-01 +date: 2026-07-12 tags: ["specification", "reference", "documentation"] author: "Christian Findlay" permalink: "/spec/" @@ -11,7 +11,7 @@ permalink: "/spec/" # Osprey Language Specification **Version:** 0.2.0 -**Date:** 2026-07-01 +**Date:** 2026-07-12 **Author:** Christian Findlay ## Table of Contents @@ -41,6 +41,7 @@ permalink: "/spec/" 23. [Language Flavors](/spec/0023-languageflavors/) 24. [ML Flavor Syntax](/spec/0024-mlflavorsyntax/) 25. [Modules and Namespaces](/spec/0025-modulesandnamespaces/) +26. [Documentation Comments](/spec/0026-documentationcomments/) ## About This Specification From 85ff06d3fe03b6ebb06ba214e9a9545195bd46f3 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Sun, 12 Jul 2026 21:25:20 +1000 Subject: [PATCH 05/17] fixes --- Cargo.lock | 1 + crates/osprey-cli/src/main.rs | 21 ++ crates/osprey-cli/src/project.rs | 47 ++++ crates/osprey-lsp/Cargo.toml | 1 + crates/osprey-lsp/src/diagnostics.rs | 249 +++++++++++++++++- crates/osprey-syntax/src/default/modules.rs | 47 ++++ crates/osprey-syntax/tests/ml_modules.rs | 177 +++++++++++++ docs/plans/0014-modules-and-namespaces.md | 15 +- docs/plans/README.md | 2 +- docs/specs/0025-ModulesAndNamespaces.md | 6 +- website/src/spec/0025-modulesandnamespaces.md | 6 +- 11 files changed, 559 insertions(+), 13 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f79ebf98..35b61872 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -420,6 +420,7 @@ dependencies = [ "lspkit-vfs", "osprey-ast", "osprey-fmt", + "osprey-project", "osprey-syntax", "osprey-types", "serde", diff --git a/crates/osprey-cli/src/main.rs b/crates/osprey-cli/src/main.rs index 57536727..5e8c6703 100644 --- a/crates/osprey-cli/src/main.rs +++ b/crates/osprey-cli/src/main.rs @@ -2028,6 +2028,11 @@ mod tests { let candidates = runtime_lib_candidates(lib, Some(&executable_dir)); let expected = root.join("compiler/bin").join(lib).display().to_string(); assert!(candidates.contains(&expected), "{candidates:?}"); + let fallbacks = runtime_lib_candidates(lib, None); + assert!(fallbacks.contains(&format!("/usr/local/lib/{lib}"))); + assert!(fallbacks + .iter() + .any(|path| path.ends_with("compiler/lib/libfiber_runtime.a"))); } #[cfg(unix)] @@ -2094,6 +2099,22 @@ mod tests { let _ = run(&cli(path, "--check", Policy::allow_all())); // parse-error branch } + #[test] + fn load_input_reports_project_and_module_assembly_errors() { + let missing = std::env::temp_dir() + .join(format!("osprey_cli_missing_{}", std::process::id())) + .join("osprey.toml"); + assert!(load_input(&cli( + missing.display().to_string(), + "--check", + Policy::allow_all() + )) + .is_err()); + let source = "module A { export let x = 1 }\nmodule A { export let x = 2 }\n"; + let path = temp_source("duplicate_module", source); + assert!(load_input(&cli(path, "--check", Policy::allow_all())).is_err()); + } + #[test] fn run_rejects_sandbox_violation_before_codegen() { let path = temp_source("fs", "let c = readFile(\"x.txt\")\n"); diff --git a/crates/osprey-cli/src/project.rs b/crates/osprey-cli/src/project.rs index b3a07bc8..400bca53 100644 --- a/crates/osprey-cli/src/project.rs +++ b/crates/osprey-cli/src/project.rs @@ -395,6 +395,25 @@ mod tests { let aggregated = aggregate_sources(&project); assert!(aggregated.contains("// @link: sqlite3")); assert!(aggregated.contains("// @linkdir: /opt/lib")); + + let input = CompilationInput::assembled( + project, + aggregated, + "demo".to_string(), + OutputDefault::Project { + root: PathBuf::from("out"), + name: "demo".to_string(), + }, + ); + assert_eq!(input.debug_path(), "first.osp"); + assert_eq!( + input.diagnostic(Some(Position { line: 2, column: 3 }), "bad"), + "first.osp:2:3: bad" + ); + assert_eq!( + input.output_path(None, "wasm32"), + PathBuf::from("out/demo.wasm") + ); } #[test] @@ -423,4 +442,32 @@ mod tests { assert!(!json.contains("reapp::maining")); assert!(json.contains("\"path\":\"src/main.osp\"")); } + + #[test] + fn project_errors_include_every_available_location_component() { + let cases = [ + ( + Some(PathBuf::from("src/a.osp")), + Some(2), + Some(3), + "src/a.osp:2:3: bad", + ), + (None, Some(4), None, "fallback:4: bad"), + ( + Some(PathBuf::from("src/b.osp")), + None, + Some(9), + "src/b.osp: bad", + ), + ]; + for (path, line, column, expected) in cases { + let error = ProjectError { + message: "bad".to_string(), + path, + line, + column, + }; + assert_eq!(format_project_error(&error, "fallback"), expected); + } + } } diff --git a/crates/osprey-lsp/Cargo.toml b/crates/osprey-lsp/Cargo.toml index a9e3e4c6..e9c11fc2 100644 --- a/crates/osprey-lsp/Cargo.toml +++ b/crates/osprey-lsp/Cargo.toml @@ -11,6 +11,7 @@ osprey-ast = { workspace = true } osprey-syntax = { workspace = true } osprey-types = { workspace = true } osprey-fmt = { workspace = true } +osprey-project = { workspace = true } # Reused lspkit building blocks (published on crates.io). [LSP-REUSE-LSPKIT] lspkit = { workspace = true } diff --git a/crates/osprey-lsp/src/diagnostics.rs b/crates/osprey-lsp/src/diagnostics.rs index 001eba97..c3f38da8 100644 --- a/crates/osprey-lsp/src/diagnostics.rs +++ b/crates/osprey-lsp/src/diagnostics.rs @@ -8,7 +8,9 @@ use lspkit_server::{Diagnostic, Severity}; use lspkit_vfs::PositionEncoding; -use osprey_ast::Position; +use osprey_ast::{Position, Program}; +use osprey_project::{AssembledProject, ProjectError}; +use std::path::{Path, PathBuf}; const SOURCE: &str = "osprey"; @@ -27,7 +29,18 @@ pub fn compute(source: &str, path: &str, encoding: PositionEncoding) -> Vec Vec { + osprey_types::check_program(program) .iter() .map(|e| { let pos = e.position.unwrap_or(Position { line: 1, column: 0 }); @@ -36,6 +49,143 @@ pub fn compute(source: &str, path: &str, encoding: PositionEncoding) -> Vec Option> { + let file = file_path(uri)?; + let root = project_root(&file)?; + let (config, mut sources) = match osprey_project::load(&root) { + Ok(loaded) => loaded, + Err(errors) => return Some(project_errors(source, &file, &errors, encoding)), + }; + let source_file = sources + .iter_mut() + .find(|candidate| same_path(&candidate.path, &file))?; + source_file.source = source.to_string(); + source_file.program = program.clone(); + match osprey_project::assemble(&config, &sources) { + Ok(project) => Some(assembled_type_errors(source, &file, &project, encoding)), + Err(errors) => Some(project_errors(source, &file, &errors, encoding)), + } +} + +fn assembled_type_errors( + source: &str, + file: &Path, + project: &AssembledProject, + encoding: PositionEncoding, +) -> Vec { + osprey_types::check_program(&project.program) + .iter() + .filter_map(|error| { + let position = if let Some(global) = error.position { + let (owner, line) = project.source_at_line(global.line)?; + same_path(&owner.path, file).then_some(Position { + line, + column: global.column, + })? + } else { + let is_entry = project + .entry() + .is_some_and(|entry| same_path(&entry.path, file)); + is_entry.then_some(Position { line: 1, column: 0 })? + }; + Some(diagnostic( + source, + position, + &error.message, + "type-error", + encoding, + )) + }) + .collect() +} + +fn project_errors( + source: &str, + file: &Path, + errors: &[ProjectError], + encoding: PositionEncoding, +) -> Vec { + errors + .iter() + .filter(|error| { + error + .path + .as_deref() + .is_none_or(|path| same_path(path, file)) + }) + .map(|error| { + let position = Position { + line: error + .line + .and_then(|line| u32::try_from(line).ok()) + .unwrap_or(1), + column: error + .column + .and_then(|column| u32::try_from(column).ok()) + .unwrap_or(0), + }; + diagnostic(source, position, &error.message, "project-error", encoding) + }) + .collect() +} + +fn project_root(file: &Path) -> Option { + file.parent()? + .ancestors() + .find(|directory| directory.join("osprey.toml").is_file()) + .map(Path::to_path_buf) +} + +fn same_path(left: &Path, right: &Path) -> bool { + let normalize = + |path: &Path| std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf()); + normalize(left) == normalize(right) +} + +fn file_path(uri: &str) -> Option { + let encoded = uri.strip_prefix("file://")?; + let decoded = percent_decode(encoded)?; + #[cfg(windows)] + let decoded = decoded + .strip_prefix('/') + .filter(|path| path.as_bytes().get(1) == Some(&b':')) + .unwrap_or(&decoded) + .to_string(); + Some(PathBuf::from(decoded)) +} + +fn percent_decode(encoded: &str) -> Option { + let bytes = encoded.as_bytes(); + let mut decoded = Vec::with_capacity(bytes.len()); + let mut index = 0; + while let Some(&byte) = bytes.get(index) { + if byte == b'%' { + let high = hex(*bytes.get(index.saturating_add(1))?)?; + let low = hex(*bytes.get(index.saturating_add(2))?)?; + decoded.push((high << 4) | low); + index = index.saturating_add(3); + } else { + decoded.push(byte); + index = index.saturating_add(1); + } + } + String::from_utf8(decoded).ok() +} + +const fn hex(byte: u8) -> Option { + match byte { + b'0'..=b'9' => Some(byte - b'0'), + b'a'..=b'f' => Some(byte - b'a' + 10), + b'A'..=b'F' => Some(byte - b'A' + 10), + _ => None, + } +} + /// Build one error diagnostic spanning the offending line from `pos` onward. fn diagnostic( source: &str, @@ -155,4 +305,99 @@ mod tests { assert!(u16.iter().all(|d| d.range.0 == 0)); assert!(u8.iter().all(|d| d.range.0 == 0)); } + + #[cfg(unix)] + #[test] + fn mixed_flavor_module_files_use_the_assembled_project_graph() { + let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); + for relative in [ + "examples/projects/modules/src/main.osp", + "examples/projects/modules/src/cream.ospml", + ] { + let path = root.join(relative); + let source = std::fs::read_to_string(&path).expect("read module example"); + let uri = format!("file://{}", path.display()); + let diagnostics = compute(&source, &uri, U16); + assert!(diagnostics.is_empty(), "{relative}: {diagnostics:?}"); + } + } + + #[cfg(unix)] + #[test] + fn project_diagnostics_map_resolution_and_type_errors_to_the_open_file() { + let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); + let cream_path = root.join("examples/projects/modules/src/cream.ospml"); + let cream = std::fs::read_to_string(&cream_path).expect("read ML module example"); + let unresolved = cream.replace( + "import \"billing/api\" as taxApi", + "import \"missing/api\" as taxApi", + ); + let diagnostics = compute( + &unresolved, + &format!("file://{}", cream_path.display()), + U16, + ); + assert!( + diagnostics + .iter() + .any(|item| item.code.as_deref() == Some("project-error")), + "{diagnostics:?}" + ); + + let main_path = root.join("examples/projects/modules/src/main.osp"); + let main = std::fs::read_to_string(&main_path).expect("read Default module example"); + let ill_typed = main.replace("let first = allocate()", "let first: int = \"wrong\""); + let diagnostics = compute(&ill_typed, &format!("file://{}", main_path.display()), U16); + assert!( + diagnostics + .iter() + .any(|item| item.code.as_deref() == Some("type-error")), + "{diagnostics:?}" + ); + + let source = "print(missing)\n"; + let project = AssembledProject { + program: osprey_syntax::parse_program(source).program, + entry_prologue: Vec::new(), + entry_source: 0, + sources: vec![osprey_project::SourceMetadata { + index: 0, + path: PathBuf::from("entry.osp"), + flavor: osprey_syntax::Flavor::Default, + source: source.to_string(), + global_line_start: 1, + global_line_end: 1, + }], + source_name_by_mangled: std::collections::BTreeMap::new(), + }; + let diagnostics = assembled_type_errors( + source, + Path::new("entry.osp"), + &project, + PositionEncoding::Utf16, + ); + assert!(!diagnostics.is_empty(), "{diagnostics:?}"); + assert!(assembled_type_errors( + source, + Path::new("other.osp"), + &project, + PositionEncoding::Utf16, + ) + .is_empty()); + } + + #[test] + fn file_uri_decoding_is_strict_and_handles_spaces() { + assert_eq!( + file_path("file:///tmp/with%20space/a.osp"), + Some(PathBuf::from("/tmp/with space/a.osp")) + ); + assert_eq!( + file_path("file:///tmp/with%2fslash.osp"), + Some(PathBuf::from("/tmp/with/slash.osp")) + ); + assert!(file_path("untitled:buffer").is_none()); + assert!(file_path("file:///tmp/bad%GG.osp").is_none()); + assert!(file_path("file:///tmp/truncated%.osp").is_none()); + } } diff --git a/crates/osprey-syntax/src/default/modules.rs b/crates/osprey-syntax/src/default/modules.rs index e7b2a1f8..25c9a754 100644 --- a/crates/osprey-syntax/src/default/modules.rs +++ b/crates/osprey-syntax/src/default/modules.rs @@ -410,6 +410,53 @@ mod tests { } } + #[test] + fn exported_docs_attach_to_every_declaration_and_repair_uppercase_opaque_aliases() { + let statements = parse( + "module Documented {\n\ + /// value docs\n\ + export let answer = 42\n\ + /// function docs\n\ + export fn identity(x) = x\n\ + /// extern docs\n\ + export extern fn log(message: string)\n\ + /// opaque type docs\n\ + export opaque type Token = Raw\n\ + /// effect docs\n\ + export effect Ping { ping: fn() -> Unit }\n\ + /// nested module docs\n\ + export module Inner { let value = 1 }\n\ + /// signature docs\n\ + export signature InnerApi { let value: int }\n\ + }\n", + ); + let Stmt::Module { body, .. } = &statements[0] else { + panic!("expected documented module") + }; + assert_eq!(body.len(), 7); + for item in body { + let doc = match item.declaration.as_ref() { + Stmt::Let { doc, .. } + | Stmt::Function { doc, .. } + | Stmt::Extern { doc, .. } + | Stmt::Type { doc, .. } + | Stmt::Effect { doc, .. } + | Stmt::Module { doc, .. } + | Stmt::Signature { doc, .. } => doc, + other => panic!("unexpected documented declaration: {other:?}"), + }; + assert!(doc.is_some(), "missing export doc on {item:?}"); + } + assert!(matches!( + body[3].declaration.as_ref(), + Stmt::Type { + alias: Some(alias), + variants, + .. + } if alias.name == "Raw" && variants.is_empty() + )); + } + #[test] fn lowers_qualified_paths_in_calls_types_and_interpolation() { let statements = parse( diff --git a/crates/osprey-syntax/tests/ml_modules.rs b/crates/osprey-syntax/tests/ml_modules.rs index 377a3391..e38fb545 100644 --- a/crates/osprey-syntax/tests/ml_modules.rs +++ b/crates/osprey-syntax/tests/ml_modules.rs @@ -278,3 +278,180 @@ fn parenthesised_cross_flavor_call_is_flat() { } if arguments.len() == 2 )); } + +#[test] +fn signature_values_effects_and_nested_modules_lower_completely() { + let statements = ok(concat!( + "signature Service\n", + " version : int\n", + " choose : (int, string) -> bool\n", + " effect Store T\n", + " get : Unit => T\n", + " module Nested : Contracts::NestedApi\n", + )); + + let Stmt::Signature { items, .. } = &statements[0] else { + panic!("expected signature, got {:?}", statements[0]); + }; + assert!(matches!( + &items[0], + SignatureItem::Value { name, ty, .. } if name == "version" && ty.name == "int" + )); + assert!(matches!( + &items[1], + SignatureItem::Function { + name, + parameters, + return_type, + .. + } if name == "choose" && parameters.len() == 2 && return_type.name == "bool" + )); + assert!(matches!( + &items[2], + SignatureItem::Effect { + name, + type_params, + operations, + .. + } if name == "Store" && type_params.len() == 1 && operations.len() == 1 + )); + assert!(matches!( + &items[3], + SignatureItem::Module { path, signature, .. } + if path.to_string() == "Nested" + && signature.path.to_string() == "Contracts::NestedApi" + && !signature.allow_extra + )); +} + +#[test] +fn module_declaration_docs_attach_to_every_supported_declaration() { + let statements = ok(concat!( + "module Documented\n", + " (** value docs *)\n", + " answer = 42\n", + " (** function docs *)\n", + " identity x = x\n", + " (** extern docs *)\n", + " extern log (message : string)\n", + " (** type docs *)\n", + " type Id = int\n", + " (** effect docs *)\n", + " effect Ping\n", + " ping : Unit => Unit\n", + " (** nested module docs *)\n", + " module Inner\n", + " value = 1\n", + " (** signature docs *)\n", + " signature InnerApi\n", + " value : int\n", + " (** import docs are deliberately discarded *)\n", + " import billing\n", + )); + + let Stmt::Module { body, .. } = &statements[0] else { + panic!("expected module, got {:?}", statements[0]); + }; + assert_eq!(body.len(), 8); + for declaration in &body[..7] { + let has_doc = match declaration.declaration.as_ref() { + Stmt::Let { doc, .. } + | Stmt::Function { doc, .. } + | Stmt::Extern { doc, .. } + | Stmt::Type { doc, .. } + | Stmt::Effect { doc, .. } + | Stmt::Module { doc, .. } + | Stmt::Signature { doc, .. } => doc.is_some(), + other => panic!("expected a documentable declaration, got {other:?}"), + }; + assert!(has_doc, "missing attached doc: {declaration:?}"); + } + assert!(matches!(body[7].declaration.as_ref(), Stmt::Import(_))); +} + +#[test] +fn malformed_module_heads_and_signature_items_recover_with_specific_errors() { + let missing_module_body = errors("module Empty\nnext = 1\n"); + assert!(missing_module_body + .iter() + .any(|error| error.contains("module declaration requires an indented body"))); + + let missing_signature_body = errors("signature Empty\nnext = 1\n"); + assert!(missing_signature_body + .iter() + .any(|error| error.contains("signature declaration requires an indented body"))); + + let missing_value_colon = errors("signature Api\n value int\n"); + assert!(missing_value_colon + .iter() + .any(|error| error.contains("expected ':' in signature value"))); + + let missing_module_colon = errors("signature Api\n module Child ChildApi\n"); + assert!(missing_module_colon + .iter() + .any(|error| error.contains("expected ':' in nested module signature item"))); + + let unexpected_item = errors("signature Api\n import billing\n"); + assert!(unexpected_item + .iter() + .any(|error| error.contains("unexpected token") && error.contains("signature"))); +} + +#[test] +fn malformed_import_projections_recover_with_specific_errors() { + let selected_alias = errors("import billing as b\n item\n"); + assert!(selected_alias + .iter() + .any(|error| error.contains("aliased whole import cannot also select members"))); + + let wildcard_tail = errors("import billing\n *\n item\n"); + assert!(wildcard_tail + .iter() + .any(|error| error.contains("wildcard import '*' must be the only selected member"))); + + let invalid_member = errors("import billing\n 42\n"); + assert!( + invalid_member + .iter() + .any(|error| error.contains("expected an identifier")), + "{invalid_member:?}" + ); + + let missing_segment = errors("import billing::\n"); + assert!(missing_segment + .iter() + .any(|error| error.contains("expected path segment after '::'"))); +} + +#[test] +fn invalid_export_opaque_and_namespace_forms_are_diagnosed() { + let duplicate_export = errors("module M\n export export x = 1\n"); + assert!(duplicate_export + .iter() + .any(|error| error.contains("duplicate 'export'"))); + + let invalid_export = errors("module M\n export import billing\n"); + assert!(invalid_export + .iter() + .any(|error| error.contains("'export' must modify"))); + + let invalid_opaque = errors("module M\n export opaque effect E\n"); + assert!(invalid_opaque + .iter() + .any(|error| error.contains("'opaque' may modify only a type declaration"))); + + let unexported_opaque = errors("module M\n opaque type Id = int\n"); + assert!(unexported_opaque + .iter() + .any(|error| error.contains("requires exactly one 'export opaque type'"))); + + let namespace_export = errors("export x = 1\n"); + assert!(namespace_export + .iter() + .any(|error| error.contains("namespace declarations are public by default"))); + + let invalid_namespace = errors("namespace 42\n"); + assert!(invalid_namespace + .iter() + .any(|error| error.contains("expected namespace name"))); +} diff --git a/docs/plans/0014-modules-and-namespaces.md b/docs/plans/0014-modules-and-namespaces.md index cb6c0819..6eead513 100644 --- a/docs/plans/0014-modules-and-namespaces.md +++ b/docs/plans/0014-modules-and-namespaces.md @@ -10,7 +10,8 @@ state. Namespaces are flat-first opaque labels; module/member qualification uses The compiler now has one shared module AST, both surface projections, a compiler-facing project resolver, deterministic flattening into the existing -checker/backend, project CLI commands, and module-aware same-document tooling. +checker/backend, project CLI commands, project-aware editor diagnostics, and +module-aware same-document navigation. The remaining work is listed explicitly below rather than hidden behind a generic "modules planned" status. @@ -24,8 +25,9 @@ generic "modules planned" status. resolved flat program for the existing type checker and backend. - `osprey build`, directory/manifest inputs, and module-aware single files work; ordinary scripts still bypass assembly unchanged. -- LSP/formatter/editor support understands module syntax within a document. - Incremental cross-file LSP indexing remains part of plan 0009. +- LSP diagnostics assemble the saved mixed-flavor project graph and overlay the + current document buffer; formatter/navigation understand module syntax within + a document. Incremental cross-file indexing remains part of plan 0009. - Opaque record/union boundaries retain nominal structure. Opaque manifest aliases are rejected loudly because the flat checker cannot yet expose their representation only to the owner without leaking its ABI to clients. @@ -105,7 +107,7 @@ TODO: TODO: - [x] Add `ProjectGraph` and assembled-project metadata in the compiler-facing - `osprey-project` crate, consumed by the CLI; LSP adoption remains below. + `osprey-project` crate, consumed by the CLI and LSP diagnostics. - [x] Read `osprey.toml` with `source_roots`, `default_namespace`, and module policy. Single-file mode remains unchanged. - [x] Scan `.osp` and `.ospml` files under source roots. @@ -195,6 +197,9 @@ TODO: ranked candidate suggestions remain. - [ ] LSP: maintain an incremental project graph across open files and source roots. +- [x] LSP: run diagnostics through the mixed-flavor project assembler, overlay + the current unsaved document, and map project/type errors back to its + physical local lines. - [x] LSP: same-document go-to-definition, references, hover, completion, and fully-qualified document symbols understand namespaces/modules/imports. Cross-file behavior depends on the incremental graph item above. @@ -223,6 +228,8 @@ TODO: tests. - [x] Add compile-fail project tests for namespace/plain-module/exported `mut`, duplicate/private boundaries, state scatter, and initializer failures. +- [x] Add LSP regressions proving the runnable mixed-flavor project has no false + cross-file diagnostics and real project/type errors map to the open file. - [ ] Add LSP integration tests for cross-file completion/hover/definition. - [ ] `make ci` green. diff --git a/docs/plans/README.md b/docs/plans/README.md index 786d6a92..4a45739d 100644 --- a/docs/plans/README.md +++ b/docs/plans/README.md @@ -21,7 +21,7 @@ repros. | [0011](0011-arc-gc-implementation.md) | Reclaiming memory backends (tracing GC + ARC) | codegen/runtime | Phase 1 conservative GC shipped (`--memory=gc`); Perceus ARC + Cheney + static-mode not started | High | | [0012](0012-osprey-debugger.md) | Modern Osprey debugger | compiler/editor/runtime | Spec written; Phase 1 source line debugging in progress | High | | [0013](0013-ml-flavor-frontend.md) | ML flavor frontend (layout syntax, curry-by-default) | frontend/types/codegen/tooling | Frontend shipped (68 `.ospml` twins, VSIX, equivalence tests); handler *values* + ML must-reject remain | Mostly done | -| [0014](0014-modules-and-namespaces.md) | Modules, namespaces & multi-file apps | frontend/resolver/types/codegen/lsp | Initial Default + ML project compiler is live; opaque manifest aliases and cross-file LSP/interface checking remain | High | +| [0014](0014-modules-and-namespaces.md) | Modules, namespaces & multi-file apps | frontend/resolver/types/codegen/lsp | Initial Default + ML project compiler and project-aware diagnostics are live; opaque manifest aliases, cross-file navigation, and interface checking remain | High | | [0015](0015-generics-and-variance.md) | Generics with `in`/`out` variance & generic effects | frontend/types/codegen (both flavors) | Core + generic-fn-values landed; turbofish + static seam remain | Mostly done | | [0016](0016-algebraic-effects-and-handlers.md) | Algebraic effects roadmap (resume/handler-values/multi-shot) | effects/types/codegen/runtime | Tail + single-shot resume + generic effects + multi-shot rejection + fiber-perform race fix + lambda-resume type error done; handler values, effect rows (incl. static unhandled-effect checks), wasm effects remain | High | diff --git a/docs/specs/0025-ModulesAndNamespaces.md b/docs/specs/0025-ModulesAndNamespaces.md index 54cab00a..c47eef84 100644 --- a/docs/specs/0025-ModulesAndNamespaces.md +++ b/docs/specs/0025-ModulesAndNamespaces.md @@ -18,9 +18,9 @@ it belongs to a project; it does **not** decide the names it exports. The initial module system is implemented end to end in both flavors. The shared AST, project loader, namespace graph, import/privacy/signature checks, resolved linkage names, state-owner validation, handler-local state materialization, -type checking, native/LLVM codegen, project CLI, formatter, and same-document -editor features are active. Mixed `.osp`/`.ospml` projects build and run through -the same canonical graph. +type checking, native/LLVM codegen, project CLI, formatter, project-aware +cross-file diagnostics, and same-document navigation features are active. Mixed +`.osp`/`.ospml` projects build and run through the same canonical graph. The implementation fails loudly at the remaining semantic boundaries. In particular, opaque manifest aliases are rejected rather than flattened to their diff --git a/website/src/spec/0025-modulesandnamespaces.md b/website/src/spec/0025-modulesandnamespaces.md index 7b732db1..3836a0ac 100644 --- a/website/src/spec/0025-modulesandnamespaces.md +++ b/website/src/spec/0025-modulesandnamespaces.md @@ -28,9 +28,9 @@ it belongs to a project; it does **not** decide the names it exports. The initial module system is implemented end to end in both flavors. The shared AST, project loader, namespace graph, import/privacy/signature checks, resolved linkage names, state-owner validation, handler-local state materialization, -type checking, native/LLVM codegen, project CLI, formatter, and same-document -editor features are active. Mixed `.osp`/`.ospml` projects build and run through -the same canonical graph. +type checking, native/LLVM codegen, project CLI, formatter, project-aware +cross-file diagnostics, and same-document navigation features are active. Mixed +`.osp`/`.ospml` projects build and run through the same canonical graph. The implementation fails loudly at the remaining semantic boundaries. In particular, opaque manifest aliases are rejected rather than flattened to their From c6577bc9f0e6aefb99776cab92c27d4323baa17e Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Sun, 12 Jul 2026 22:11:34 +1000 Subject: [PATCH 06/17] banking example --- crates/osprey-cli/tests/project_e2e.rs | 78 ++++++---- crates/osprey-lsp/src/diagnostics.rs | 26 ++-- examples/projects/modules/README.md | 128 +++++++++++++--- examples/projects/modules/e2e/.gitignore | 4 + .../projects/modules/e2e/package-lock.json | 76 ++++++++++ examples/projects/modules/e2e/package.json | 13 ++ .../projects/modules/e2e/playwright.config.js | 24 +++ .../projects/modules/e2e/tests/bank.spec.js | 118 +++++++++++++++ examples/projects/modules/expectedoutput | 26 +++- examples/projects/modules/osprey.toml | 6 +- .../projects/modules/src/api/routes.ospml | 136 +++++++++++++++++ examples/projects/modules/src/cream.ospml | 30 ---- .../modules/src/deep/unrelated/tax.osp | 12 -- .../modules/src/domain/accounts.ospml | 51 +++++++ .../projects/modules/src/domain/money.ospml | 40 +++++ .../projects/modules/src/lib/sqlite.ospml | 142 ++++++++++++++++++ examples/projects/modules/src/main.osp | 14 -- examples/projects/modules/src/main.ospml | 115 ++++++++++++++ .../projects/modules/src/store/ledger.ospml | 110 ++++++++++++++ .../projects/modules/src/store/metrics.ospml | 34 +++++ examples/projects/modules/src/web/pages.ospml | 104 +++++++++++++ 21 files changed, 1167 insertions(+), 120 deletions(-) create mode 100644 examples/projects/modules/e2e/.gitignore create mode 100644 examples/projects/modules/e2e/package-lock.json create mode 100644 examples/projects/modules/e2e/package.json create mode 100644 examples/projects/modules/e2e/playwright.config.js create mode 100644 examples/projects/modules/e2e/tests/bank.spec.js create mode 100644 examples/projects/modules/src/api/routes.ospml delete mode 100644 examples/projects/modules/src/cream.ospml delete mode 100644 examples/projects/modules/src/deep/unrelated/tax.osp create mode 100644 examples/projects/modules/src/domain/accounts.ospml create mode 100644 examples/projects/modules/src/domain/money.ospml create mode 100644 examples/projects/modules/src/lib/sqlite.ospml delete mode 100644 examples/projects/modules/src/main.osp create mode 100644 examples/projects/modules/src/main.ospml create mode 100644 examples/projects/modules/src/store/ledger.ospml create mode 100644 examples/projects/modules/src/store/metrics.ospml create mode 100644 examples/projects/modules/src/web/pages.ospml diff --git a/crates/osprey-cli/tests/project_e2e.rs b/crates/osprey-cli/tests/project_e2e.rs index d38e45db..a047c925 100644 --- a/crates/osprey-cli/tests/project_e2e.rs +++ b/crates/osprey-cli/tests/project_e2e.rs @@ -50,19 +50,47 @@ fn arg(path: &Path) -> String { path.to_string_lossy().into_owned() } +const FIXTURE_SOURCES: [&str; 9] = [ + "osprey.toml", + "src/main.ospml", + "src/lib/sqlite.ospml", + "src/domain/money.ospml", + "src/domain/accounts.ospml", + "src/store/ledger.ospml", + "src/store/metrics.ospml", + "src/api/routes.ospml", + "src/web/pages.ospml", +]; + fn copy_fixture(name: &str) -> PathBuf { let root = std::env::temp_dir().join(format!("osprey_project_e2e_{name}_{}", std::process::id())); let _ = std::fs::remove_dir_all(&root); - let deep = root.join("src/deep/unrelated"); - std::fs::create_dir_all(&deep).expect("create project directories"); - copy("osprey.toml", &root.join("osprey.toml")); - copy("src/main.osp", &root.join("src/main.osp")); - copy("src/cream.ospml", &root.join("src/cream.ospml")); - copy("src/deep/unrelated/tax.osp", &deep.join("tax.osp")); + for relative in FIXTURE_SOURCES { + let destination = root.join(relative); + if let Some(parent) = destination.parent() { + std::fs::create_dir_all(parent).expect("create project directories"); + } + copy(relative, &destination); + } root } +fn expected_output() -> String { + std::fs::read_to_string(fixture().join("expectedoutput")).expect("read expectedoutput fixture") +} + +/// The Talon Bank demo binds one fixed HTTP port and one `SQLite` file, so +/// the tests that actually execute it must not overlap in time. +fn demo_run_lock() -> std::sync::MutexGuard<'static, ()> { + static LOCK: std::sync::OnceLock> = std::sync::OnceLock::new(); + let _ = std::fs::remove_file("/tmp/talon_bank.hold"); + match LOCK.get_or_init(std::sync::Mutex::default).lock() { + Ok(guard) => guard, + Err(poisoned) => poisoned.into_inner(), + } +} + fn copy(relative: &str, destination: &Path) { let _ = std::fs::copy(fixture().join(relative), destination).expect("copy project fixture"); } @@ -89,25 +117,25 @@ fn directory_and_manifest_inputs_share_the_flat_project_pipeline() { let symbols = run(&[arg(&project), "--symbols".to_string()]); assert_eq!(symbols.code, Some(0), "stderr={}", symbols.stderr); assert!( - symbols.stdout.contains("billing/api::Tax::addTax"), + symbols.stdout.contains("bank/web::Pages::render"), "{}", symbols.stdout ); assert!(!symbols.stdout.contains("__osp_"), "{}", symbols.stdout); - assert_project_main_symbol_is_local(&symbols.stdout, &project.join("src/main.osp")); + assert_project_main_symbol_is_local(&symbols.stdout, &project.join("src/main.ospml")); } fn assert_project_main_symbol_is_local(json: &str, source: &Path) { let value = serde_json::from_str::(json).expect("valid symbols JSON"); let main = value.as_array().and_then(|entries| { entries.iter().find(|entry| { - entry.get("name").and_then(serde_json::Value::as_str) == Some("app::main") + entry.get("name").and_then(serde_json::Value::as_str) == Some("bank::main") }) }); let expected_line = std::fs::read_to_string(source) .expect("read entry source") .lines() - .position(|line| line.trim_start().starts_with("fn main")) + .position(|line| line.trim_start().starts_with("main () =")) .and_then(|line| u64::try_from(line.saturating_add(1)).ok()); assert_eq!( main.and_then(|entry| entry.get("line")) @@ -125,11 +153,12 @@ fn assert_project_main_symbol_is_local(json: &str, source: &Path) { } #[test] -fn mixed_flavor_path_independent_project_runs() { +fn bank_project_runs_byte_exact_against_expectedoutput() { + let _serialized = demo_run_lock(); let project = fixture(); let output = run(&[arg(&project), "--run".to_string()]); assert_eq!(output.code, Some(0), "stderr={}", output.stderr); - assert_eq!(output.stdout, "tax=110 counter=1/2\n"); + assert_eq!(output.stdout, expected_output()); } #[test] @@ -228,7 +257,7 @@ fn link_directives_from_a_non_entry_source_reach_the_native_driver() { use std::os::unix::fs::PermissionsExt; let project = copy_fixture("link_directives"); - let module = project.join("src/deep/unrelated/tax.osp"); + let module = project.join("src/store/ledger.ospml"); let source = std::fs::read_to_string(&module).expect("read non-entry source"); std::fs::write( &module, @@ -266,40 +295,35 @@ fn link_directives_from_a_non_entry_source_reach_the_native_driver() { #[test] fn build_subcommand_uses_project_name_inside_project_directory() { + let _serialized = demo_run_lock(); let project = copy_fixture("build"); - let artifact = project.join("modules"); + let artifact = project.join("talon-bank"); let output = run_in(&project, &["build", "--quiet"]); assert_eq!(output.code, Some(0), "stderr={}", output.stderr); assert!(artifact.is_file(), "missing {}", artifact.display()); let executed = Command::new(&artifact).output().expect("run built project"); assert!(executed.status.success()); - assert_eq!( - String::from_utf8_lossy(&executed.stdout), - "tax=110 counter=1/2\n" - ); + assert_eq!(String::from_utf8_lossy(&executed.stdout), expected_output()); let _ = std::fs::remove_dir_all(project); } #[test] fn flattened_type_errors_map_back_to_physical_local_lines() { let project = copy_fixture("diagnostic"); - let cream = project.join("src/cream.ospml"); - let source = std::fs::read_to_string(&cream).expect("read ML source"); - let broken = source.replace( - "export label cents = \"tax=${taxApi::Tax::addTax cents}\"", - "export label : int -> int\n label cents = \"tax=${taxApi::Tax::addTax cents}\"", - ); + let money = project.join("src/domain/money.ospml"); + let source = std::fs::read_to_string(&money).expect("read ML source"); + let broken = source.replace("show : int -> string", "show : int -> int"); assert_ne!(broken, source, "fixture mutation must change the ML source"); let line = broken .lines() - .position(|line| line.contains("label cents =")) + .position(|line| line.contains("show cents =")) .map_or(0, |line| line.saturating_add(1)); - std::fs::write(&cream, broken).expect("write broken ML source"); + std::fs::write(&money, broken).expect("write broken ML source"); let output = run(&[arg(&project), "--check".to_string()]); assert_ne!(output.code, Some(0)); - let expected = format!("{}:{line}:", cream.display()); + let expected = format!("{}:{line}:", money.display()); assert!(output.stderr.contains(&expected), "{}", output.stderr); let _ = std::fs::remove_dir_all(project); } diff --git a/crates/osprey-lsp/src/diagnostics.rs b/crates/osprey-lsp/src/diagnostics.rs index c3f38da8..99bc4cfb 100644 --- a/crates/osprey-lsp/src/diagnostics.rs +++ b/crates/osprey-lsp/src/diagnostics.rs @@ -308,11 +308,11 @@ mod tests { #[cfg(unix)] #[test] - fn mixed_flavor_module_files_use_the_assembled_project_graph() { + fn module_files_use_the_assembled_project_graph() { let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); for relative in [ - "examples/projects/modules/src/main.osp", - "examples/projects/modules/src/cream.ospml", + "examples/projects/modules/src/main.ospml", + "examples/projects/modules/src/web/pages.ospml", ] { let path = root.join(relative); let source = std::fs::read_to_string(&path).expect("read module example"); @@ -326,17 +326,13 @@ mod tests { #[test] fn project_diagnostics_map_resolution_and_type_errors_to_the_open_file() { let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../.."); - let cream_path = root.join("examples/projects/modules/src/cream.ospml"); - let cream = std::fs::read_to_string(&cream_path).expect("read ML module example"); - let unresolved = cream.replace( - "import \"billing/api\" as taxApi", - "import \"missing/api\" as taxApi", - ); - let diagnostics = compute( - &unresolved, - &format!("file://{}", cream_path.display()), - U16, + let main_path = root.join("examples/projects/modules/src/main.ospml"); + let main = std::fs::read_to_string(&main_path).expect("read ML module example"); + let unresolved = main.replace( + "import \"bank/web\" as web", + "import \"missing/web\" as web", ); + let diagnostics = compute(&unresolved, &format!("file://{}", main_path.display()), U16); assert!( diagnostics .iter() @@ -344,9 +340,7 @@ mod tests { "{diagnostics:?}" ); - let main_path = root.join("examples/projects/modules/src/main.osp"); - let main = std::fs::read_to_string(&main_path).expect("read Default module example"); - let ill_typed = main.replace("let first = allocate()", "let first: int = \"wrong\""); + let ill_typed = main.replace("served = Metrics::track boot", "served = Metrics::track 42"); let diagnostics = compute(&ill_typed, &format!("file://{}", main_path.display()), U16); assert!( diagnostics diff --git a/examples/projects/modules/README.md b/examples/projects/modules/README.md index 93d10233..f51ed12a 100644 --- a/examples/projects/modules/README.md +++ b/examples/projects/modules/README.md @@ -1,23 +1,117 @@ -# Mixed-flavour modules +# Talon Bank — the Osprey modules showcase -This project exercises Osprey's logical module graph end to end: +A complete, layered banking application in ML-flavor Osprey. One +`osprey.toml` project, eight source files, every module-system feature doing +real work: a SQLite library over the C FFI (with a bound prepared-statement +cursor API), a double-entry journal, a storage capability as an algebraic +effect, a JSON API over the data (`/api/accounts`, `/api/activity`, deposits, +withdrawals, transfers, overdraft refusals), and a server-driven web +dashboard — stat tiles, accounts, a color-coded activity feed — that is +*provably* unable to touch the database. -- `"billing/api"::Tax` is written in Default Osprey under the intentionally - unrelated physical path `src/deep/unrelated/tax.osp`; the slash label is one - opaque namespace name, not a folder hierarchy. -- `billing::Greeting` and the signature-ascribed `billing::Counter` state module - are written in the ML flavour; `Greeting` aliases the quoted namespace and - imports Default's `Tax::addTax` through `taxApi::Tax::addTax`. -- the Default entry imports both ML modules, proving interop in both directions - through one shared ABI and namespace model. -- `Counter` state is instantiated by `run` and touched only by `CounterFx` - handler arms. Importing it allocates and mutates nothing. -- `CounterFake` handles the same exported effect without owning mutable state, - so tests can swap the installer while application logic stays unchanged. +Spec: [docs/specs/0025-ModulesAndNamespaces.md](../../../docs/specs/0025-ModulesAndNamespaces.md) · +Plan: [docs/plans/0014-modules-and-namespaces.md](../../../docs/plans/0014-modules-and-namespaces.md) -Run it from the repository root: +## Run it ```sh -target/release/osprey build examples/projects/modules -o /tmp/osprey-modules -/tmp/osprey-modules +target/release/osprey examples/projects/modules --run ``` + +Output is deterministic and byte-compared against `expectedoutput` by +`crates/osprey-cli/tests/project_e2e.rs`. + +## Architecture + +``` +src/ + lib/sqlite.ospml module Sqlite SQLite library: C FFI externs + typed helpers + domain/money.ospml module Money pure cents arithmetic (signature-ascribed) + domain/accounts.ospml module Accounts Account record, Outcome union, pure rules + store/ledger.ospml module Ledger effect Store (capability) + SQL implementations + store/metrics.ospml state Metrics the namespace's ONE state module (request counter) + api/routes.ospml module Api JSON routes + effect Audit; performs Store + web/pages.ospml module Pages server-driven HTML; sees ONLY bank::Api + main.ospml (entry) composition root: binds every capability +``` + +The dependency arrows only point down, and the module system enforces them: + +``` +web ("bank/web") ──imports──▶ api ──performs──▶ Ledger::Store ──SQL──▶ Sqlite ──▶ libsqlite3 + │ + └──performs──▶ Api::Audit (bound to console in main) +``` + +- **The UI never talks to the database.** `web/pages.ospml` imports only + `bank::Api`. There is no `Ledger` or `Sqlite` path in scope, so a database + call from the UI is not merely bad style — it does not resolve. +- **Storage is a capability.** `Ledger::Store` is an algebraic effect. The api + layer `perform`s it; only `main.ospml` decides what a `debit` physically is. + An unhandled operation is a compile error. Swapping SQLite for an in-memory + fake is a main-only edit. +- **Refusal is a domain outcome, not an error.** `debit` returns the + `Outcome` union (`Landed`/`Refused`); every caller pattern-matches it + exhaustively, and an overdraft surfaces as HTTP 422 with a reason. +- **Double-entry journal.** Every movement — refusals included — lands as a + bound-parameter row in `entries`; a transfer writes both sides. The activity + feed is an audit ledger, not a best-effort log. +- **One state owner.** `state Metrics` owns the only mutable cell in the app. + The cell is readable and writable exclusively inside its own effect's + handler arms, and that region exists only while the exported installer + (`track`) is running. + +## Module-system features exercised + +| Feature | Where | +|---|---| +| File-scoped `namespace` | every file (`namespace bank`) | +| Quoted namespace + alias import | `web/pages.ospml` (`namespace "bank/web"`), `import "bank/web" as web` in main | +| Cross-file namespace merging | `Account`/`Outcome` declared in domain, used in api with no import | +| `module` with `export` markers | Sqlite, Accounts, Ledger, Api, Pages | +| Signature-ascribed module (no redundant exports) | `module Money : MoneyApi` | +| Signature-ascribed **state** module | `state Metrics : MetricsApi` | +| Effect declared in a signature | `MetricsApi.MetricsFx` | +| Effect exported from a module | `Ledger::Store`, `Api::Audit` | +| Effect rows on module exports | `route : … ! [Ledger::Store, Audit]` | +| Handler installer + private cells | `Metrics::track` | +| Qualified paths in perform/handle | `perform Ledger::Store.debit`, `handle Api::Audit` | +| Member imports | `import bank::Sqlite`, etc. | +| Multi-file project manifest | `osprey.toml` (`source_roots`, `default_namespace`, `entry`) | +| `@link` directive from a non-entry file | `lib/sqlite.ospml` links `sqlite3` | + +## Browser end-to-end tests (Playwright) + +```sh +cd examples/projects/modules/e2e +npm install && npx playwright install chromium +npx playwright test +``` + +The suite boots the real compiled binary (the `/tmp/talon_bank.hold` marker +file pauses the demo just before shutdown so the server stays up), then +drives Chromium through the dashboard and the JSON API: seeded balances, +styled rendering, an overdraft refusal (422), and the server-driven proof +that an API mutation appears on the next rendered page. + +## Known compiler defects encountered (worked around here, not fixed) + +Found while building this app; each reproduces in a few lines. The module +system itself needed **zero** workarounds. + +1. **`deleteFile` is a phantom builtin** — typed in + `crates/osprey-types/src/builtins.rs` but absent from the runtime, so any + use fails at link time. Workaround: idempotent `DROP TABLE IF EXISTS`. +2. **`Result` loses its variant tag through effect `resume`** — a handler arm + returning `Error(…)` for an op typed `… => Result` matches + `Success` at the perform site with a garbage payload. User-defined unions + round-trip correctly, which is why `debit` returns the domain `Outcome` + union instead. +3. **`HttpResponse` field readback corrupts** — constructing an + `HttpResponse` and then reading a string field back (e.g. `.partialBody`) + yields garbage or a segfault. Custom records are unaffected. Workaround: + `Api::accountsJson` hands the web layer the JSON string directly. +4. **Undocumented HTTP contract** — the `headers` string of a server + `HttpResponse` is spliced verbatim into the wire response, so every header + line must be CRLF-terminated (`"Content-Type: text/html; charset=utf-8\r\n"`), + or browsers receive a mangled header block and fall back to text/plain. diff --git a/examples/projects/modules/e2e/.gitignore b/examples/projects/modules/e2e/.gitignore new file mode 100644 index 00000000..f1f884a0 --- /dev/null +++ b/examples/projects/modules/e2e/.gitignore @@ -0,0 +1,4 @@ +node_modules/ +test-results/ +playwright-report/ +dashboard.png diff --git a/examples/projects/modules/e2e/package-lock.json b/examples/projects/modules/e2e/package-lock.json new file mode 100644 index 00000000..1d1d43d8 --- /dev/null +++ b/examples/projects/modules/e2e/package-lock.json @@ -0,0 +1,76 @@ +{ + "name": "talon-bank-e2e", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "talon-bank-e2e", + "devDependencies": { + "@playwright/test": "^1.40.0" + } + }, + "node_modules/@playwright/test": { + "version": "1.61.1", + "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.61.1.tgz", + "integrity": "sha512-8nKv6+0RJSL9FE4jYOEGXnPeM/Hg12qZpmqzZjRh3qM0Y7c3z1mrOTfFLids72RDQYVh9WpLEfR5WdpNX4fkig==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright": "1.61.1" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/playwright": { + "version": "1.61.1", + "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.61.1.tgz", + "integrity": "sha512-DWnY5o3YbLWK4GovuAVwpqL+1VwGNdUGrRr++8j8PtQQzvAVZUIMjKQ90fY689sEJZJBbZVw1rXaOKSTitkzPQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "playwright-core": "1.61.1" + }, + "bin": { + "playwright": "cli.js" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "fsevents": "2.3.2" + } + }, + "node_modules/playwright-core": { + "version": "1.61.1", + "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.61.1.tgz", + "integrity": "sha512-h7Qlt6m4REp25qvIdvbDtVmD4LqVXfpRxhORv9L0jzETM05p4fuPJ3dKyuSXQxDSbXnmS79HAgi9589lGSpLkg==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "playwright-core": "cli.js" + }, + "engines": { + "node": ">=18" + } + } + } +} diff --git a/examples/projects/modules/e2e/package.json b/examples/projects/modules/e2e/package.json new file mode 100644 index 00000000..d46ce929 --- /dev/null +++ b/examples/projects/modules/e2e/package.json @@ -0,0 +1,13 @@ +{ + "name": "talon-bank-e2e", + "private": true, + "description": "Playwright end-to-end tests for the Talon Bank Osprey modules showcase", + "scripts": { + "test": "playwright test", + "test:headed": "playwright test --headed", + "install-browsers": "playwright install chromium" + }, + "devDependencies": { + "@playwright/test": "^1.40.0" + } +} diff --git a/examples/projects/modules/e2e/playwright.config.js b/examples/projects/modules/e2e/playwright.config.js new file mode 100644 index 00000000..8be474d3 --- /dev/null +++ b/examples/projects/modules/e2e/playwright.config.js @@ -0,0 +1,24 @@ +// Playwright config for the Talon Bank showcase. The webServer block owns the +// app lifecycle: it creates the hold marker so the Osprey demo pauses while +// serving, then removes it on teardown so the binary finishes its run. +const { defineConfig } = require('@playwright/test'); + +module.exports = defineConfig({ + testDir: './tests', + timeout: 30_000, + fullyParallel: false, + workers: 1, + reporter: [['list']], + use: { + baseURL: 'http://127.0.0.1:18790', + screenshot: 'only-on-failure', + }, + webServer: { + command: + 'touch /tmp/talon_bank.hold && trap "rm -f /tmp/talon_bank.hold" EXIT && ../../../../target/release/osprey ../.. --run', + cwd: __dirname, + url: 'http://127.0.0.1:18790/api/accounts', + reuseExistingServer: false, + timeout: 20_000, + }, +}); diff --git a/examples/projects/modules/e2e/tests/bank.spec.js b/examples/projects/modules/e2e/tests/bank.spec.js new file mode 100644 index 00000000..3a34e844 --- /dev/null +++ b/examples/projects/modules/e2e/tests/bank.spec.js @@ -0,0 +1,118 @@ +// End-to-end tests for Talon Bank: a real browser against the real compiled +// Osprey binary — server-driven HTML, the JSON API, domain refusals, the +// double-entry activity journal, and the architecture rule that the UI +// reflects exactly what the API serves. +const { test, expect } = require('@playwright/test'); + +test.describe.configure({ mode: 'serial' }); + +test.describe('JSON API over the data', () => { + test('lists the seeded accounts with machine and display money', async ({ request }) => { + const reply = await request.get('/api/accounts'); + expect(reply.status()).toBe(200); + const accounts = await reply.json(); + expect(accounts).toEqual([ + { id: 1, owner: 'Amelia Chen', cents: 246240, balance: '$2,462.40' }, + { id: 2, owner: 'Marcus Webb', cents: 191785, balance: '$1,917.85' }, + { id: 3, owner: 'Priya Sharma', cents: 360000, balance: '$3,600.00' }, + ]); + }); + + test('journals every movement, refusals included, newest first', async ({ request }) => { + const reply = await request.get('/api/activity'); + expect(reply.status()).toBe(200); + const feed = await reply.json(); + expect(feed).toHaveLength(7); + expect(feed[0]).toEqual({ + kind: 'refused', + cents: 999900, + note: 'vintage synthesizer', + owner: 'Marcus Webb', + }); + // The transfer is double-entry: one debit, one credit, same note. + const dinner = feed.filter((entry) => entry.note === 'dinner split'); + expect(dinner.map((entry) => entry.kind).sort()).toEqual(['credit', 'debit']); + }); + + test('refuses an overdraft with 422 and a domain reason', async ({ request }) => { + const reply = await request.post('/api/withdraw', { + data: { account: 3, cents: 99999999, note: 'yacht' }, + }); + expect(reply.status()).toBe(422); + expect(await reply.json()).toEqual({ error: 'insufficient funds' }); + }); + + test('refuses an unnamed account with 422', async ({ request }) => { + const reply = await request.post('/api/accounts', { data: {} }); + expect(reply.status()).toBe(422); + expect(await reply.json()).toEqual({ error: 'owner name required' }); + }); + + test('404s unknown endpoints', async ({ request }) => { + const reply = await request.get('/api/nope'); + expect(reply.status()).toBe(404); + }); +}); + +test.describe('server-driven web UI', () => { + test('renders tiles, accounts, and the activity feed from the API', async ({ page }) => { + await page.goto('/'); + await expect(page).toHaveTitle('Talon Bank'); + await expect(page.locator('h1')).toContainText('Talon Bank'); + + const tiles = page.locator('.tile'); + await expect(tiles).toHaveCount(3); + await expect(tiles.nth(0)).toContainText('$7,980.25'); + await expect(tiles.nth(1)).toContainText('3'); + + const rows = page.locator('tbody tr'); + await expect(rows).toHaveCount(3); + await expect(rows.nth(0)).toContainText('Amelia Chen'); + await expect(rows.nth(0)).toContainText('$2,462.40'); + await expect(rows.nth(2)).toContainText('Priya Sharma'); + + const refusal = page.locator('.feed li.refused', { hasText: 'vintage synthesizer' }); + await expect(refusal).toHaveCount(1); + await expect(refusal).toContainText('Marcus Webb'); + await expect(refusal).toContainText('$9,999.00'); + await expect(page.locator('footer')).toContainText('holds no database capability'); + }); + + test('is styled, not a bare document', async ({ page }) => { + await page.goto('/'); + const bg = await page + .locator('body') + .evaluate((el) => getComputedStyle(el).backgroundColor); + expect(bg).toBe('rgb(11, 18, 32)'); + const money = await page + .locator('.money') + .first() + .evaluate((el) => getComputedStyle(el).color); + expect(money).toBe('rgb(125, 219, 163)'); + const refusedAmount = await page + .locator('.refused .amt') + .first() + .evaluate((el) => getComputedStyle(el).textDecorationLine); + expect(refusedAmount).toBe('line-through'); + await page.screenshot({ path: 'dashboard.png', fullPage: true }); + }); + + test('mutations through the API appear on the next server-rendered page', async ({ + page, + request, + }) => { + const deposit = await request.post('/api/deposit', { + data: { account: 3, cents: 25, note: 'browser e2e top-up' }, + }); + expect(deposit.status()).toBe(200); + await page.goto('/'); + await expect(page.locator('tbody tr').nth(2)).toContainText('$3,600.25'); + await expect(page.locator('.feed li').first()).toContainText('browser e2e top-up'); + }); + + test('unknown paths get the 404 page', async ({ page }) => { + const reply = await page.goto('/nowhere'); + expect(reply.status()).toBe(200); + await expect(page.locator('h1')).toHaveText('404'); + }); +}); diff --git a/examples/projects/modules/expectedoutput b/examples/projects/modules/expectedoutput index 4781b4aa..0ed7b038 100644 --- a/examples/projects/modules/expectedoutput +++ b/examples/projects/modules/expectedoutput @@ -1 +1,25 @@ -tax=110 counter=1/2 +=== Talon Bank — one Osprey app, every module feature === +[boot] fresh ledger at /tmp/talon_bank.db +[boot] api + web listening on http://127.0.0.1:18790 +[audit] account #1 opened for Amelia Chen +[audit] account #2 opened for Marcus Webb +[audit] account #3 opened for Priya Sharma +[audit] deposit $4,250.00 -> account #1 (March salary — Nimble Robotics) +[audit] deposit $1,980.25 -> account #2 (freelance invoice #4021) +[audit] deposit $3,600.00 -> account #3 (research grant Q1) +[audit] withdraw $1,850.00 from account #1 (rent — 12 Fern St) +[audit] transfer $62.40 account #2 -> account #1 (dinner split) +[audit] withdraw $9,999.00 from account #2 REFUSED (insufficient funds) +[http] open=201/201/201 deposit=200/200/200 rent=200 transfer=200 overdraft=422 +--- GET /api/accounts --- +[{"id":1,"owner":"Amelia Chen","cents":246240,"balance":"$2,462.40"},{"id":2,"owner":"Marcus Webb","cents":191785,"balance":"$1,917.85"},{"id":3,"owner":"Priya Sharma","cents":360000,"balance":"$3,600.00"}] +--- GET /api/activity --- +[{"kind":"refused","cents":999900,"note":"vintage synthesizer","owner":"Marcus Webb"},{"kind":"credit","cents":6240,"note":"dinner split","owner":"Amelia Chen"},{"kind":"debit","cents":6240,"note":"dinner split","owner":"Marcus Webb"},{"kind":"debit","cents":185000,"note":"rent — 12 Fern St","owner":"Amelia Chen"},{"kind":"credit","cents":360000,"note":"research grant Q1","owner":"Priya Sharma"},{"kind":"credit","cents":198025,"note":"freelance invoice #4021","owner":"Marcus Webb"},{"kind":"credit","cents":425000,"note":"March salary — Nimble Robotics","owner":"Amelia Chen"}] +--- GET / (server-driven ui) --- +html=true title=true vault=true feedRefusal=true +┌────┬──────────────┬───────────┐ +│ 1 │ Amelia Chen │ $2,462.40 │ +│ 2 │ Marcus Webb │ $1,917.85 │ +│ 3 │ Priya Sharma │ $3,600.00 │ +└────┴──────────────┴───────────┘ +[metrics] 12 requests served — goodbye diff --git a/examples/projects/modules/osprey.toml b/examples/projects/modules/osprey.toml index 15bfd5b2..e29dc1db 100644 --- a/examples/projects/modules/osprey.toml +++ b/examples/projects/modules/osprey.toml @@ -1,8 +1,8 @@ [project] -name = "modules" +name = "talon-bank" source_roots = ["src"] -default_namespace = "billing" -entry = "src/main.osp" +default_namespace = "bank" +entry = "src/main.ospml" [modules] allow_wildcard_imports = false diff --git a/examples/projects/modules/src/api/routes.ospml b/examples/projects/modules/src/api/routes.ospml new file mode 100644 index 00000000..0014168a --- /dev/null +++ b/examples/projects/modules/src/api/routes.ospml @@ -0,0 +1,136 @@ +// api/routes — the JSON API over the data. [MODULES-IMPORT] [MODULES-EFFECTS] +// +// The ONLY layer that talks to storage, and it does so purely through the +// `Ledger::Store` capability — this file never imports the Sqlite library, +// so it cannot bypass the effect surface even by accident. The import graph +// IS the architecture, and the compiler enforces it. +// +// The module exports its own cross-cutting `Audit` effect: every mutation is +// announced as a domain fact, and the composition root decides what an audit +// line physically is (here: a console log). + +namespace bank + +import bank::Accounts +import bank::Ledger +import bank::Money + +// `Account` itself needs no import: this file shares `namespace bank` with +// domain/accounts.ospml, and one namespace is one logical declaration space +// no matter how many physical files contribute to it. [MODULES-NAMESPACE] + +module Api + export effect Audit + log : string => Unit + + // The `headers` string is spliced verbatim into the wire response, so + // each header line must carry its own CRLF terminator. + json : int -> string -> HttpResponse + json status body = HttpResponse(status = status, headers = "Content-Type: application/json\r\n", contentType = "application/json", streamFd = -1, isComplete = true, partialBody = body) + + refuse : string -> HttpResponse + refuse why = json 422 "{\"error\":\"${why}\"}" + + // Pull one string field out of a JSON request body. + field : string -> string -> string + field body path = + doc = jsonParse body + v = match jsonGet doc path + Success value => value + Error message => "" + freed = jsonFree doc + v + + num : string -> string -> int + num body path = match parseInt (field body path) + Success value => value + Error message => 0 + + load : int -> Account ! Ledger::Store + load id = Account(id = id, owner = perform Ledger::Store.owner id, balance = perform Ledger::Store.balance id) + + // Render accounts 1..count as a JSON array, recursively — no loops, no state. + rows : int -> int -> string ! Ledger::Store + rows id count = match id > count + true => "" + false => + sep = match id < count + true => "," + false => "" + "${Accounts::json (load id)}${sep}${rows (id + 1) count}" + + onOpen : string -> HttpResponse ! [Ledger::Store, Audit] + onOpen body = + name = field body "name" + match Accounts::namable name + false => refuse "owner name required" + true => + id = perform Ledger::Store.open name + perform Audit.log "account #${id} opened for ${name}" + json 201 (Accounts::json (load id)) + + onDeposit : string -> HttpResponse ! [Ledger::Store, Audit] + onDeposit body = + id = num body "account" + cents = num body "cents" + note = field body "note" + match Accounts::movable cents + false => refuse "amount must be positive" + true => + balance = perform Ledger::Store.credit id cents note + perform Audit.log "deposit ${Money::show cents} -> account #${id} (${note})" + json 200 (Accounts::json (load id)) + + onWithdraw : string -> HttpResponse ! [Ledger::Store, Audit] + onWithdraw body = + id = num body "account" + cents = num body "cents" + note = field body "note" + attempt = perform Ledger::Store.debit id cents note + match attempt + Landed balance => + perform Audit.log "withdraw ${Money::show cents} from account #${id} (${note})" + json 200 (Accounts::json (load id)) + Refused why => + perform Audit.log "withdraw ${Money::show cents} from account #${id} REFUSED (${why})" + refuse why + + // A transfer COMPOSES the capability: debit then credit, atomically + // refused when funds are missing. Business flow lives here, not in SQL. + onTransfer : string -> HttpResponse ! [Ledger::Store, Audit] + onTransfer body = + from = num body "from" + to = num body "to" + cents = num body "cents" + note = field body "note" + attempt = perform Ledger::Store.debit from cents note + match attempt + Refused why => + perform Audit.log "transfer ${Money::show cents} account #${from} -> account #${to} REFUSED (${why})" + refuse why + Landed balance => + landed = perform Ledger::Store.credit to cents note + perform Audit.log "transfer ${Money::show cents} account #${from} -> account #${to} (${note})" + json 200 "[${Accounts::json (load from)},${Accounts::json (load to)}]" + + // The canonical JSON views, exported on their own so the web layer can + // consume the API in-process without unwrapping HTTP envelopes. + export accountsJson : Unit -> string ! Ledger::Store + accountsJson () = "[${rows 1 (perform Ledger::Store.count ())}]" + + export activityJson : Unit -> string ! Ledger::Store + activityJson () = perform Ledger::Store.activity () + + export route : string -> string -> string -> HttpResponse ! [Ledger::Store, Audit] + route method path body = match method + "GET" => match path + "/api/accounts" => json 200 (accountsJson ()) + "/api/activity" => json 200 (activityJson ()) + _ => json 404 "{\"error\":\"no such endpoint\"}" + "POST" => match path + "/api/accounts" => onOpen body + "/api/deposit" => onDeposit body + "/api/withdraw" => onWithdraw body + "/api/transfer" => onTransfer body + _ => json 404 "{\"error\":\"no such endpoint\"}" + _ => json 404 "{\"error\":\"no such endpoint\"}" diff --git a/examples/projects/modules/src/cream.ospml b/examples/projects/modules/src/cream.ospml deleted file mode 100644 index 7d95e5c9..00000000 --- a/examples/projects/modules/src/cream.ospml +++ /dev/null @@ -1,30 +0,0 @@ -namespace billing - -import "billing/api" as taxApi - -module Greeting - export label cents = "tax=${taxApi::Tax::addTax cents}" - -signature CounterApi - effect CounterFx - next : Unit => int - run : (Unit -> Unit) -> Unit - -state Counter : CounterApi - mut count = 0 - - effect CounterFx - next : Unit => int - - run action = - handle CounterFx - next => - count := count + 1 - count - in action () - -module CounterFake - export run action = - handle Counter::CounterFx - next => 41 - in action () diff --git a/examples/projects/modules/src/deep/unrelated/tax.osp b/examples/projects/modules/src/deep/unrelated/tax.osp deleted file mode 100644 index e13fc17b..00000000 --- a/examples/projects/modules/src/deep/unrelated/tax.osp +++ /dev/null @@ -1,12 +0,0 @@ -namespace "billing/api"; - -signature TaxApi { - fn addTax(cents: int) -> int -} - -module Tax : TaxApi { - let defaultRate = 10 - - fn addTax(cents) = - cents + defaultRate -} diff --git a/examples/projects/modules/src/domain/accounts.ospml b/examples/projects/modules/src/domain/accounts.ospml new file mode 100644 index 00000000..e5ee05a0 --- /dev/null +++ b/examples/projects/modules/src/domain/accounts.ospml @@ -0,0 +1,51 @@ +// domain/accounts — the PURE core of the bank. [MODULES-MODULE] +// +// A record type shared across every layer, plus the business rules and the +// canonical renderings of an account (JSON for the API, a table row for the +// TUI). No effects, no IO, no state: every export is a pure function, so this +// module is trivially testable and reusable from any layer above it. + +namespace bank + +import bank::Money + +type Account = + id : int + owner : string + balance : int + +// A refused movement is a DOMAIN OUTCOME, not an error: the union makes both +// futures first-class values that every layer must pattern-match exhaustively. +type Outcome = + Landed + balance : int + Refused + why : string + +module Accounts + // Domain rule: an account must be opened with a non-empty owner name. + export namable : string -> bool + namable owner = length owner > 0 + + // Domain rule: money can only move in positive whole-cent amounts. + export movable : int -> bool + movable cents = Money::positive cents + + // Both the machine field (`cents`) and the display field (`balance`), so + // API consumers never re-parse formatted money. + export json : Account -> string + json a = "{\"id\":${a.id},\"owner\":\"${a.owner}\",\"cents\":${a.balance},\"balance\":\"${Money::show a.balance}\"}" + + // One TUI table row: `│ 1 │ Amelia Chen │ $2,462.40 │` + export row : Account -> string + row a = + owner = match padEnd a.owner 12 " " + Success value => value + Error message => a.owner + cash = match padStart (Money::show a.balance) 9 " " + Success value => value + Error message => Money::show a.balance + id = match padStart (toString a.id) 2 " " + Success value => value + Error message => toString a.id + "│ ${id} │ ${owner} │ ${cash} │" diff --git a/examples/projects/modules/src/domain/money.ospml b/examples/projects/modules/src/domain/money.ospml new file mode 100644 index 00000000..b88822b9 --- /dev/null +++ b/examples/projects/modules/src/domain/money.ospml @@ -0,0 +1,40 @@ +// domain/money — PURE money arithmetic and formatting. [MODULES-SIGNATURE] +// +// `Money : MoneyApi` is a signature-ascribed module: the signature is its +// complete public surface, so nothing inside carries an `export` marker and +// nothing beyond the signature can leak. Every function is a pure expression — +// amounts are integer cents, so there is no floating-point drift anywhere in +// the bank. + +namespace bank + +signature MoneyApi + show : int -> string + positive : int -> bool + +module Money : MoneyApi + // "$4,250.05" — cents are zero-padded via the two-digit remainder and + // dollars are thousands-grouped by recursion. `/` is float division in + // Osprey, so all of this runs on `intDiv`. + pennies : int -> string + pennies c = match c % 100 < 10 + true => "0${c % 100}" + false => "${c % 100}" + + triple : int -> string + triple n = match n < 10 + true => "00${n}" + false => match n < 100 + true => "0${n}" + false => "${n}" + + group : int -> string + group dollars = match dollars < 1000 + true => "${dollars}" + false => "${group (intDiv dollars 1000)},${triple (dollars % 1000)}" + + show : int -> string + show cents = "$${group (intDiv cents 100)}.${pennies cents}" + + positive : int -> bool + positive cents = cents > 0 diff --git a/examples/projects/modules/src/lib/sqlite.ospml b/examples/projects/modules/src/lib/sqlite.ospml new file mode 100644 index 00000000..3f8ca65f --- /dev/null +++ b/examples/projects/modules/src/lib/sqlite.ospml @@ -0,0 +1,142 @@ +// lib/sqlite — the SQLite LIBRARY. [MODULES-MODULE] +// +// A reusable database layer built from nothing but Osprey's generic C FFI: +// every call is a plain `extern` bound to the SQLite C API, linked by the +// `// @link:` directive below. The module exports a small typed surface +// (open/run/queryInt/queryText/…) and keeps the raw pointer choreography +// (out-param cells, bind/step/finalize) private behind the module boundary. +// Values are always BOUND (`?`), never interpolated — injection is +// structurally impossible. +// +// @link: sqlite3 + +namespace bank + +// --- SQLite C API (https://sqlite.org/cintro.html) --- +extern sqlite3_open (filename : string) (ppDb : Ptr) -> int +extern sqlite3_exec (db : Ptr) (sql : string) (cb : Ptr) (arg : Ptr) (errmsg : Ptr) -> int +extern sqlite3_prepare_v2 (db : Ptr) (sql : string) (nByte : int) (ppStmt : Ptr) (tail : Ptr) -> int +extern sqlite3_bind_int (stmt : Ptr) (idx : int) (val : int) -> int +extern sqlite3_bind_text (stmt : Ptr) (idx : int) (val : string) (nByte : int) (destructor : Ptr) -> int +extern sqlite3_step (stmt : Ptr) -> int +extern sqlite3_column_int (stmt : Ptr) (col : int) -> int +extern sqlite3_column_text (stmt : Ptr) (col : int) -> string +extern sqlite3_last_insert_rowid (db : Ptr) -> int +extern sqlite3_finalize (stmt : Ptr) -> int +extern sqlite3_close (db : Ptr) -> int + +// --- generic FFI pointer helpers (compiler/runtime/ffi_runtime.c) --- +extern osprey_ffi_cell -> Ptr +extern osprey_ffi_deref (cell : Ptr) -> Ptr +extern osprey_ffi_free (cell : Ptr) -> int +extern osprey_ffi_null -> Ptr +extern osprey_ffi_transient -> Ptr + +module Sqlite + // prepare is PRIVATE: callers never see statement pointers, only values. + prepare : Ptr -> string -> Ptr + prepare db sql = + cell = osprey_ffi_cell () + rc = sqlite3_prepare_v2 db sql (0 - 1) cell (osprey_ffi_null ()) + stmt = osprey_ffi_deref cell + freed = osprey_ffi_free cell + stmt + + // bind positional (int, text) then run to completion — private plumbing. + runBound : Ptr -> string -> int -> string -> int + runBound db sql i t = + stmt = prepare db sql + b1 = sqlite3_bind_int stmt 1 i + b2 = sqlite3_bind_text stmt 2 t (0 - 1) (osprey_ffi_transient ()) + rc = sqlite3_step stmt + fin = sqlite3_finalize stmt + rc + + export openAt : string -> Ptr + openAt path = + cell = osprey_ffi_cell () + rc = sqlite3_open path cell + db = osprey_ffi_deref cell + freed = osprey_ffi_free cell + db + + // Run one statement with no result rows (DDL, DELETE, BEGIN/COMMIT). + export run : Ptr -> string -> int + run db sql = sqlite3_exec db sql (osprey_ffi_null ()) (osprey_ffi_null ()) (osprey_ffi_null ()) + + // INSERT with one bound int and one bound text; returns the new rowid. + export insertIntText : Ptr -> string -> int -> string -> int + insertIntText db sql i t = + rc = runBound db sql i t + sqlite3_last_insert_rowid db + + // UPDATE with two bound ints; returns the step result code. + export updateIntInt : Ptr -> string -> int -> int -> int + updateIntInt db sql a b = + stmt = prepare db sql + b1 = sqlite3_bind_int stmt 1 a + b2 = sqlite3_bind_int stmt 2 b + rc = sqlite3_step stmt + fin = sqlite3_finalize stmt + rc + + // SELECT one int scalar with one bound int (first row, first column). + export queryInt : Ptr -> string -> int -> int + queryInt db sql key = + stmt = prepare db sql + b1 = sqlite3_bind_int stmt 1 key + rc = sqlite3_step stmt + v = sqlite3_column_int stmt 0 + fin = sqlite3_finalize stmt + v + + // SELECT one text scalar with one bound int. The column pointer is only + // valid until finalize, so the text is copied into a fresh Osprey string + // (via interpolation) BEFORE the statement is finalized. + export queryText : Ptr -> string -> int -> string + queryText db sql key = + stmt = prepare db sql + b1 = sqlite3_bind_int stmt 1 key + rc = sqlite3_step stmt + v = "${sqlite3_column_text stmt 0}" + fin = sqlite3_finalize stmt + v + + // SELECT one int scalar with no bound parameters (e.g. COUNT(*)). + export queryScalar : Ptr -> string -> int + queryScalar db sql = + stmt = prepare db sql + rc = sqlite3_step stmt + v = sqlite3_column_int stmt 0 + fin = sqlite3_finalize stmt + v + + // --- cursor API: multi-row reads without exposing pointer plumbing --- + // `query` hands back a live statement; callers walk it with `step` + // (SQLITE_ROW = 100 means a row landed), read typed columns, and MUST + // `closeQuery` when done. + export query : Ptr -> string -> Ptr + query db sql = prepare db sql + + export bindIntAt : Ptr -> int -> int -> int + bindIntAt cursor idx val = sqlite3_bind_int cursor idx val + + export bindTextAt : Ptr -> int -> string -> int + bindTextAt cursor idx val = sqlite3_bind_text cursor idx val (0 - 1) (osprey_ffi_transient ()) + + export step : Ptr -> int + step cursor = sqlite3_step cursor + + export intAt : Ptr -> int -> int + intAt cursor col = sqlite3_column_int cursor col + + // Copied into a fresh Osprey string immediately: the column pointer dies + // with the next step/finalize. + export textAt : Ptr -> int -> string + textAt cursor col = "${sqlite3_column_text cursor col}" + + export closeQuery : Ptr -> int + closeQuery cursor = sqlite3_finalize cursor + + export shutdown : Ptr -> int + shutdown db = sqlite3_close db diff --git a/examples/projects/modules/src/main.osp b/examples/projects/modules/src/main.osp deleted file mode 100644 index bc07936a..00000000 --- a/examples/projects/modules/src/main.osp +++ /dev/null @@ -1,14 +0,0 @@ -namespace app; - -import billing::Greeting as Greeting -import billing::Counter::{CounterFx, run} - -fn allocate() = - perform CounterFx.next() - -fn main() = - run(action: fn() => { - let first = allocate() - let second = allocate() - print("${Greeting::label(100)} counter=${first}/${second}") - }) diff --git a/examples/projects/modules/src/main.ospml b/examples/projects/modules/src/main.ospml new file mode 100644 index 00000000..cdec9bd5 --- /dev/null +++ b/examples/projects/modules/src/main.ospml @@ -0,0 +1,115 @@ +// main — the COMPOSITION ROOT. [MODULES-EXPORTS] [MODULES-STATE-MODULE] +// +// The only file allowed to know everything. Here — and nowhere else — the +// abstract `Ledger::Store` capability is bound to its SQLite implementation, +// `Api::Audit` is bound to the console, and the `Metrics` state module's +// installer opens the one region where request counting may mutate. The +// layers underneath stay pure and swappable; rewiring the bank is a +// main-only edit. + +namespace bank + +import bank::Sqlite +import bank::Ledger +import bank::Api +import bank::Metrics +import "bank/web" as web + +// One deterministic tour of the whole stack, driven over REAL HTTP by the +// in-process client: JSON mutations, a refused overdraft, the JSON listing, +// and the server-driven HTML dashboard. +fetch : int -> string -> string +fetch client path = + reply = httpGetResponse client path "" + match reply + Success value => + body = match httpResponseBody value + Success text => text + Error message => "(no body)" + freed = httpResponseFree value + body + Error message => "GET ${path} failed" + +drive : int -> Unit +drive client = + amelia = httpPost client "/api/accounts" "{\"name\":\"Amelia Chen\"}" "" + marcus = httpPost client "/api/accounts" "{\"name\":\"Marcus Webb\"}" "" + priya = httpPost client "/api/accounts" "{\"name\":\"Priya Sharma\"}" "" + salary = httpPost client "/api/deposit" "{\"account\":1,\"cents\":425000,\"note\":\"March salary — Nimble Robotics\"}" "" + invoice = httpPost client "/api/deposit" "{\"account\":2,\"cents\":198025,\"note\":\"freelance invoice #4021\"}" "" + grant = httpPost client "/api/deposit" "{\"account\":3,\"cents\":360000,\"note\":\"research grant Q1\"}" "" + rent = httpPost client "/api/withdraw" "{\"account\":1,\"cents\":185000,\"note\":\"rent — 12 Fern St\"}" "" + dinner = httpPost client "/api/transfer" "{\"from\":2,\"to\":1,\"cents\":6240,\"note\":\"dinner split\"}" "" + synth = httpPost client "/api/withdraw" "{\"account\":2,\"cents\":999900,\"note\":\"vintage synthesizer\"}" "" + print "[http] open=${amelia}/${marcus}/${priya} deposit=${salary}/${invoice}/${grant} rent=${rent} transfer=${dinner} overdraft=${synth}" + print "--- GET /api/accounts ---\n${fetch client "/api/accounts"}" + print "--- GET /api/activity ---\n${fetch client "/api/activity"}" + page = fetch client "/" + print "--- GET / (server-driven ui) ---\nhtml=${startsWith page ""} title=${contains page "Talon Bank"} vault=${contains page "$7,980.25"} feedRefusal=${contains page "vintage synthesizer"}" + +// Playwright hold: while /tmp/talon_bank.hold exists the server keeps serving +// and the demo pauses right here — remove the file (or never create it) and +// the run finishes deterministically with identical stdout either way. +hold : Unit -> int +hold () = + marker = readFile "/tmp/talon_bank.hold" + match marker + Error message => 0 + Success value => + slept = sleep 250 + hold () + +// The TUI closing shot: render every account as a table row through the same +// pure domain renderer the API uses. +table : int -> int -> Unit ! Ledger::Store +table id count = match id > count + true => print "└────┴──────────────┴───────────┘" + false => + account = Account(id = id, owner = perform Ledger::Store.owner id, balance = perform Ledger::Store.balance id) + print (Accounts::row account) + table (id + 1) count + +// Everything below runs inside the Metrics installer's handler region, so +// the request counter cell exists exactly as long as the bank is serving. +boot : Unit -> int ! Metrics::MetricsFx +boot () = + db = Sqlite::openAt "/tmp/talon_bank.db" + made = Ledger::schema db + print "[boot] fresh ledger at /tmp/talon_bank.db" + handle Ledger::Store + open name => Ledger::openSql db name + credit id cents note => Ledger::creditSql db id cents note + debit id cents note => Ledger::debitSql db id cents note + balance id => Ledger::balanceSql db id + owner id => Ledger::ownerSql db id + count => Ledger::countSql db + activity => Ledger::activitySql db + in handle Api::Audit + log line => print "[audit] ${line}" + in + server = httpCreateServer 18790 "127.0.0.1" + listening = httpListen server handleRequest + client = httpCreateClient "http://127.0.0.1:18790" 5000 + print "[boot] api + web listening on http://127.0.0.1:18790" + drive client + print "┌────┬──────────────┬───────────┐" + table 1 (perform Ledger::Store.count ()) + held = hold () + stopped = httpStopServer server + closed = Sqlite::shutdown db + perform Metrics::MetricsFx.total () + +// The router: every request is counted by the state module, then dispatched — +// `/api/*` to the JSON API, everything else to the server-driven web UI. +handleRequest : string -> string -> string -> string -> HttpResponse +handleRequest (method, path, headers, body) = + seen = perform Metrics::MetricsFx.hit path + match startsWith path "/api" + true => Api::route method path body + false => web::Pages::render path + +main () = + print "=== Talon Bank — one Osprey app, every module feature ===" + served = Metrics::track boot + print "[metrics] ${served} requests served — goodbye" + 0 diff --git a/examples/projects/modules/src/store/ledger.ospml b/examples/projects/modules/src/store/ledger.ospml new file mode 100644 index 00000000..d1544402 --- /dev/null +++ b/examples/projects/modules/src/store/ledger.ospml @@ -0,0 +1,110 @@ +// store/ledger — the STORAGE CAPABILITY. [MODULES-EFFECTS] +// +// `Store` is an algebraic effect exported from this module: it is the ONLY way +// any layer above can reach the ledger. App code says WHAT it needs +// (`perform Ledger::Store.credit …`); the composition root in main.ospml +// decides HOW, by installing handler arms that pair each operation with the +// SQL implementation exported below. Unhandled operations are COMPILE errors, +// and swapping SQLite for a fake is a main-only change — the api/ and web/ +// layers never know. +// +// The bank is DOUBLE-ENTRY at the storage level: every movement — including +// a refused one — lands as a row in `entries`, so the activity feed is a +// faithful audit ledger, not a best-effort log. +// +// The SQL functions take the open database as an explicit `Ptr` parameter, so +// this module stays stateless and pure-by-construction. [MODULES-STATE-SOURCE-OF-TRUTH] + +namespace bank + +import bank::Sqlite + +module Ledger + // The capability surface. `debit` is fallible — overdrafts are refused — + // so its operation returns the domain `Outcome` union the caller must + // pattern-match exhaustively. + export effect Store + open : string => int + credit : (int, int, string) => int + debit : (int, int, string) => Outcome + balance : int => int + owner : int => string + count : Unit => int + activity : Unit => string + + // Idempotent reset-and-create: the demo starts from a known-empty ledger + // no matter what a previous run left in the database file. + export schema : Ptr -> int + schema db = + droppedEntries = Sqlite::run db "DROP TABLE IF EXISTS entries" + droppedAccounts = Sqlite::run db "DROP TABLE IF EXISTS accounts" + accounts = Sqlite::run db "CREATE TABLE accounts (id INTEGER PRIMARY KEY, owner TEXT NOT NULL, balance INTEGER NOT NULL DEFAULT 0)" + Sqlite::run db "CREATE TABLE entries (id INTEGER PRIMARY KEY, account INTEGER NOT NULL, kind TEXT NOT NULL, cents INTEGER NOT NULL, note TEXT NOT NULL)" + + // Every movement is journalled, refusals included — all four values + // BOUND through the library's prepared-statement cursor, never spliced. + journal : Ptr -> int -> string -> int -> string -> int + journal db account kind cents note = + cursor = Sqlite::query db "INSERT INTO entries (account, kind, cents, note) VALUES (?, ?, ?, ?)" + b1 = Sqlite::bindIntAt cursor 1 account + b2 = Sqlite::bindTextAt cursor 2 kind + b3 = Sqlite::bindIntAt cursor 3 cents + b4 = Sqlite::bindTextAt cursor 4 note + stepped = Sqlite::step cursor + Sqlite::closeQuery cursor + + export openSql : Ptr -> string -> int + openSql db name = Sqlite::insertIntText db "INSERT INTO accounts (balance, owner) VALUES (?, ?)" 0 name + + export creditSql : Ptr -> int -> int -> string -> int + creditSql db id cents note = + rc = Sqlite::updateIntInt db "UPDATE accounts SET balance = balance + ? WHERE id = ?" cents id + entry = journal db id "credit" cents note + balanceSql db id + + // A debit is transactional and guarded: the UPDATE only fires when the + // funds exist, and the row-check decides commit versus refusal. Either + // way the attempt is journalled. + export debitSql : Ptr -> int -> int -> string -> Outcome + debitSql db id cents note = + before = balanceSql db id + match before < cents + true => + entry = journal db id "refused" cents note + Refused(why = "insufficient funds") + false => + begun = Sqlite::run db "BEGIN IMMEDIATE" + rc = Sqlite::updateIntInt db "UPDATE accounts SET balance = balance - ? WHERE id = ?" cents id + entry = journal db id "debit" cents note + done = Sqlite::run db "COMMIT" + Landed(balance = balanceSql db id) + + export balanceSql : Ptr -> int -> int + balanceSql db id = Sqlite::queryInt db "SELECT balance FROM accounts WHERE id = ?" id + + export ownerSql : Ptr -> int -> string + ownerSql db id = Sqlite::queryText db "SELECT owner FROM accounts WHERE id = ?" id + + export countSql : Ptr -> int + countSql db = Sqlite::queryScalar db "SELECT COUNT(*) FROM accounts" + + // Walk the journal newest-first with the library's cursor API and render + // it as the JSON the API serves. SQLITE_ROW is 100. + feedRows : Ptr -> string -> string + feedRows cursor sep = + stepped = Sqlite::step cursor + match stepped == 100 + false => "" + true => + kind = Sqlite::textAt cursor 0 + cents = Sqlite::intAt cursor 1 + note = Sqlite::textAt cursor 2 + who = Sqlite::textAt cursor 3 + "${sep}{\"kind\":\"${kind}\",\"cents\":${cents},\"note\":\"${note}\",\"owner\":\"${who}\"}${feedRows cursor ","}" + + export activitySql : Ptr -> string + activitySql db = + cursor = Sqlite::query db "SELECT e.kind, e.cents, e.note, a.owner FROM entries e JOIN accounts a ON a.id = e.account ORDER BY e.id DESC LIMIT 8" + listing = feedRows cursor "" + closed = Sqlite::closeQuery cursor + "[${listing}]" diff --git a/examples/projects/modules/src/store/metrics.ospml b/examples/projects/modules/src/store/metrics.ospml new file mode 100644 index 00000000..3b57d3cd --- /dev/null +++ b/examples/projects/modules/src/store/metrics.ospml @@ -0,0 +1,34 @@ +// store/metrics — the namespace's ONE state module. [MODULES-STATE-MODULE] +// +// `state Metrics : MetricsApi` owns the only durable mutable cell in the +// whole bank. The cell is private by construction: it can be touched ONLY +// inside the handler arms of the module's own exported effect, and that +// handler region exists only while the exported installer (`track`) is +// running. Importing this module allocates nothing; each `track` call +// instantiates a fresh `served` cell for exactly that region. +// [MODULES-STATE-SOURCE-OF-TRUTH] + +namespace bank + +signature MetricsApi + effect MetricsFx + hit : string => int + total : Unit => int + track : (Unit -> int) -> int + +state Metrics : MetricsApi + mut served = 0 + + effect MetricsFx + hit : string => int + total : Unit => int + + // The handler installer: wraps a request-serving body in the one region + // allowed to read and write `served`. + track body = + handle MetricsFx + hit path => + served := served + 1 + served + total => served + in body () diff --git a/examples/projects/modules/src/web/pages.ospml b/examples/projects/modules/src/web/pages.ospml new file mode 100644 index 00000000..8750ff86 --- /dev/null +++ b/examples/projects/modules/src/web/pages.ospml @@ -0,0 +1,104 @@ +// web/pages — the SERVER-DRIVEN UI. [MODULES-NAMESPACE] [MODULES-IMPORT] +// +// This layer lives in its own quoted namespace, `"bank/web"`, and its imports +// are the whole architecture story: it can see `bank::Api` (plus the pure +// `bank::Money` domain formatter) and nothing else. There is no Ledger +// import, no Sqlite import, no Store capability in scope — the UI CANNOT +// talk to the database, because the module system won't resolve a path to +// it. Every byte it renders comes from the same JSON the API serves to +// external clients, consumed in-process via `Api::accountsJson` / +// `Api::activityJson`. + +namespace "bank/web" + +import bank::Api +import bank::Money + +module Pages + // The `headers` string is spliced verbatim into the wire response, so + // each header line must carry its own CRLF terminator. + html : string -> HttpResponse + html body = HttpResponse(status = 200, headers = "Content-Type: text/html; charset=utf-8\r\n", contentType = "text/html", streamFd = -1, isComplete = true, partialBody = body) + + // The design system, inlined: dark ledger-paper navy, osprey-gold accents, + // tabular numerals for money. One request, zero external assets. + style : Unit -> string + style () = "" + + // One per account, straight off the API's JSON — recursion over the + // parsed document, no mutation anywhere. + accountRows : int -> int -> string + accountRows doc i = + owner = jsonGet doc "[${i}].owner" + match owner + Error message => "" + Success value => + id = match jsonGet doc "[${i}].id" + Success n => n + Error nope => "?" + cash = match jsonGet doc "[${i}].balance" + Success money => money + Error nope => "?" + "#${id}${value}${cash}${accountRows doc (i + 1)}" + + // Accumulator recursion: the running sum rides the argument list, so the + // checked `+` auto-unwraps at the call site. + vault : int -> int -> int -> int + vault doc i acc = + cents = jsonGet doc "[${i}].cents" + match cents + Error message => acc + Success value => + held = match parseInt value + Success n => n + Error nope => 0 + vault doc (i + 1) (acc + held) + + mark : string -> string + mark kind = match kind + "credit" => "+" + "debit" => "–" + _ => "✕" + + // One feed line per journal entry, newest first, styled by kind. + feedItems : int -> int -> string + feedItems doc i = + kind = jsonGet doc "[${i}].kind" + match kind + Error message => "" + Success value => + note = match jsonGet doc "[${i}].note" + Success text => text + Error nope => "?" + who = match jsonGet doc "[${i}].owner" + Success name => name + Error nope => "?" + cents = match jsonGet doc "[${i}].cents" + Success raw => match parseInt raw + Success n => n + Error bad => 0 + Error nope => 0 + "
  • ${mark value}${note}${who}${Money::show cents}
    • ${feedItems doc (i + 1)}" + + tiles : int -> int -> string + tiles accountsDoc activityDoc = + held = vault accountsDoc 0 0 + "
    ${Money::show held}total on deposit
    ${jsonLength accountsDoc ""}accounts
    ${jsonLength activityDoc ""}journalled movements
    " + + // No effect row is spelled here: the checker infers that rendering needs + // whatever the Api views need. This file never names the storage + // capability — it genuinely does not know it exists. + dashboard () = + accounts = Api::accountsJson () + activity = Api::activityJson () + accountsDoc = jsonParse accounts + activityDoc = jsonParse activity + page = "Talon Bank${style ()}

    ◭ Talon Bank

    capability-checked banking, compiled by Osprey

    ${tiles accountsDoc activityDoc}

    Accounts

    ${accountRows accountsDoc 0}
    No.OwnerBalance

    Activity

      ${feedItems activityDoc 0}
    server-driven — rendered from /api/accounts + /api/activity, the UI holds no database capability
    " + freedAccounts = jsonFree accountsDoc + freedActivity = jsonFree activityDoc + html page + + export render : string -> HttpResponse + render path = match path + "/" => dashboard () + _ => html "

    404

    " From 8f52617622736f4451b42f9be412f78e7c167331 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Sun, 12 Jul 2026 22:27:50 +1000 Subject: [PATCH 07/17] stuff --- .github/workflows/ci.yml | 21 ++ Makefile | 11 +- crates/osprey-cli/tests/project_e2e.rs | 3 +- docs/specs/0027-TestingFramework.md | 270 ++++++++++++++++++ examples/projects/modules/README.md | 8 +- .../projects/modules/e2e/tests/bank.spec.js | 21 ++ .../projects/modules/src/api/routes.ospml | 5 +- .../modules/src/domain/accounts.ospml | 9 +- .../projects/modules/src/domain/json.ospml | 61 ++++ .../projects/modules/src/store/ledger.ospml | 4 +- 10 files changed, 403 insertions(+), 10 deletions(-) create mode 100644 docs/specs/0027-TestingFramework.md create mode 100644 examples/projects/modules/src/domain/json.ospml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 97fa0664..4a17fbfb 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -64,6 +64,7 @@ jobs: vscode-extension/package-lock.json webcompiler/package-lock.json website/package-lock.json + examples/projects/modules/e2e/package-lock.json # Rust toolchain + clang/LLVM + C runtime archives + the osprey binary. - name: Setup Osprey Compiler @@ -106,6 +107,26 @@ jobs: - name: Test run: xvfb-run -a make test + # Talon Bank modules showcase (examples/projects/modules): real Chromium + # drives the compiled osprey binary serving its HTTP API and web UI. + - name: Install bank e2e dependencies + run: npm ci + working-directory: ./examples/projects/modules/e2e + - name: Install Playwright Chromium + run: npx playwright install --with-deps chromium + working-directory: ./examples/projects/modules/e2e + - name: Bank e2e (Playwright) + run: npx playwright test + working-directory: ./examples/projects/modules/e2e + - name: Upload bank e2e results on failure + uses: actions/upload-artifact@v4 + if: failure() + with: + name: bank-e2e-results + path: examples/projects/modules/e2e/test-results/ + if-no-files-found: ignore + retention-days: 7 + - name: Upload test logs on failure uses: actions/upload-artifact@v4 if: failure() diff --git a/Makefile b/Makefile index 6904c42b..a0894cda 100644 --- a/Makefile +++ b/Makefile @@ -118,6 +118,13 @@ test: build $(MAKE) _test_vscode_extension $(MAKE) _coverage_check_vscode_extension +## bank-e2e: Browser end-to-end tests for the Talon Bank modules showcase +## (examples/projects/modules) — real Chromium via Playwright drives +## the compiled osprey binary serving its HTTP API and web UI. +bank-e2e: build + @echo "==> Bank e2e (Playwright)..." + cd examples/projects/modules/e2e && npm ci && npx playwright install chromium && npx playwright test + ## lint: Run all linters/analyzers (read-only). Does NOT format. lint: deslop @echo "==> Linting..." @@ -150,8 +157,8 @@ clean: $(RM) $(RTB) compiler/lib outputs lcov.info test.log cd $(EXT_DIR) && $(RM) out dist coverage test.log -## ci: lint + test + build (full CI simulation) -ci: lint test build +## ci: lint + test + bank-e2e + build (full CI simulation) +ci: lint test bank-e2e build ## wasm: Build everything for the WebAssembly target, ready to go — the wasm ## runtime archive (compiler/bin/libosprey_runtime_wasm.a), the hello example, diff --git a/crates/osprey-cli/tests/project_e2e.rs b/crates/osprey-cli/tests/project_e2e.rs index a047c925..d5281022 100644 --- a/crates/osprey-cli/tests/project_e2e.rs +++ b/crates/osprey-cli/tests/project_e2e.rs @@ -50,12 +50,13 @@ fn arg(path: &Path) -> String { path.to_string_lossy().into_owned() } -const FIXTURE_SOURCES: [&str; 9] = [ +const FIXTURE_SOURCES: [&str; 10] = [ "osprey.toml", "src/main.ospml", "src/lib/sqlite.ospml", "src/domain/money.ospml", "src/domain/accounts.ospml", + "src/domain/json.ospml", "src/store/ledger.ospml", "src/store/metrics.ospml", "src/api/routes.ospml", diff --git a/docs/specs/0027-TestingFramework.md b/docs/specs/0027-TestingFramework.md new file mode 100644 index 00000000..126134ac --- /dev/null +++ b/docs/specs/0027-TestingFramework.md @@ -0,0 +1,270 @@ +# Testing Framework + +Osprey's built-in testing harness: three built-in functions (`test`, `expect`, +`check`), a TAP text protocol emitted by compiled test binaries, an +`osprey test` CLI runner, a `--list-tests` discovery mode, and a VS Code Test +Explorer integration shipped in the extension. The framework is deliberately +ultra-minimal: no test DSL, no new syntax, no registration step — a test file +is an ordinary Osprey program whose top-level `test(...)` calls run in source +order. + +> **Flavor layer — shared core (AST and above).** The testing built-ins are +> shared core exactly like every other built-in ([0012](0012-Built-InFunctions.md)): +> the same functions exist in every flavor and lower to the same canonical +> `Expr::Call` nodes. Only the spelling is a flavor concern. The Default +> surface reads like Jest (`test("adds", fn() => expect(add(2, 3), 5))`); the +> ML surface reads like Alcotest (`test "adds" (\() => check "sum" 5 (add (2, 3)))`). +> See [Language Flavors](0023-LanguageFlavors.md). + +- [Status](#status) +- [The built-ins](#the-built-ins) +- [Equality semantics](#equality-semantics) +- [TAP output protocol](#tap-output-protocol) +- [Exit code](#exit-code) +- [Test filtering](#test-filtering) +- [File naming convention](#file-naming-convention) +- [CLI](#cli) +- [VS Code Test Explorer](#vs-code-test-explorer) +- [Runtime](#runtime) +- [Decision record and assumptions](#decision-record-and-assumptions) +- [Risks](#risks) +- [Cross-references](#cross-references) + +## Status + +Implemented for both flavors (Default and ML) on the native target. The C +test-runtime unit is also compiled into the wasm archive so `--target=wasm32` +links, but the wasm runner path is not exercised by the harness. + +## The built-ins + +**`[TESTING-BUILTINS]`** Three built-in functions form the whole framework. +They are ordinary built-ins: declared in the type checker's base environment, +lowered by codegen, backed by the C runtime. No new grammar, keywords, or AST +nodes exist for testing. + +### `test(name: string, body: fn() -> Unit) -> Unit` — `[TESTING-BUILTIN-TEST]` + +Runs `body` as one named test case and prints exactly one TAP result line for +it. Test cases execute inline, in source order, wherever the `test` call is +evaluated (top level is the convention). A test passes when no assertion +inside its body fails; assertions are soft — a failing `expect`/`check` marks +the case failed and execution continues, so one case can report several +mismatches. + +The `body` argument must be a zero-parameter function: an inline lambda +(Default `fn() => …`, ML `\() => …`) or the name of a zero-parameter function. +Any other expression is a compile-time codegen error. + +```osprey +test("addition works", fn() => { + expect(add(2, 3), 5) + expect(add(0, 0), 0) +}) +``` + +```osprey-ml +test "addition works" (\() => + check "sum" 5 (add (2, 3))) +``` + +### `expect(actual: any, expected: any) -> Unit` — `[TESTING-BUILTIN-EXPECT]` + +The Default-flavor-familiar assertion (Jest argument order: actual first). +Compares the two values (see [Equality semantics](#equality-semantics)); on +mismatch, records a failure against the enclosing test case (or the whole run +when used outside `test`) and prints a `#` diagnostic line. + +### `check(label: string, expected: any, actual: any) -> Unit` — `[TESTING-BUILTIN-CHECK]` + +The ML-flavor-familiar assertion, modeled on Alcotest's +`check testable msg expected actual`: a short label, then **expected before +actual**. Behavior is otherwise identical to `expect`. + +Both assertions are valid anywhere an expression is — inside `test` bodies, +in helper functions called from tests, or at the top level of a script. + +**`[TESTING-SHADOWING]`** Unlike other runtime built-ins, `test`, `expect`, +and `check` do NOT reserve their names: a user-defined function with the same +name shadows the built-in in both the type environment and codegen dispatch. +This keeps pre-existing programs (e.g. a `fn check(t: Tree)` helper) compiling +unchanged. + +## Equality semantics + +**`[TESTING-EQUALITY]`** Assertion equality is *canonical-string equality*: +both sides are auto-unwrapped if they are `Result` values (mirroring the `==` +operator's checker rule), rendered with the same `toString` lowering used by +string interpolation, and compared with `strcmp`. This gives uniform, +structural, human-explainable equality across ints, bools, floats, strings, +`Result`s, records, and lists — the diagnostic shows exactly the two rendered +strings that were compared. Corollary: values of different types that render +identically (e.g. `5` and `"5"`) compare equal; assert on the value the test +actually computes. + +## TAP output protocol + +**`[TESTING-TAP]`** A compiled test binary writes +[TAP](https://testanything.org/)-style lines to stdout, interleaved with any +output the program itself prints: + +``` +ok 1 - addition works +# check 'difference' failed: expected 2, got 3 +not ok 2 - subtraction works +1..2 +# tests=2 passed=1 failed=1 +``` + +- One `ok N - name` / `not ok N - name` line per executed test case, numbered + from 1 in execution order, printed when the case's body finishes. +- Each failing assertion prints one `#` diagnostic line at the moment it + fails: `# expect failed: expected E, got A` or + `# check 'label' failed: expected E, got A`. Diagnostics for a case + therefore appear immediately *before* its result line. +- A failing assertion outside any test prints its diagnostic and counts + toward the run's failure total without producing a result line. +- After the program's last statement, the runtime epilogue prints the plan + `1..N` (N = cases executed) and a `# tests=N passed=P failed=F` summary. + The epilogue is emitted only for programs that use a testing built-in; + ordinary programs are unaffected. + +## Exit code + +**`[TESTING-EXIT]`** A test binary exits `0` when every executed test case +passed and no out-of-case assertion failed, else `1`. Compile errors keep +their existing CLI exit codes. + +## Test filtering + +**`[TESTING-FILTER]`** The environment variable `OSPREY_TEST_FILTER`, when +set and non-empty, selects exactly the test cases whose name equals its value +(exact string match). Non-matching cases are skipped silently: their bodies +do not run, they produce no TAP line, and they do not advance the numbering. +The filter is the single mechanism behind "run one test" in every front end +(CLI `--filter`, Test Explorer single-test runs). + +## File naming convention + +**`[TESTING-FILE-CONVENTION]`** Test files are named `*.test.osp` (Default) +or `*.test.ospml` (ML). The convention is what `osprey test` directory +discovery and the VS Code Test Explorer glob use. It is a convention, not a +gate — any Osprey program may call the testing built-ins. + +## CLI + +### `osprey test [path] [--filter ] [--quiet]` — `[TESTING-CLI-RUN]` + +Runs test files and aggregates results. `path` (default `.`) is either a +single file (run as-is, regardless of naming) or a directory searched +recursively for `[TESTING-FILE-CONVENTION]` files (sorted, deterministic +order, hidden/`target` dirs skipped). Each file is compiled and executed like +`osprey --run`; its TAP output streams through unmodified under a +`# file: ` header line. `--filter` sets `OSPREY_TEST_FILTER` for the +child processes. After all files, the runner prints +`# suites: X passed, Y failed` and exits `1` if any suite failed (test +failures or compile errors), else `0`. An empty discovery set is a failure +(`no test files found`). + +### `osprey --list-tests` — `[TESTING-LIST]` + +Static test discovery for editors. Parses the file (skipping the type gate, +like `--symbols`, so discovery works mid-edit) and prints a JSON array of the +statically visible test cases — `test(...)` calls whose first argument is a +string literal, found anywhere in the program's expression trees: + +```json +[{"name":"addition works","line":3,"column":1}] +``` + +`line`/`column` are 1-based and point at the `test` call. Dynamically named +tests (non-literal first argument) still run and report via TAP; they are +simply not listed statically. + +## VS Code Test Explorer + +**`[TESTING-VSCODE]`** The extension ships a native Testing-API integration +(`vscode.tests.createTestController`) in `client/src/test-explorer.ts`, +registered from `activate()` and packaged in the VSIX: + +- **Discovery**: a file-system watcher plus initial scan over + `**/*.test.{osp,ospml}` creates one file-level item per test file; each + file's children come from `osprey --list-tests` (real parse — never + regex), re-resolved on file change. The compiler binary is resolved with + the same chain as the LSP (`osprey.server.compilerPath` setting → bundled + `bin//osprey` → `osprey` on PATH). +- **Run**: the run profile executes `osprey --run` per requested file + (cwd = the file's directory), with `OSPREY_TEST_FILTER=` when a + single case is requested, parses the TAP stream, and maps `ok`/`not ok` + lines back to test items by name. `#` diagnostic lines preceding a + `not ok` line become the failure message. Cases absent from the output are + marked skipped; a non-TAP failure (e.g. compile error) marks the file item + errored with the compiler's stderr. + +## Runtime + +**`[TESTING-RUNTIME]`** `compiler/runtime/test_runtime.c` holds the run +state (cases executed/failed, in-case failure count) and four symbols emitted +by codegen: `osp_test_begin(name)` (returns whether the case runs, applying +`[TESTING-FILTER]`), `osp_test_assert(label, ok, expected, actual)` (label is +NULL for `expect`), `osp_test_end(name)` (prints the TAP result line), and +`osp_test_finalize()` (prints plan + summary, returns the exit code). The +unit is dependency-free C11, compiled into `libfiber_runtime.a` (and its +`_gc`/HTTP/wasm siblings), and assumes single-fiber test execution +(`[TESTING-RISK-FIBERS]`). + +**`[TESTING-CODEGEN]`** Codegen lowers the three built-ins in +`crates/osprey-codegen/src/testing.rs`: `test` evaluates its name, calls +`osp_test_begin`, branches around the inlined body, and calls `osp_test_end`; +`expect`/`check` unwrap + stringify both values, `strcmp`-compare, and call +`osp_test_assert`. Any use sets a per-module flag that makes `main` return +`osp_test_finalize()` instead of `0`. + +## Decision record and assumptions + +**2026-07-12 — built-ins over syntax.** A `test "name" = expr` declaration +form was rejected: it would touch the tree-sitter grammar, the ML parser, the +AST, and project assembly for zero expressive gain. Built-in calls need no +grammar change, work identically in both flavors, and keep discovery trivial +(`Expr::Call` walk). + +**2026-07-12 — canonical-string equality.** Codegen's `==` is shallow +(handles compare as `i64` for lists/records). Rather than build deep +structural equality into the backend for v1, assertions compare `toString` +renderings — the same canonical form the golden-example harness asserts on. +Revisit if/when deep `==` lands in codegen; the TAP surface won't change. + +**2026-07-12 — soft assertions.** A failing assertion does not abort the +case (Osprey has no exceptions; an abort would need effect machinery for a +feature the golden harness doesn't need). Alcotest aborts on first failure; +this framework reports all mismatches in a case. Divergence noted in the +docs. + +**2026-07-12 — filtering by exact name via environment.** An env var needs +no argv plumbing through the compiled binary and works identically for +`osprey test --filter`, bare `--run` invocations, and the Test Explorer. +Exact match keeps "run this one test" unambiguous. + +## Risks + +- **`[TESTING-RISK-FIBERS]`** The run state is plain (non-atomic) C globals; + assertions performed inside spawned fibers may interleave TAP lines or + miscount. Tests should assert on the main fiber (await fiber results, then + assert). +- Canonical-string equality conflates values with identical renderings + across types (`5` vs `"5"`). Accepted for v1; documented in + `[TESTING-EQUALITY]`. +- Test names are matched by exact string in filtering and in the Test + Explorer TAP mapping; duplicate names within one file resolve to the last + matching item. + +## Cross-references + +- [0012 Built-In Functions](0012-Built-InFunctions.md) — the built-in + reference (testing built-ins listed there, normative rules here). +- [0023 Language Flavors](0023-LanguageFlavors.md) — flavor selection and + the shared-core boundary the built-ins sit above. +- [0024 ML Flavor Syntax](0024-MLFlavorSyntax.md) — the ML surface used in + ML-flavor test files. +- `crates/diff_examples.sh` — the golden harness that runs + `examples/tested/testing/` (the framework's own executable examples). diff --git a/examples/projects/modules/README.md b/examples/projects/modules/README.md index f51ed12a..97c7d1fd 100644 --- a/examples/projects/modules/README.md +++ b/examples/projects/modules/README.md @@ -27,6 +27,7 @@ Output is deterministic and byte-compared against `expectedoutput` by src/ lib/sqlite.ospml module Sqlite SQLite library: C FFI externs + typed helpers domain/money.ospml module Money pure cents arithmetic (signature-ascribed) + domain/json.ospml module Json typed JSON encoder, escaping in one place (signature-ascribed) domain/accounts.ospml module Accounts Account record, Outcome union, pure rules store/ledger.ospml module Ledger effect Store (capability) + SQL implementations store/metrics.ospml state Metrics the namespace's ONE state module (request counter) @@ -56,6 +57,11 @@ web ("bank/web") ──imports──▶ api ──performs──▶ Ledger:: - **Double-entry journal.** Every movement — refusals included — lands as a bound-parameter row in `entries`; a transfer writes both sides. The activity feed is an audit ledger, not a best-effort log. +- **JSON is built from strong types, never spliced.** No layer hand-writes + `"{\"error\":\"...\"}"`. `domain/json.ospml` owns encoding through typed + combinators (`strField`/`numField`/`obj`/`arr`), so string escaping lives in + exactly one place — an owner name like `Amelia "Mel" Chen` yields valid JSON + instead of a broken document. (SQL input is bound, never spliced, too.) - **One state owner.** `state Metrics` owns the only mutable cell in the app. The cell is readable and writable exclusively inside its own effect's handler arms, and that region exists only while the exported installer @@ -69,7 +75,7 @@ web ("bank/web") ──imports──▶ api ──performs──▶ Ledger:: | Quoted namespace + alias import | `web/pages.ospml` (`namespace "bank/web"`), `import "bank/web" as web` in main | | Cross-file namespace merging | `Account`/`Outcome` declared in domain, used in api with no import | | `module` with `export` markers | Sqlite, Accounts, Ledger, Api, Pages | -| Signature-ascribed module (no redundant exports) | `module Money : MoneyApi` | +| Signature-ascribed module (no redundant exports) | `module Money : MoneyApi`, `module Json : JsonApi` | | Signature-ascribed **state** module | `state Metrics : MetricsApi` | | Effect declared in a signature | `MetricsApi.MetricsFx` | | Effect exported from a module | `Ledger::Store`, `Api::Audit` | diff --git a/examples/projects/modules/e2e/tests/bank.spec.js b/examples/projects/modules/e2e/tests/bank.spec.js index 3a34e844..3508ab7e 100644 --- a/examples/projects/modules/e2e/tests/bank.spec.js +++ b/examples/projects/modules/e2e/tests/bank.spec.js @@ -116,3 +116,24 @@ test.describe('server-driven web UI', () => { await expect(page.locator('h1')).toHaveText('404'); }); }); + +// Runs last: it opens an account, mutating the shared server's state, so it +// must not precede the count-sensitive assertions above. +test.describe('typed JSON encoding', () => { + test('escapes quotes and backslashes so the response stays valid JSON', async ({ request }) => { + // Without the Json encoder's escaping (domain/json.ospml), an owner name + // containing a quote produces a malformed body and request.json() throws. + const tricky = 'Amelia "Mel" Chen \\ Co.'; + const created = await request.post('/api/accounts', { data: { name: tricky } }); + expect(created.status()).toBe(201); + expect((await created.json()).owner).toBe(tricky); + + const accounts = await (await request.get('/api/accounts')).json(); + expect(accounts.some((a) => a.owner === tricky)).toBe(true); + + // The dashboard re-parses that same JSON, so a broken escape would drop + // the row; the server-rendered page must still show the tricky name. + const page = await request.get('/'); + expect(await page.text()).toContain('Amelia "Mel" Chen'); + }); +}); diff --git a/examples/projects/modules/src/api/routes.ospml b/examples/projects/modules/src/api/routes.ospml index 0014168a..d954cc96 100644 --- a/examples/projects/modules/src/api/routes.ospml +++ b/examples/projects/modules/src/api/routes.ospml @@ -14,6 +14,7 @@ namespace bank import bank::Accounts import bank::Ledger import bank::Money +import bank::Json // `Account` itself needs no import: this file shares `namespace bank` with // domain/accounts.ospml, and one namespace is one logical declaration space @@ -29,7 +30,7 @@ module Api json status body = HttpResponse(status = status, headers = "Content-Type: application/json\r\n", contentType = "application/json", streamFd = -1, isComplete = true, partialBody = body) refuse : string -> HttpResponse - refuse why = json 422 "{\"error\":\"${why}\"}" + refuse why = json 422 (Json::error why) // Pull one string field out of a JSON request body. field : string -> string -> string @@ -111,7 +112,7 @@ module Api Landed balance => landed = perform Ledger::Store.credit to cents note perform Audit.log "transfer ${Money::show cents} account #${from} -> account #${to} (${note})" - json 200 "[${Accounts::json (load from)},${Accounts::json (load to)}]" + json 200 (Json::arr (Accounts::json (load from) + "," + Accounts::json (load to))) // The canonical JSON views, exported on their own so the web layer can // consume the API in-process without unwrapping HTTP envelopes. diff --git a/examples/projects/modules/src/domain/accounts.ospml b/examples/projects/modules/src/domain/accounts.ospml index e5ee05a0..aa196542 100644 --- a/examples/projects/modules/src/domain/accounts.ospml +++ b/examples/projects/modules/src/domain/accounts.ospml @@ -8,6 +8,7 @@ namespace bank import bank::Money +import bank::Json type Account = id : int @@ -31,10 +32,12 @@ module Accounts export movable : int -> bool movable cents = Money::positive cents - // Both the machine field (`cents`) and the display field (`balance`), so - // API consumers never re-parse formatted money. + // Built through the typed `Json` encoder, so `owner` is escaped exactly + // once and a name with quotes still yields valid JSON. Both the machine + // field (`cents`) and the display field (`balance`) ship, so API consumers + // never re-parse formatted money. export json : Account -> string - json a = "{\"id\":${a.id},\"owner\":\"${a.owner}\",\"cents\":${a.balance},\"balance\":\"${Money::show a.balance}\"}" + json a = Json::obj (Json::numField "id" a.id + "," + Json::strField "owner" a.owner + "," + Json::numField "cents" a.balance + "," + Json::strField "balance" (Money::show a.balance)) // One TUI table row: `│ 1 │ Amelia Chen │ $2,462.40 │` export row : Account -> string diff --git a/examples/projects/modules/src/domain/json.ospml b/examples/projects/modules/src/domain/json.ospml new file mode 100644 index 00000000..139aab86 --- /dev/null +++ b/examples/projects/modules/src/domain/json.ospml @@ -0,0 +1,61 @@ +// domain/json — the TYPED JSON ENCODER. [MODULES-SIGNATURE] +// +// One place, and only one place, turns Osprey values into JSON text. No layer +// above ever splices a raw `${value}` inside a string literal — they build +// documents by composing these typed combinators, so string escaping (quotes, +// backslashes) is handled centrally and correctly. A name like +// `Amelia "Mel" Chen` round-trips through `jsonParse` instead of producing a +// broken document. +// +// The signature is the module's whole public surface, so no `export` markers +// appear inside and nothing beyond the combinators can leak. + +namespace bank + +signature JsonApi + strField : string -> string -> string + numField : string -> int -> string + obj : string -> string + arr : string -> string + error : string -> string + +module Json : JsonApi + // JSON string escaping: backslash first (so we never double-escape the + // escapes we just added), then the double-quote. `replace` is fallible; + // on the impossible failure path the input passes through unchanged. + unwrap : Result -> string + unwrap r = match r + Success value => value + Error message => "" + + escape : string -> string + escape s = + bslash = "\\" + quote = "\"" + step = unwrap (replace s bslash (bslash + bslash)) + unwrap (replace step quote (bslash + quote)) + + quoted : string -> string + quoted s = + quote = "\"" + quote + escape s + quote + + // `"key":"escaped value"` — a string-valued object member. + strField : string -> string -> string + strField key value = quoted key + ":" + quoted value + + // `"key":123` — a number-valued object member (integers need no escaping). + numField : string -> int -> string + numField key value = quoted key + ":" + toString value + + // Wrap a comma-joined member list into an object / array. Callers join the + // members with `,`; these only add the braces so nesting stays composable. + obj : string -> string + obj members = "{" + members + "}" + + arr : string -> string + arr elements = "[" + elements + "]" + + // The one canonical error body shape, so every 4xx path is identical. + error : string -> string + error why = obj (strField "error" why) diff --git a/examples/projects/modules/src/store/ledger.ospml b/examples/projects/modules/src/store/ledger.ospml index d1544402..1bb93660 100644 --- a/examples/projects/modules/src/store/ledger.ospml +++ b/examples/projects/modules/src/store/ledger.ospml @@ -18,6 +18,7 @@ namespace bank import bank::Sqlite +import bank::Json module Ledger // The capability surface. `debit` is fallible — overdrafts are refused — @@ -100,7 +101,8 @@ module Ledger cents = Sqlite::intAt cursor 1 note = Sqlite::textAt cursor 2 who = Sqlite::textAt cursor 3 - "${sep}{\"kind\":\"${kind}\",\"cents\":${cents},\"note\":\"${note}\",\"owner\":\"${who}\"}${feedRows cursor ","}" + entry = Json::obj (Json::strField "kind" kind + "," + Json::numField "cents" cents + "," + Json::strField "note" note + "," + Json::strField "owner" who) + "${sep}${entry}${feedRows cursor ","}" export activitySql : Ptr -> string activitySql db = From 8d9efb19a50d2f885be7733e818bed3aed8a84da Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Tue, 14 Jul 2026 20:23:37 +1000 Subject: [PATCH 08/17] Bank --- Makefile | 19 +- compiler/runtime/test_runtime.c | 80 +++ crates/osprey-cli/src/main.rs | 104 +++- crates/osprey-cli/src/test_cmd.rs | 151 ++++++ crates/osprey-cli/tests/cli_e2e.rs | 211 ++++++++ crates/osprey-codegen/src/builder.rs | 4 + crates/osprey-codegen/src/expr.rs | 3 + crates/osprey-codegen/src/lib.rs | 78 +++ crates/osprey-codegen/src/lower.rs | 9 +- crates/osprey-codegen/src/runtime.rs | 18 +- crates/osprey-codegen/src/testing.rs | 134 +++++ crates/osprey-lsp/src/analysis.rs | 2 +- crates/osprey-lsp/src/lib.rs | 2 + crates/osprey-lsp/src/testing.rs | 219 ++++++++ crates/osprey-types/src/builtin_docs.rs | 1 + crates/osprey-types/src/builtin_docs_lang.rs | 24 + crates/osprey-types/src/builtins.rs | 17 + crates/osprey-types/src/check.rs | 38 +- docs/specs/0012-Built-InFunctions.md | 33 ++ docs/specs/0027-TestingFramework.md | 55 +- .../testing/calculator.test.expectedoutput | 6 + examples/tested/testing/calculator.test.osp | 28 + examples/tested/testing/calculator.test.ospml | 25 + .../testing/mlcheck.test.expectedoutput | 5 + examples/tested/testing/mlcheck.test.osp | 29 ++ examples/tested/testing/mlcheck.test.ospml | 26 + vscode-extension/client/src/extension.ts | 6 + .../client/src/test-explorer-parse.ts | 300 +++++++++++ vscode-extension/client/src/test-explorer.ts | 418 +++++++++++++++ vscode-extension/package.json | 4 +- .../test/suite/test-explorer-harness.ts | 90 ++++ .../test/suite/test-explorer-parse.test.ts | 248 +++++++++ .../test/suite/test-explorer.test.ts | 491 ++++++++++++++++++ 33 files changed, 2831 insertions(+), 47 deletions(-) create mode 100644 compiler/runtime/test_runtime.c create mode 100644 crates/osprey-cli/src/test_cmd.rs create mode 100644 crates/osprey-codegen/src/testing.rs create mode 100644 crates/osprey-lsp/src/testing.rs create mode 100644 examples/tested/testing/calculator.test.expectedoutput create mode 100644 examples/tested/testing/calculator.test.osp create mode 100644 examples/tested/testing/calculator.test.ospml create mode 100644 examples/tested/testing/mlcheck.test.expectedoutput create mode 100644 examples/tested/testing/mlcheck.test.osp create mode 100644 examples/tested/testing/mlcheck.test.ospml create mode 100644 vscode-extension/client/src/test-explorer-parse.ts create mode 100644 vscode-extension/client/src/test-explorer.ts create mode 100644 vscode-extension/test/suite/test-explorer-harness.ts create mode 100644 vscode-extension/test/suite/test-explorer-parse.test.ts create mode 100644 vscode-extension/test/suite/test-explorer.test.ts diff --git a/Makefile b/Makefile index a0894cda..1ed0df3a 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ # --run`) and TypeScript sub-projects (vscode-extension, webcompiler, website). # ============================================================================= -.PHONY: build test lint fmt clean ci setup run install bench wasm wasm-site wasm-serve vsix-rebuild-reinstall +.PHONY: build test lint fmt clean ci setup run install bench wasm wasm-site wasm-serve vsix-rebuild-reinstall bank bank-e2e # --------------------------------------------------------------------------- # OS Detection @@ -62,13 +62,13 @@ A ?= -c -fPIC -O2 -D_FORTIFY_SOURCE=2 -fstack-protector-strong -Werror -Wall B ?= $(A) -std=c11 OSSL ?= -DOPENSSL_SUPPRESS_DEPRECATED -DOPENSSL_API_COMPAT=30000 -Wno-deprecated-declarations # Object lists for the archives (paths relative to compiler/, where `ar` runs). -FIB_OBJ ?= bin/memory_runtime.o bin/fiber_runtime.o bin/system_runtime.o bin/effects_runtime.o bin/string_runtime.o bin/string_runtime_list.o bin/list_runtime.o bin/map_runtime.o bin/map_runtime_hamt.o bin/json_runtime.o bin/ffi_runtime.o bin/term_runtime.o bin/random_runtime.o +FIB_OBJ ?= bin/memory_runtime.o bin/fiber_runtime.o bin/system_runtime.o bin/effects_runtime.o bin/string_runtime.o bin/string_runtime_list.o bin/list_runtime.o bin/map_runtime.o bin/map_runtime_hamt.o bin/json_runtime.o bin/ffi_runtime.o bin/term_runtime.o bin/random_runtime.o bin/test_runtime.o HTTP_OBJ ?= bin/http_shared.o bin/http_client_runtime.o bin/http_server_runtime.o bin/websocket_client_runtime.o bin/websocket_server_runtime.o $(FIB_OBJ) # GC backend archives (osprey --memory=gc): the tracing collector replaces # memory_runtime.o, and the value-container units are rebuilt with the malloc # redirect (osp_gc_shim.h) so their nodes live in the managed heap. Everything # else is the same object. Implements [GC-TRACE-CONSERVATIVE], docs/plans/0011. -FIB_OBJ_GC ?= bin/memory_gc.o bin/fiber_runtime.o bin/system_runtime.o bin/effects_runtime.o bin/string_runtime.o bin/string_runtime_list.o bin/gc/list_runtime.o bin/gc/map_runtime.o bin/gc/map_runtime_hamt.o bin/json_runtime.o bin/ffi_runtime.o bin/term_runtime.o bin/random_runtime.o +FIB_OBJ_GC ?= bin/memory_gc.o bin/fiber_runtime.o bin/system_runtime.o bin/effects_runtime.o bin/string_runtime.o bin/string_runtime_list.o bin/gc/list_runtime.o bin/gc/map_runtime.o bin/gc/map_runtime_hamt.o bin/json_runtime.o bin/ffi_runtime.o bin/term_runtime.o bin/random_runtime.o bin/test_runtime.o HTTP_OBJ_GC ?= bin/http_shared.o bin/http_client_runtime.o bin/http_server_runtime.o bin/websocket_client_runtime.o bin/websocket_server_runtime.o $(FIB_OBJ_GC) # WebAssembly (wasm32-wasip1) cross-build toolchain — opt-in via `make wasm`. @@ -91,7 +91,7 @@ WASM_CFLAGS ?= --target=$(WASM_TARGET) --sysroot=$(WASI_SYSROOT) -O2 -std=c11 - # Portable subset that compiles for wasm32: allocator + strings + value # containers + JSON + effects. Excludes fiber (pthreads), http/websocket # (sockets/OpenSSL), system (fork/wait), term (termios) and ffi (dlopen). -WASM_RT_SRC ?= memory_runtime string_runtime string_runtime_list list_runtime map_runtime map_runtime_hamt json_runtime effects_runtime +WASM_RT_SRC ?= memory_runtime string_runtime string_runtime_list list_runtime map_runtime map_runtime_hamt json_runtime effects_runtime test_runtime # `make wasm-serve` static-host dir + port for the in-browser example. WASM_SERVE_DIR ?= examples/wasm WASM_SERVE_PORT ?= 8080 @@ -118,6 +118,16 @@ test: build $(MAKE) _test_vscode_extension $(MAKE) _coverage_check_vscode_extension +## bank: Run the Talon Bank showcase and keep it serving for manual testing. +## Opens http://127.0.0.1:18790 (dashboard) / /api/accounts (JSON API). +## The hold marker keeps the server up; Ctrl-C removes it and exits. +bank: build + @echo "==> Talon Bank live on http://127.0.0.1:18790 (Ctrl-C to stop)" + @touch /tmp/talon_bank.hold + @trap 'rm -f /tmp/talon_bank.hold' EXIT INT TERM; \ + (sleep 2 && (command -v open >/dev/null && open http://127.0.0.1:18790 || true)) & \ + ./$(BIN) examples/projects/modules --run + ## bank-e2e: Browser end-to-end tests for the Talon Bank modules showcase ## (examples/projects/modules) — real Chromium via Playwright drives ## the compiled osprey binary serving its HTTP API and web UI. @@ -260,6 +270,7 @@ _runtime: $(CC) $(B) runtime/ffi_runtime.c -o bin/ffi_runtime.o && \ $(CC) $(B) runtime/term_runtime.c -o bin/term_runtime.o && \ $(CC) $(B) runtime/random_runtime.c -o bin/random_runtime.o && \ + $(CC) $(B) runtime/test_runtime.c -o bin/test_runtime.o && \ $(CC) -c -fPIC -O2 -D_FORTIFY_SOURCE=2 -fstack-protector-strong -Werror -Wall -Wextra \ -Wformat -Werror=format-security -Werror=implicit-function-declaration \ -Werror=incompatible-pointer-types -Werror=int-conversion -Warray-bounds -ftrapv \ diff --git a/compiler/runtime/test_runtime.c b/compiler/runtime/test_runtime.c new file mode 100644 index 00000000..af9a2650 --- /dev/null +++ b/compiler/runtime/test_runtime.c @@ -0,0 +1,80 @@ +// Osprey testing framework run state + TAP emission. Implements +// [TESTING-RUNTIME], [TESTING-TAP], [TESTING-EXIT], [TESTING-FILTER] +// (docs/specs/0027-TestingFramework.md). Called only from compiler-emitted IR +// (crates/osprey-codegen/src/testing.rs); dependency-free C11 so the unit +// compiles unchanged into the native, GC, and wasm runtime archives. +// +// State is plain (non-atomic) globals: test execution is single-fiber by +// contract [TESTING-RISK-FIBERS]. + +#include +#include +#include +#include + +static int64_t tests_run = 0; +static int64_t tests_failed = 0; +static int64_t stray_failures = 0; /* failing asserts outside any case */ +static int64_t case_failures = -1; /* -1 = not inside a test case */ + +/* Begin the named case: 0 = skip, 1 = run. Skips on a filter mismatch + [TESTING-FILTER]; a nested test() inside a running case does not run — it + fails the enclosing case loudly instead [TESTING-BUILTIN-TEST]. */ +int32_t osp_test_begin(const char *name) { + if (case_failures >= 0) { + printf("# nested test '%s' skipped: test() inside a test body is not " + "supported\n", + name == NULL ? "" : name); + case_failures += 1; + return 0; + } + const char *filter = getenv("OSPREY_TEST_FILTER"); + if (filter != NULL && filter[0] != '\0' && + (name == NULL || strcmp(filter, name) != 0)) { + return 0; + } + case_failures = 0; + return 1; +} + +/* Record one assertion; on mismatch print the `#` diagnostic [TESTING-TAP]. + `label` is NULL for expect, the check label otherwise. */ +void osp_test_assert(const char *label, int32_t ok, const char *expected, + const char *actual) { + if (ok != 0) { + return; + } + if (label != NULL) { + printf("# check '%s' failed: expected %s, got %s\n", label, expected, + actual); + } else { + printf("# expect failed: expected %s, got %s\n", expected, actual); + } + if (case_failures >= 0) { + case_failures += 1; + } else { + stray_failures += 1; + } +} + +/* Close the current case and print its TAP result line [TESTING-TAP]. */ +void osp_test_end(const char *name) { + tests_run += 1; + if (case_failures > 0) { + tests_failed += 1; + printf("not ok %lld - %s\n", (long long)tests_run, name); + } else { + printf("ok %lld - %s\n", (long long)tests_run, name); + } + case_failures = -1; +} + +/* Print the plan + summary — always, even for a zero-case run (`1..0`), so a + filter that matched nothing is visible [TESTING-TAP]. The process exit code + [TESTING-EXIT]. */ +int32_t osp_test_finalize(void) { + printf("1..%lld\n", (long long)tests_run); + printf("# tests=%lld passed=%lld failed=%lld\n", (long long)tests_run, + (long long)(tests_run - tests_failed), (long long)tests_failed); + return (tests_failed > 0 || stray_failures > 0) ? 1 : 0; +} diff --git a/crates/osprey-cli/src/main.rs b/crates/osprey-cli/src/main.rs index 5e8c6703..2e9af52e 100644 --- a/crates/osprey-cli/src/main.rs +++ b/crates/osprey-cli/src/main.rs @@ -3,8 +3,10 @@ //! Modes: report type errors (`--check`, the default — the editor's //! diagnostics path), dump the AST (`--ast`), emit LLVM IR (`--llvm`), build //! an executable (`--compile`), compile-and-run via clang (`--run`), emit the -//! document outline as JSON (`--symbols`), or print a built-in's signature as -//! markdown (`--hover `). Every compiling mode gates on Hindley-Milner +//! document outline as JSON (`--symbols`), list statically-discoverable test +//! cases as JSON (`--list-tests`, [TESTING-LIST]), or print a built-in's +//! signature as markdown (`--hover `). `osprey test` discovers and runs +//! test suites ([TESTING-CLI-RUN], `test_cmd`). Every compiling mode gates on Hindley-Milner //! type inference first — an ill-typed program never reaches codegen — and on //! the capability sandbox (`--sandbox`, `--no-http`, `--no-websocket`, //! `--no-fs`, `--no-ffi`). `--quiet` suppresses non-essential output. The C @@ -18,6 +20,7 @@ mod docs; mod fmt; mod project; mod sandbox; +mod test_cmd; mod wasm; use osprey_syntax::Flavor; @@ -28,13 +31,14 @@ use std::path::Path; use std::path::PathBuf; use std::process::{Command, ExitCode}; -const USAGE: &str = +pub(crate) const USAGE: &str = "usage: osprey [--check | --ast | --llvm | --compile | --run | \ ---symbols] [--quiet] [--debug] [--flavor default|ml] [--memory=default|gc] \ +--symbols | --list-tests] [--quiet] [--debug] [--flavor default|ml] [--memory=default|gc] \ [--target=native|wasm32] [-o ] \ [--sandbox | --no-http | --no-websocket | --no-fs | --no-ffi]\n\ osprey build [project] [--quiet] [--debug] [--memory=default|gc] \ [--target=native|wasm32] [-o ]\n\ + osprey test [path] [--filter ] [--quiet]\n\ osprey fmt [--check | --stdout] [--flavor default|ml] \n\ osprey --hover \n\ osprey --docs --docs-dir     \n\ @@ -42,7 +46,7 @@ const USAGE: &str = /// The parsed invocation: source path, mode flag, and behaviour switches. #[derive(Debug)] -struct Cli { +pub(crate) struct Cli { path: String, mode: String, quiet: bool, @@ -64,6 +68,24 @@ struct Cli { flavor: Option, } +impl Cli { + /// A `--run`-mode invocation for `path` with default switches — the + /// `osprey test` runner's per-file configuration [TESTING-CLI-RUN]. + pub(crate) fn run_native(path: String) -> Cli { + Cli { + path, + mode: String::from("--run"), + quiet: true, + policy: Policy::allow_all(), + memory: String::from("default"), + target: String::from("native"), + output: None, + debug: false, + flavor: None, + } + } +} + fn main() -> ExitCode { let args: Vec = std::env::args().skip(1).collect(); if args.first().map(String::as_str) == Some("--version") { @@ -92,6 +114,10 @@ fn main() -> ExitCode { if args.first().map(String::as_str) == Some("fmt") { return fmt::run(args.get(1..).unwrap_or_default()); } + // `osprey test`: discover and run test suites. [TESTING-CLI-RUN] + if args.first().map(String::as_str) == Some("test") { + return test_cmd::run(args.get(1..).unwrap_or_default()); + } // `osprey --docs`: regenerate the built-in function reference from the // compiler's metadata. No source file is involved. if args.iter().any(|a| a == "--docs") { @@ -158,14 +184,16 @@ fn parse_args(args: &[String]) -> Result { let mut it = args.iter(); while let Some(a) = it.next() { match a.as_str() { - "--ast" | "--check" | "--llvm" | "--compile" | "--run" | "--symbols" | "--hover" + "--ast" | "--check" | "--llvm" | "--compile" | "--run" | "--symbols" + | "--list-tests" | "--hover" if project_build => { return Err(format!( "`osprey build` does not accept mode flag {a}\n{USAGE}" )); } - "--ast" | "--check" | "--llvm" | "--compile" | "--run" | "--symbols" | "--hover" => { + "--ast" | "--check" | "--llvm" | "--compile" | "--run" | "--symbols" + | "--list-tests" | "--hover" => { mode.clone_from(a); } "--quiet" => quiet = true, @@ -279,7 +307,7 @@ fn run(cli: &Cli) -> ExitCode { dispatch(cli, &input) } -fn load_input(cli: &Cli) -> Result { +pub(crate) fn load_input(cli: &Cli) -> Result { let path = &cli.path; if project::is_project_path(path) { if cli.flavor.is_some() { @@ -344,6 +372,12 @@ fn dispatch(cli: &Cli, input: &CompilationInput) -> ExitCode { println!("{}", input.symbols_json()); ExitCode::SUCCESS } + // Static test discovery skips the type gate too, so editors can list + // tests mid-edit [TESTING-LIST]. + "--list-tests" => { + println!("{}", osprey_lsp::tests_json(program)); + ExitCode::SUCCESS + } "--llvm" | "--run" | "--compile" if report_type_errors(input) > 0 => ExitCode::FAILURE, "--llvm" => match compile_ir(input.debug_path(), program, cli.debug) { Ok(ir) => { @@ -366,7 +400,7 @@ fn dispatch(cli: &Cli, input: &CompilationInput) -> ExitCode { /// Type-check `program`, print every error in `file:line:col: message` form, /// and return how many there were. The shared gate for every compiling mode. -fn report_type_errors(input: &CompilationInput) -> usize { +pub(crate) fn report_type_errors(input: &CompilationInput) -> usize { let errors = osprey_types::check_program(input.program()); for e in &errors { eprintln!("{}", input.diagnostic(e.position, &e.message)); @@ -446,22 +480,34 @@ fn run_program(cli: &Cli, input: &CompilationInput) -> ExitCode { } return wasm::run(input.debug_path(), input.program()); } + match execute_native(input, &cli.memory, cli.debug) { + Ok(code) => ExitCode::from(code), + Err(code) => code, + } +} + +/// Compile `input` natively to a temp binary and execute it inheriting stdio; +/// the child's exit code. Shared by `--run` and the `osprey test` runner +/// [TESTING-CLI-RUN]. +pub(crate) fn execute_native( + input: &CompilationInput, + memory: &str, + debug: bool, +) -> Result { let exe = std::env::temp_dir().join(format!("{}.out", scratch_stem(input.display_path()))); - if let Err(code) = build_executable( + build_executable( input.debug_path(), input.program(), input.source(), &exe, - &cli.memory, - cli.debug, - ) { - return code; - } + memory, + debug, + )?; match Command::new(&exe).status() { - Ok(s) => ExitCode::from(child_exit_code(s)), + Ok(s) => Ok(child_exit_code(s)), Err(e) => { eprintln!("error: could not run {}: {e}", exe.display()); - ExitCode::FAILURE + Err(ExitCode::FAILURE) } } } @@ -1118,6 +1164,10 @@ mod tests { "examples/tested/ml/results_state_hof.ospml", "examples/tested/ml/strings.osp", "examples/tested/ml/strings.ospml", + "examples/tested/testing/calculator.test.osp", + "examples/tested/testing/calculator.test.ospml", + "examples/tested/testing/mlcheck.test.osp", + "examples/tested/testing/mlcheck.test.ospml", ]; #[test] @@ -1822,6 +1872,26 @@ mod tests { assert_example_matches("examples/tested/ml/strings.ospml"); } + #[test] + fn testing_calculator_test_osp() { + assert_example_matches("examples/tested/testing/calculator.test.osp"); + } + + #[test] + fn testing_calculator_test_ospml() { + assert_example_matches("examples/tested/testing/calculator.test.ospml"); + } + + #[test] + fn testing_mlcheck_test_osp() { + assert_example_matches("examples/tested/testing/mlcheck.test.osp"); + } + + #[test] + fn testing_mlcheck_test_ospml() { + assert_example_matches("examples/tested/testing/mlcheck.test.ospml"); + } + fn args(list: &[&str]) -> Vec { list.iter().map(|s| (*s).to_string()).collect() } diff --git a/crates/osprey-cli/src/test_cmd.rs b/crates/osprey-cli/src/test_cmd.rs new file mode 100644 index 00000000..d28891ea --- /dev/null +++ b/crates/osprey-cli/src/test_cmd.rs @@ -0,0 +1,151 @@ +//! `osprey test` — discover and run test suites. Implements +//! [TESTING-CLI-RUN], [TESTING-FILE-CONVENTION], [TESTING-FILTER] +//! (docs/specs/0027-TestingFramework.md). +//! +//! `path` (default `.`) is a single file run as-is, or a directory searched +//! recursively for `*.test.osp` / `*.test.ospml`, sorted for determinism, +//! skipping hidden, `target`, and `node_modules` directories. Each file +//! compiles and runs like `osprey --run`; its TAP output streams +//! through under a `# file:` header; the exit code aggregates suite outcomes. + +use crate::{execute_native, load_input, report_type_errors, Cli, USAGE}; +use std::path::{Path, PathBuf}; +use std::process::ExitCode; + +struct Opts { + path: String, + filter: Option, + quiet: bool, +} + +pub(crate) fn run(args: &[String]) -> ExitCode { + let opts = match parse(args) { + Ok(opts) => opts, + Err(msg) => { + eprintln!("{msg}"); + return ExitCode::from(2); + } + }; + if let Some(filter) = &opts.filter { + // The compiled test binaries inherit the environment; the filter is + // an exact-name match applied by the C runtime [TESTING-FILTER]. + std::env::set_var("OSPREY_TEST_FILTER", filter); + } + let files = discover(Path::new(&opts.path)); + if files.is_empty() { + eprintln!("osprey test: no test files found under {}", opts.path); + return ExitCode::FAILURE; + } + run_suites(&files, opts.quiet) +} + +fn parse(args: &[String]) -> Result { + let mut opts = Opts { + path: String::from("."), + filter: None, + quiet: false, + }; + let mut path = None; + let mut it = args.iter(); + while let Some(a) = it.next() { + match a.as_str() { + "--quiet" => opts.quiet = true, + "--filter" => { + let next = it + .next() + .ok_or_else(|| format!("--filter requires a test name\n{USAGE}"))?; + opts.filter = Some(next.clone()); + } + flag if flag.starts_with("--") => { + return Err(format!("unknown flag {flag}\n{USAGE}")); + } + _ if path.is_none() => path = Some(a.clone()), + other => return Err(format!("unexpected argument {other}\n{USAGE}")), + } + } + if let Some(p) = path { + opts.path = p; + } + Ok(opts) +} + +/// A single file runs as-is regardless of naming; a directory is searched for +/// `[TESTING-FILE-CONVENTION]` files, sorted for a deterministic run order. +fn discover(path: &Path) -> Vec { + if path.is_file() { + return vec![path.to_path_buf()]; + } + let mut out = Vec::new(); + visit(path, &mut out); + out.sort(); + out +} + +fn is_test_file(path: &Path) -> bool { + path.file_name() + .and_then(|name| name.to_str()) + .is_some_and(|name| name.ends_with(".test.osp") || name.ends_with(".test.ospml")) +} + +fn skipped_dir_entry(path: &Path) -> bool { + path.file_name() + .and_then(|name| name.to_str()) + .is_some_and(|name| name.starts_with('.') || name == "target" || name == "node_modules") +} + +fn visit(dir: &Path, out: &mut Vec) { + let Ok(entries) = std::fs::read_dir(dir) else { + return; + }; + for entry in entries.flatten() { + let path = entry.path(); + // `file_type()` does not follow symlinks, so a symlinked directory is + // never descended into — a link cycle cannot recurse forever. + let Ok(file_type) = entry.file_type() else { + continue; + }; + if skipped_dir_entry(&path) { + continue; + } + if file_type.is_dir() { + visit(&path, out); + } else if file_type.is_file() && is_test_file(&path) { + out.push(path); + } + } +} + +fn run_suites(files: &[PathBuf], quiet: bool) -> ExitCode { + let mut failed = 0usize; + for file in files { + if !quiet { + println!("# file: {}", file.display()); + } + if !suite_passes(file) { + failed += 1; + } + } + println!( + "# suites: {} passed, {} failed", + files.len() - failed, + failed + ); + if failed > 0 { + ExitCode::FAILURE + } else { + ExitCode::SUCCESS + } +} + +/// Compile and execute one test file like `--run`; `true` when it exits 0 +/// [TESTING-EXIT]. Compile and type errors print their own diagnostics. +fn suite_passes(file: &Path) -> bool { + let cli = Cli::run_native(file.display().to_string()); + let Ok(input) = load_input(&cli) else { + return false; + }; + if report_type_errors(&input) > 0 { + return false; + } + matches!(execute_native(&input, "default", false), Ok(0)) +} diff --git a/crates/osprey-cli/tests/cli_e2e.rs b/crates/osprey-cli/tests/cli_e2e.rs index bce0affd..960df781 100644 --- a/crates/osprey-cli/tests/cli_e2e.rs +++ b/crates/osprey-cli/tests/cli_e2e.rs @@ -515,3 +515,214 @@ fn run_reports_an_uninvokable_c_compiler() { assert_ne!(o.code, Some(0)); assert!(!o.stderr.is_empty(), "{}", o.stderr); } + +// --- testing framework (docs/specs/0027-TestingFramework.md) --------------- + +const PASSING_TESTS: &str = "test(\"adds\", fn() => expect(1 + 1, 2))\n\ +test(\"labeled\", fn() => check(\"sum\", 4, 2 + 2))\n"; + +const FAILING_TESTS: &str = "test(\"bad math\", fn() => expect(1 + 1, 3))\n\ +test(\"good math\", fn() => expect(2 + 2, 4))\n"; + +/// Write `body` to `/` and return the path. +fn write_in(dir: &Path, name: &str, body: &str) -> PathBuf { + let path = dir.join(name); + let _ = std::fs::write(&path, body); + path +} + +// [TESTING-TAP][TESTING-EXIT] a test binary reports TAP and exits by outcome. +#[test] +fn test_builtins_emit_tap_and_exit_status() { + let pass = temp_osp("tap_pass", PASSING_TESTS); + let o = run_file(&pass, &["--run"]); + assert_eq!(o.code, Some(0), "{}", o.stderr); + assert!(o.stdout.contains("ok 1 - adds"), "{}", o.stdout); + assert!(o.stdout.contains("1..2"), "{}", o.stdout); + assert!( + o.stdout.contains("# tests=2 passed=2 failed=0"), + "{}", + o.stdout + ); + + let fail = temp_osp("tap_fail", FAILING_TESTS); + let o = run_file(&fail, &["--run"]); + assert_eq!(o.code, Some(1), "{}", o.stdout); + assert!( + o.stdout.contains("# expect failed: expected 3, got 2"), + "{}", + o.stdout + ); + assert!(o.stdout.contains("not ok 1 - bad math"), "{}", o.stdout); + assert!(o.stdout.contains("ok 2 - good math"), "{}", o.stdout); + assert!( + o.stdout.contains("# tests=2 passed=1 failed=1"), + "{}", + o.stdout + ); +} + +// [TESTING-FILTER] the env var exact-matches one case; others skip silently. +#[test] +fn test_filter_env_selects_one_case() { + let prog = temp_osp("tap_filter", FAILING_TESTS); + let mut cmd = osprey(); + let _ = cmd + .arg(&prog) + .arg("--run") + .env("OSPREY_TEST_FILTER", "good math"); + let o = finish(cmd); + assert_eq!(o.code, Some(0), "{}", o.stdout); + assert!(o.stdout.contains("ok 1 - good math"), "{}", o.stdout); + assert!(!o.stdout.contains("bad math"), "{}", o.stdout); + assert!(o.stdout.contains("1..1"), "{}", o.stdout); +} + +// [TESTING-LIST] static discovery lists literal names with positions and +// skips dynamic names; a testless file lists as []. +#[test] +fn list_tests_reports_literal_cases_as_json() { + let prog = temp_osp( + "list_tests", + "let name = \"dyn\"\ntest(\"first\", fn() => expect(1, 1))\ntest(name, fn() => expect(1, 1))\n", + ); + let o = run_file(&prog, &["--list-tests"]); + assert_eq!(o.code, Some(0), "{}", o.stderr); + assert_eq!( + o.stdout.trim(), + "[{\"name\":\"first\",\"line\":2,\"column\":1}]" + ); + + let none = temp_osp("list_none", HELLO); + let o = run_file(&none, &["--list-tests"]); + assert_eq!(o.stdout.trim(), "[]"); +} + +// [TESTING-CLI-RUN] the runner discovers *.test.osp{,ml} under a directory, +// streams TAP under headers, and aggregates the exit status. +#[test] +fn test_subcommand_runs_directories_and_files() { + let dir = temp_dir("suite"); + let _ = write_in(&dir, "pass.test.osp", PASSING_TESTS); + let _ = write_in( + &dir, + "fail.test.ospml", + "test \"ml bad\" (\\() => check \"v\" 3 (1 + 1))\n", + ); + let _ = write_in(&dir, "ignored.osp", HELLO); + + let o = run_args(&["test", dir.to_string_lossy().as_ref()]); + assert_eq!(o.code, Some(1), "{}", o.stdout); + assert!(o.stdout.contains("# file:"), "{}", o.stdout); + assert!(o.stdout.contains("ok 1 - adds"), "{}", o.stdout); + assert!( + o.stdout.contains("# check 'v' failed: expected 3, got 2"), + "{}", + o.stdout + ); + assert!( + o.stdout.contains("# suites: 1 passed, 1 failed"), + "{}", + o.stdout + ); + assert!( + !o.stdout.contains("v=hi"), + "plain .osp files must be ignored" + ); + + // A single file runs regardless of naming; --filter reaches the children. + let single = write_in(&dir, "single.osp", FAILING_TESTS); + let o = run_args(&[ + "test", + single.to_string_lossy().as_ref(), + "--filter", + "good math", + "--quiet", + ]); + assert_eq!(o.code, Some(0), "{}", o.stdout); + assert!( + o.stdout.contains("# suites: 1 passed, 0 failed"), + "{}", + o.stdout + ); + assert!(!o.stdout.contains("# file:"), "--quiet drops headers"); +} + +// A compile-error suite fails the run; an empty discovery set is loud. +#[test] +fn test_subcommand_reports_broken_and_missing_suites() { + let dir = temp_dir("suite_bad"); + let _ = write_in(&dir, "broken.test.osp", "test(\"x\", fn() => expect(1)\n"); + let o = run_args(&["test", dir.to_string_lossy().as_ref()]); + assert_eq!(o.code, Some(1), "{}", o.stdout); + assert!( + o.stdout.contains("# suites: 0 passed, 1 failed"), + "{}", + o.stdout + ); + + let empty = temp_dir("suite_empty"); + let o = run_args(&["test", empty.to_string_lossy().as_ref()]); + assert_eq!(o.code, Some(1), "{}", o.stderr); + assert!(o.stderr.contains("no test files found"), "{}", o.stderr); + + let o = run_args(&["test", "--filter"]); + assert_eq!(o.code, Some(2), "{}", o.stderr); + let o = run_args(&["test", "--nonsense"]); + assert_eq!(o.code, Some(2), "{}", o.stderr); + let o = run_args(&["test", "a", "b"]); + assert_eq!(o.code, Some(2), "{}", o.stderr); +} + +// A nested test() must not silently reshuffle counters: it fails the +// enclosing case loudly [TESTING-BUILTIN-TEST], and a zero-case run still +// prints its plan so a matchless filter is visible [TESTING-TAP]. +#[test] +fn nested_tests_fail_loudly_and_zero_case_runs_keep_the_plan() { + let nested = temp_osp( + "tap_nested", + "test(\"outer\", fn() => {\n expect(1, 2)\n test(\"inner\", fn() => expect(3, 3))\n})\n", + ); + let o = run_file(&nested, &["--run"]); + assert_eq!(o.code, Some(1), "{}", o.stdout); + assert!( + o.stdout.contains("# nested test 'inner' skipped"), + "{}", + o.stdout + ); + assert!(o.stdout.contains("not ok 1 - outer"), "{}", o.stdout); + + let prog = temp_osp("tap_nomatch", PASSING_TESTS); + let mut cmd = osprey(); + let _ = cmd + .arg(&prog) + .arg("--run") + .env("OSPREY_TEST_FILTER", "matches nothing"); + let o = finish(cmd); + assert_eq!(o.code, Some(0), "{}", o.stdout); + assert!(o.stdout.contains("1..0"), "{}", o.stdout); + assert!( + o.stdout.contains("# tests=0 passed=0 failed=0"), + "{}", + o.stdout + ); +} + +// [TESTING-EQUALITY] an Error operand is a visible mismatch, never a blind +// payload read. +#[test] +fn error_result_assertions_render_the_error() { + let prog = temp_osp( + "tap_err_result", + "test(\"div\", fn() => expect(intDiv(1, 0), 2))\n", + ); + let o = run_file(&prog, &["--run"]); + assert_eq!(o.code, Some(1), "{}", o.stdout); + assert!( + o.stdout + .contains("# expect failed: expected 2, got Error(division by zero)"), + "{}", + o.stdout + ); + assert!(o.stdout.contains("not ok 1 - div"), "{}", o.stdout); +} diff --git a/crates/osprey-codegen/src/builder.rs b/crates/osprey-codegen/src/builder.rs index 12cc465d..5aa0955f 100644 --- a/crates/osprey-codegen/src/builder.rs +++ b/crates/osprey-codegen/src/builder.rs @@ -98,6 +98,9 @@ pub struct Codegen { pub(crate) cell_slots: HashMap, /// Continuation lowering context while emitting a resuming handler arm. pub(crate) resume_ctx: Option, + /// Whether any testing built-in was lowered — makes `main` return the TAP + /// epilogue's exit status [TESTING-EXIT]. + pub(crate) testing_used: bool, /// LLVM/DWARF debug metadata state, when `--debug` was requested. debug: Option, } @@ -416,6 +419,7 @@ impl Codegen { cell_vars: HashSet::new(), cell_slots: HashMap::new(), resume_ctx: None, + testing_used: false, debug: options.debug_source.map(DebugState::new), } } diff --git a/crates/osprey-codegen/src/expr.rs b/crates/osprey-codegen/src/expr.rs index b6f55aa8..8f3458b5 100644 --- a/crates/osprey-codegen/src/expr.rs +++ b/crates/osprey-codegen/src/expr.rs @@ -483,6 +483,9 @@ fn gen_call( // names below are reserved. Each dispatcher returns `None` when the name // is not its builtin, so the chain falls through to a user call. _ => { + if let Some(v) = crate::testing::gen(cg, name, arguments, named)? { + return Ok(v); + } if let Some(v) = crate::strings::gen(cg, name, arguments, named)? { return Ok(v); } diff --git a/crates/osprey-codegen/src/lib.rs b/crates/osprey-codegen/src/lib.rs index 8d1fb3f8..18666d8f 100644 --- a/crates/osprey-codegen/src/lib.rs +++ b/crates/osprey-codegen/src/lib.rs @@ -35,6 +35,7 @@ mod pattern; mod result; mod runtime; mod strings; +mod testing; mod types; pub use error::{CodegenError, Result}; @@ -141,6 +142,83 @@ mod tests { assert!(ir.contains("call i64 @add(i64 2, i64 3)")); } + // Testing built-ins lower to the TAP runtime and re-route main's exit + // status through the epilogue. [TESTING-CODEGEN][TESTING-EXIT] + #[test] + fn testing_builtins_lower_to_tap_runtime_calls() { + let ir = module("test(\"adds\", fn() => expect(1 + 1, 2))\n"); + assert!(ir.contains("call i32 @osp_test_begin(i8*")); + assert!(ir.contains("call void @osp_test_end(i8*")); + assert!(ir.contains("call void @osp_test_assert(i8* null, i32")); + assert!(ir.contains("call i32 @osp_test_finalize()")); + assert!(ir.contains("call i32 @strcmp(i8*")); + } + + #[test] + fn check_lowers_with_label_and_named_body_calls_through() { + let ir = module("fn body() = check(\"sum\", 4, 2 + 2)\ntest(\"named\", body)\n"); + // The label operand is a real string pointer, not the expect null. + assert!(ir.contains("@osp_test_assert(i8* %")); + assert!(!ir.contains("@osp_test_assert(i8* null")); + assert!(ir.contains("call i32 @osp_test_begin(i8*")); + } + + #[test] + fn programs_without_tests_keep_the_plain_exit_path() { + let ir = module("print(\"hi\")\n"); + assert!(!ir.contains("osp_test_finalize")); + assert!(ir.contains("ret i32 0")); + } + + #[test] + fn user_functions_shadow_testing_builtins() { + // [TESTING-SHADOWING] a user `check` compiles as an ordinary call. + let ir = module("fn check(t: int) -> int = t + 1\nlet r = check(4)\nprint(r)\n"); + assert!(!ir.contains("osp_test_assert")); + assert!(ir.contains("call i64 @check(i64 4)")); + // …and so does an extern declaration of the same name. + let ir = module( + "extern fn check(a: int, b: int, c: int) -> int\nlet r = check(1, 2, 3)\nprint(r)\n", + ); + assert!(!ir.contains("osp_test_assert")); + } + + #[test] + fn error_results_render_visibly_and_handles_are_rejected() { + // [TESTING-EQUALITY] a Result operand branches on its discriminant: + // Success renders bare, Error renders as Error(). + let ir = module("expect(intDiv(1, 0), 2)\n"); + assert!(ir.contains("call void @osp_test_assert(i8* null, i32")); + assert!(ir.contains("Error(%s)")); + // A list/map/record operand has no canonical rendering — loud error. + assert!(compile_err("expect([1, 2], [1, 3])\n") + .to_string() + .contains("list, map, or record")); + } + + #[test] + fn assertion_operands_unwrap_results_before_comparing() { + // [TESTING-EQUALITY] intDiv returns Result; expect compares + // its unwrapped payload's canonical string. + let ir = module("expect(intDiv(4, 2), 2)\n"); + assert!(ir.contains("call void @osp_test_assert(i8* null, i32")); + } + + #[test] + fn testing_builtin_arity_errors_are_loud() { + // The type gate rejects these in the CLI; codegen still fails loudly + // on its own rather than emitting a broken call. + assert!(compile_err("test(\"only name\")\n") + .to_string() + .contains("test needs")); + assert!(compile_err("expect(1)\n") + .to_string() + .contains("expect needs")); + assert!(compile_err("check(\"l\", 1)\n") + .to_string() + .contains("check needs")); + } + #[test] fn debug_compile_emits_source_level_metadata() { let ir = diff --git a/crates/osprey-codegen/src/lower.rs b/crates/osprey-codegen/src/lower.rs index 91808221..f3d95c30 100644 --- a/crates/osprey-codegen/src/lower.rs +++ b/crates/osprey-codegen/src/lower.rs @@ -117,7 +117,14 @@ fn compile_program_with_options(program: &Program, options: CodegenOptions) -> R gen_local_stmt(&mut cg, stmt)?; } } - cg.emit("ret i32 0"); + // A program that used the testing built-ins exits with the TAP epilogue's + // status (plan + summary printed by the runtime) [TESTING-EXIT]. + if cg.testing_used { + let code = cg.call("i32", "osp_test_finalize", "", &[]); + cg.emit(format!("ret i32 {code}")); + } else { + cg.emit("ret i32 0"); + } cg.finish_function(LType::I32.as_str(), "main", &[]); Ok(cg.render()) diff --git a/crates/osprey-codegen/src/runtime.rs b/crates/osprey-codegen/src/runtime.rs index 92eb3b13..dc06c693 100644 --- a/crates/osprey-codegen/src/runtime.rs +++ b/crates/osprey-codegen/src/runtime.rs @@ -29,10 +29,26 @@ pub(crate) fn to_string_value(cg: &mut Codegen, v: Value) -> Result { /// payload comes from the errmsg slot (slot 2), which `load_errmsg` already /// falls back to the bare `"Error"` constant when unset. Implements [ERR-PAYLOAD]. fn result_to_string(cg: &mut Codegen, v: &Value) -> Result { + result_string(cg, v, true) +} + +/// [`result_to_string`] minus the `Success(…)` wrapping: a Success renders as +/// its bare payload, an Error as `Error()`. The assertion operands' +/// rendering — a Success compares as its payload, an Error is a visible +/// mismatch, never a blind payload load. [TESTING-EQUALITY] +pub(crate) fn result_payload_or_error_string(cg: &mut Codegen, v: &Value) -> Result { + result_string(cg, v, false) +} + +fn result_string(cg: &mut Codegen, v: &Value, wrap_success: bool) -> Result { let (_sl, el, end) = crate::result::open_result_branch(cg, v); let val = crate::result::load_value(cg, v); let vs = to_string_value(cg, val)?; - let succ = sprintf_wrap(cg, "Success(%s)", &vs.operand); + let succ = if wrap_success { + sprintf_wrap(cg, "Success(%s)", &vs.operand) + } else { + vs.operand + }; let sb = cg.snapshot_to(&end); cg.start_block(&el); diff --git a/crates/osprey-codegen/src/testing.rs b/crates/osprey-codegen/src/testing.rs new file mode 100644 index 00000000..3de75ce8 --- /dev/null +++ b/crates/osprey-codegen/src/testing.rs @@ -0,0 +1,134 @@ +//! Codegen for the testing built-ins `test` / `expect` / `check`: lowers each +//! call to the TAP-emitting C runtime (`compiler/runtime/test_runtime.c`). +//! Assertion equality is canonical-string equality after Result auto-unwrap +//! [TESTING-EQUALITY]. Implements [TESTING-CODEGEN], [TESTING-BUILTIN-TEST], +//! [TESTING-BUILTIN-EXPECT], [TESTING-BUILTIN-CHECK] +//! (docs/specs/0027-TestingFramework.md). + +use crate::builder::Codegen; +use crate::error::{CodegenError, Result}; +use crate::expr::{arg_exprs, gen_expr}; +use crate::llty::Value; +use crate::runtime::to_string_value; +use osprey_ast::{Expr, NamedArgument}; + +/// Dispatch a testing built-in call; `None` when `name` is not one, or when a +/// user-defined function OR extern shadows the name [TESTING-SHADOWING]. +pub(crate) fn gen( + cg: &mut Codegen, + name: &str, + arguments: &[Expr], + named: &[NamedArgument], +) -> Result> { + if cg.fn_params.contains_key(name) || cg.prog.functions.contains_key(name) { + return Ok(None); + } + let args = arg_exprs(arguments, named); + match name { + "test" => gen_test(cg, &args).map(Some), + "expect" => gen_expect(cg, &args).map(Some), + "check" => gen_check(cg, &args).map(Some), + _ => Ok(None), + } +} + +/// `test(name, body)`: begin (returns whether the case runs, applying the +/// `OSPREY_TEST_FILTER` skip [TESTING-FILTER]), branch around the invoked +/// body, end (prints the TAP result line). +fn gen_test(cg: &mut Codegen, args: &[&Expr]) -> Result { + let [name_expr, body_expr] = args else { + return Err(CodegenError::invalid("test needs (name, body) arguments")); + }; + let name_str = eval_to_string(cg, name_expr)?; + cg.testing_used = true; + let run = cg.call("i32", "osp_test_begin", "i8*", &[&name_str.operand]); + let cond = cg.emit_reg(format!("icmp ne i32 {run}, 0")); + let (run_bb, end_bb) = (cg.fresh_label(), cg.fresh_label()); + cg.emit(format!("br i1 {cond}, label %{run_bb}, label %{end_bb}")); + cg.start_block(&run_bb); + // Invoking the body as a synthesized zero-arg call reuses the whole call + // dispatch: an inline lambda beta-reduces, a named function or closure + // value calls through its normal path. + let invoke = Expr::Call { + function: Box::new((*body_expr).clone()), + arguments: Vec::new(), + named_arguments: Vec::new(), + }; + let _ = gen_expr(cg, &invoke)?; + cg.call_void("osp_test_end", "i8*", &[&name_str.operand]); + let _ = cg.snapshot_to(&end_bb); + cg.start_block(&end_bb); + Ok(Value::unit()) +} + +/// `expect(actual, expected)` — Jest argument order, no label. +fn gen_expect(cg: &mut Codegen, args: &[&Expr]) -> Result { + let [actual, expected] = args else { + return Err(CodegenError::invalid( + "expect needs (actual, expected) arguments", + )); + }; + let a = eval_to_string(cg, actual)?; + let e = eval_to_string(cg, expected)?; + Ok(emit_assert(cg, "null", &e, &a)) +} + +/// `check(label, expected, actual)` — Alcotest argument order. +fn gen_check(cg: &mut Codegen, args: &[&Expr]) -> Result { + let [label, expected, actual] = args else { + return Err(CodegenError::invalid( + "check needs (label, expected, actual) arguments", + )); + }; + let l = eval_to_string(cg, label)?; + let e = eval_to_string(cg, expected)?; + let a = eval_to_string(cg, actual)?; + Ok(emit_assert(cg, &l.operand, &e, &a)) +} + +/// Evaluate one assertion operand to its canonical string: a Success renders +/// as its bare payload, an Error as `Error()` (a visible mismatch, +/// never a blind payload load), everything else through the shared `toString` +/// lowering [TESTING-EQUALITY]. +fn eval_to_string(cg: &mut Codegen, expr: &Expr) -> Result { + let v = gen_expr(cg, expr)?; + reject_opaque_handle(&v)?; + if v.result_inner.is_some() { + return crate::runtime::result_payload_or_error_string(cg, &v); + } + to_string_value(cg, v) +} + +/// Lists, maps, records, and other runtime handles have no canonical string +/// rendering yet, so an assertion on one would compare raw pointers — reject +/// loudly instead [TESTING-EQUALITY]. +fn reject_opaque_handle(v: &Value) -> Result<()> { + let opaque = (v.result_inner.is_none() && v.ty == crate::llty::LType::Ptr) + || v.result_inner == Some(crate::llty::LType::Ptr); + if opaque { + return Err(CodegenError::unsupported( + "expect/check on a list, map, or record value; compare scalar fields or elements", + )); + } + Ok(()) +} + +/// Compare two canonical strings and record the verdict with the runtime. +/// `label_op` is the rendered label operand — `null` for `expect`. +fn emit_assert(cg: &mut Codegen, label_op: &str, expected: &Value, actual: &Value) -> Value { + cg.testing_used = true; + let c = cg.call( + "i32", + "strcmp", + "i8*, i8*", + &[&actual.operand, &expected.operand], + ); + let ok = cg.emit_reg(format!("icmp eq i32 {c}, 0")); + let ok32 = cg.emit_reg(format!("zext i1 {ok} to i32")); + cg.call_void( + "osp_test_assert", + "i8*, i32, i8*, i8*", + &[label_op, &ok32, &expected.operand, &actual.operand], + ); + Value::unit() +} diff --git a/crates/osprey-lsp/src/analysis.rs b/crates/osprey-lsp/src/analysis.rs index 64058b7b..46a6901a 100644 --- a/crates/osprey-lsp/src/analysis.rs +++ b/crates/osprey-lsp/src/analysis.rs @@ -662,7 +662,7 @@ fn params_json(params: &[(String, String)]) -> String { format!("[{}]", items.join(",")) } -fn json_str(s: &str) -> String { +pub(crate) fn json_str(s: &str) -> String { let mut out = String::with_capacity(s.len().saturating_add(2)); out.push('"'); for c in s.chars() { diff --git a/crates/osprey-lsp/src/lib.rs b/crates/osprey-lsp/src/lib.rs index 4e48cbd7..1b1591a5 100644 --- a/crates/osprey-lsp/src/lib.rs +++ b/crates/osprey-lsp/src/lib.rs @@ -13,9 +13,11 @@ pub mod engine; pub mod features; pub mod model; pub mod server; +pub mod testing; pub mod text; pub mod wire; pub use crate::analysis::{builtin_hover, symbols_json}; pub use crate::engine::OspreyEngine; pub use crate::server::run_stdio; +pub use crate::testing::tests_json; diff --git a/crates/osprey-lsp/src/testing.rs b/crates/osprey-lsp/src/testing.rs new file mode 100644 index 00000000..bf951950 --- /dev/null +++ b/crates/osprey-lsp/src/testing.rs @@ -0,0 +1,219 @@ +//! Static test-case discovery: find `test("name", …)` calls with a literal +//! name, for the `--list-tests` CLI mode and editor test explorers. Discovery +//! is statement-scoped — a `test` call is found wherever it stands as a +//! statement value (top level, block statements, lambda/handler/match bodies, +//! namespaces, modules); dynamically-named or expression-buried calls still +//! run and report via TAP, they are just not statically listable. Implements +//! [TESTING-LIST] (docs/specs/0027-TestingFramework.md). + +use crate::analysis::json_str; +use osprey_ast::{Expr, Position, Program, Stmt}; + +/// One statically-discovered test case: its literal name and the position of +/// the nearest enclosing statement (the `test` call's own line in practice). +#[derive(Debug)] +pub struct TestCase { + /// The test's literal name (the first argument to `test`). + pub name: String, + /// 1-based line / 0-based column of the enclosing statement. + pub position: Option, +} + +/// The `--list-tests` JSON array: `[{"name":…,"line":…,"column":…}, …]`. +/// Line and column are 1-based on the wire, matching `symbols_json`. +#[must_use] +pub fn tests_json(program: &Program) -> String { + let rendered: Vec = collect_tests(program).iter().map(case_json).collect(); + format!("[{}]", rendered.join(",")) +} + +fn case_json(case: &TestCase) -> String { + let (line, column) = case + .position + .map_or((1, 1), |p| (p.line, p.column.saturating_add(1))); + format!( + "{{\"name\":{},\"line\":{line},\"column\":{column}}}", + json_str(&case.name) + ) +} + +/// Collect every statically-visible test case, in source order. +#[must_use] +pub fn collect_tests(program: &Program) -> Vec { + let mut out = Vec::new(); + walk_stmts(&program.statements, None, &mut out); + out +} + +fn walk_stmts(stmts: &[Stmt], pos: Option, out: &mut Vec) { + for stmt in stmts { + walk_stmt(stmt, pos, out); + } +} + +fn walk_stmt(stmt: &Stmt, pos: Option, out: &mut Vec) { + match stmt { + Stmt::Let { + value, position, .. + } + | Stmt::Assignment { + value, position, .. + } + | Stmt::Expr { + value, position, .. + } => walk_value(value, position.or(pos), out), + Stmt::Function { body, position, .. } => walk_value(body, position.or(pos), out), + Stmt::Namespace { body, .. } => walk_stmts(body, pos, out), + Stmt::Module { body, .. } => { + for item in body { + walk_stmt(&item.declaration, pos, out); + } + } + _ => {} + } +} + +/// Descend a statement's value into the containers a test call can stand in. +fn walk_value(expr: &Expr, pos: Option, out: &mut Vec) { + match expr { + Expr::Call { + function, + arguments, + .. + } => record_test_call(function, arguments, pos, out), + Expr::Block { statements, value } => { + walk_stmts(statements, pos, out); + if let Some(v) = value { + walk_value(v, pos, out); + } + } + Expr::Lambda { body, position, .. } => walk_value(body, position.or(pos), out), + Expr::Handler { + arms, + body, + position, + .. + } => { + let pos = position.or(pos); + for arm in arms { + walk_value(&arm.body, pos, out); + } + walk_value(body, pos, out); + } + Expr::Match { arms, .. } => { + for arm in arms { + walk_value(&arm.body, pos, out); + } + } + _ => {} + } +} + +/// Record a call whose callee is the bare identifier `test` and whose first +/// positional argument is a string literal. +fn record_test_call( + function: &Expr, + arguments: &[Expr], + pos: Option, + out: &mut Vec, +) { + if let (Expr::Identifier(callee), Some(Expr::Str(name))) = (function, arguments.first()) { + if callee == "test" { + out.push(TestCase { + name: name.clone(), + position: pos, + }); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use osprey_syntax::{parse_program, parse_program_with_flavor, Flavor}; + + fn program(src: &str) -> Program { + let parsed = parse_program(src); + assert!( + parsed.errors.is_empty(), + "syntax errors: {:?}", + parsed.errors + ); + parsed.program + } + + fn ml_program(src: &str) -> Program { + let parsed = parse_program_with_flavor(src, Flavor::Ml); + assert!( + parsed.errors.is_empty(), + "syntax errors: {:?}", + parsed.errors + ); + parsed.program + } + + #[test] + fn lists_top_level_literal_tests_with_positions() { + let json = tests_json(&program( + "fn add(a, b) = a + b\n\ntest(\"adds\", fn() => expect(add(1, 2), 3))\ntest(\"doubles\", fn() => expect(2 * 2, 4))\n", + )); + assert_eq!( + json, + "[{\"name\":\"adds\",\"line\":3,\"column\":1},{\"name\":\"doubles\",\"line\":4,\"column\":1}]" + ); + } + + #[test] + fn skips_dynamic_names_and_unrelated_calls() { + let cases = collect_tests(&program( + "let name = \"dyn\"\ntest(name, fn() => expect(1, 1))\nprint(\"not a test\")\n", + )); + assert!(cases.is_empty()); + } + + #[test] + fn finds_tests_in_main_blocks_and_ml_modules() { + let in_main = collect_tests(&program( + "fn main() = {\n test(\"in main\", fn() => expect(1, 1))\n}\n", + )); + let names: Vec<&str> = in_main.iter().map(|c| c.name.as_str()).collect(); + assert_eq!(names, ["in main"]); + + let in_module = collect_tests(&ml_program( + "namespace demo\n\nmodule Cases\n run () =\n test \"inside module\" (\\() => check \"x\" 1 1)\n", + )); + let names: Vec<&str> = in_module.iter().map(|c| c.name.as_str()).collect(); + assert_eq!(names, ["inside module"]); + } + + #[test] + fn finds_tests_under_match_and_handler_arms() { + let cases = collect_tests(&program( + "effect Env {\n mode: fn() -> string\n}\nfn suite() !Env = match perform Env.mode() {\n \"fast\" => test(\"fast case\", fn() => expect(1, 1))\n _ => test(\"slow case\", fn() => expect(2, 2))\n}\nhandle Env\n mode => resume(\"fast\")\nin {\n suite()\n}\n", + )); + let names: Vec<&str> = cases.iter().map(|c| c.name.as_str()).collect(); + assert_eq!(names, ["fast case", "slow case"]); + } + + #[test] + fn json_escapes_quoted_test_names_and_renders_empty_array() { + let json = tests_json(&program("test(\"lit \\\"q\\\"\", fn() => expect(1, 1))\n")); + assert_eq!( + json, + "[{\"name\":\"lit \\\"q\\\"\",\"line\":1,\"column\":1}]" + ); + assert_eq!(tests_json(&program("print(\"none\")\n")), "[]"); + } + + #[test] + fn missing_positions_default_to_line_one() { + let case = TestCase { + name: String::from("anon"), + position: None, + }; + assert_eq!( + case_json(&case), + "{\"name\":\"anon\",\"line\":1,\"column\":1}" + ); + } +} diff --git a/crates/osprey-types/src/builtin_docs.rs b/crates/osprey-types/src/builtin_docs.rs index ba4f477a..850e65e2 100644 --- a/crates/osprey-types/src/builtin_docs.rs +++ b/crates/osprey-types/src/builtin_docs.rs @@ -36,6 +36,7 @@ fn builtin_docs() -> impl Iterator { use crate::builtin_docs_sys as sys; [ lang::CORE, + lang::TESTING, lang::STRINGS, lang::FUNCTIONAL, lang::LISTS, diff --git a/crates/osprey-types/src/builtin_docs_lang.rs b/crates/osprey-types/src/builtin_docs_lang.rs index 9e3fca39..704f292c 100644 --- a/crates/osprey-types/src/builtin_docs_lang.rs +++ b/crates/osprey-types/src/builtin_docs_lang.rs @@ -95,6 +95,30 @@ pub(crate) static CORE: &[BuiltinDoc] = &[ ), ]; +/// Testing framework built-in documentation [TESTING-BUILTINS] +/// (docs/specs/0027-TestingFramework.md). Prose only — types come from the +/// authoritative scheme in `builtins.rs`, joined by name. +pub(crate) static TESTING: &[BuiltinDoc] = &[ + builtin_doc!( + "test", + "Runs `body` as one named test case and prints a TAP result line. A case fails when any assertion inside it fails; the program exits non-zero if any case failed.", + ["name" => "The test case's name", "body" => "A zero-parameter function containing the case's assertions"], + "test(\"addition works\", fn() => expect(2 + 3, 5))", + ), + builtin_doc!( + "expect", + "Asserts two values are equal (canonical-string equality, Results auto-unwrapped). On mismatch, marks the enclosing test failed and prints a diagnostic; execution continues.", + ["actual" => "The computed value", "expected" => "The value it should equal"], + "test(\"doubling\", fn() => expect(21 * 2, 42))", + ), + builtin_doc!( + "check", + "Labeled equality assertion in Alcotest argument order (expected before actual). Behaves exactly like expect, with the label in the failure diagnostic.", + ["label" => "A short description of what is being checked", "expected" => "The value the actual must equal", "actual" => "The computed value"], + "test(\"doubling\", fn() => check(\"double\", 42, 21 * 2))", + ), +]; + /// `strings` built-in documentation. Prose only — types come from the /// authoritative scheme in `builtins.rs`, joined by name. pub(crate) static STRINGS: &[BuiltinDoc] = &[ diff --git a/crates/osprey-types/src/builtins.rs b/crates/osprey-types/src/builtins.rs index 2d87a089..7463370f 100644 --- a/crates/osprey-types/src/builtins.rs +++ b/crates/osprey-types/src/builtins.rs @@ -52,10 +52,16 @@ fn poly(env: &mut TypeEnv, name: &str, vars: Vec, params: Vec, ret: T env.insert(name, Scheme::poly(vars, Type::fun(params, ret))); } +/// Built-ins a user function may redefine: the testing names are common +/// identifiers, so a same-named user function shadows the built-in instead of +/// erroring. Implements [TESTING-SHADOWING] (docs/specs/0027-TestingFramework.md). +pub const SHADOWABLE_BUILTINS: &[&str] = &["test", "expect", "check"]; + /// Install every built-in into a base environment. pub fn base_env() -> TypeEnv { let mut e = TypeEnv::new(); core(&mut e); + testing(&mut e); strings(&mut e); functional(&mut e); lists(&mut e); @@ -89,6 +95,17 @@ fn core(e: &mut TypeEnv) { mono(e, "not", vec![b()], b()); } +/// The testing framework's built-ins. Implements [TESTING-BUILTINS] +/// (docs/specs/0027-TestingFramework.md). +fn testing(e: &mut TypeEnv) { + // test(name, body): run `body` as one named test case. [TESTING-BUILTIN-TEST] + mono(e, "test", vec![s(), Type::fun(vec![], u())], u()); + // expect(actual, expected): Jest argument order. [TESTING-BUILTIN-EXPECT] + mono(e, "expect", vec![any(), any()], u()); + // check(label, expected, actual): Alcotest argument order. [TESTING-BUILTIN-CHECK] + mono(e, "check", vec![s(), any(), any()], u()); +} + fn strings(e: &mut TypeEnv) { mono(e, "contains", vec![s(), s()], b()); mono(e, "startsWith", vec![s(), s()], b()); diff --git a/crates/osprey-types/src/check.rs b/crates/osprey-types/src/check.rs index 19f41a87..1e3fb6e2 100644 --- a/crates/osprey-types/src/check.rs +++ b/crates/osprey-types/src/check.rs @@ -484,7 +484,9 @@ impl Checker { return_type: Option<&TypeExpr>, env: &mut TypeEnv, ) { - if self.builtins.contains(name) { + // The testing built-ins are shadowable by design [TESTING-SHADOWING]: + // a user `fn test/expect/check` replaces the built-in scheme below. + if self.builtins.contains(name) && !crate::builtins::SHADOWABLE_BUILTINS.contains(&name) { self.errors.push(TypeError::new(format!( "cannot redefine built-in function `{name}`" ))); @@ -893,6 +895,40 @@ mod tests { assert!(errs.iter().any(|e| e.message.contains("type mismatch"))); } + #[test] + fn testing_builtins_typecheck_and_reject_bad_arity() { + // [TESTING-BUILTINS] the three schemes accept the documented shapes. + let errs = check( + "test(\"adds\", fn() => expect(1 + 1, 2))\n\ + test(\"labeled\", fn() => check(\"sum\", 4, 2 + 2))\n", + ); + assert!(errs.is_empty(), "unexpected type errors: {errs:?}"); + let errs = check("expect(1)\n"); + assert!(errs.iter().any(|e| e.message.contains("arity"))); + let errs = check("test(42, fn() => expect(1, 1))\n"); + assert!( + !errs.is_empty(), + "a non-string test name must not typecheck" + ); + } + + #[test] + fn testing_builtins_are_shadowable_but_others_stay_reserved() { + // [TESTING-SHADOWING] a user test/expect/check replaces the built-in; + // every other built-in still rejects redefinition. + let errs = check( + "fn check(t: int) -> int = t + 1\n\ + fn expect(a: int) -> int = a\n\ + fn test(x: int) -> int = x\n\ + let r = check(expect(test(1)))\n", + ); + assert!(errs.is_empty(), "unexpected type errors: {errs:?}"); + let errs = check("fn range(t: int) -> int = t\n"); + assert!(errs + .iter() + .any(|e| e.message.contains("cannot redefine built-in"))); + } + #[test] fn declared_typaram_functions_generalize_regardless_of_binding_direction() { // Regression lock for the builtin binder-id collision: builtin schemes diff --git a/docs/specs/0012-Built-InFunctions.md b/docs/specs/0012-Built-InFunctions.md index 889fcc1d..c3ecda5e 100644 --- a/docs/specs/0012-Built-InFunctions.md +++ b/docs/specs/0012-Built-InFunctions.md @@ -45,6 +45,39 @@ n = ### `toString(value: int | string | bool) -> string` Converts any value to its string representation. +## Testing Functions — [TESTING-BUILTINS] + +The built-in testing framework. Normative rules — TAP output, exit codes, +filtering, discovery, the `osprey test` runner, and the VS Code Test Explorer +— live in [Testing Framework](0027-TestingFramework.md); the three functions +are listed here for completeness. + +### `test(name: string, body: fn() -> Unit) -> Unit` — [TESTING-BUILTIN-TEST] +Runs `body` as one named test case and prints a TAP result line. A program +that uses any testing built-in exits non-zero when a case failed. + +### `expect(actual: any, expected: any) -> Unit` — [TESTING-BUILTIN-EXPECT] +Equality assertion, Jest argument order. Canonical-string equality with +`Result` auto-unwrap; a mismatch marks the enclosing case failed and prints a +diagnostic without aborting the case. + +### `check(label: string, expected: any, actual: any) -> Unit` — [TESTING-BUILTIN-CHECK] +Labeled equality assertion, Alcotest argument order (expected before actual). + +```osprey +fn add(a, b) = a + b +test("addition works", fn() => expect(add(2, 3), 5)) +``` + +```osprey-ml +add (a, b) = a + b +test "addition works" (\() => check "sum" 5 (add (2, 3))) +``` + +Unlike other built-ins, these three names are shadowable: a user-defined +`test`/`expect`/`check` function replaces the built-in +([TESTING-SHADOWING]). + ## Numeric Functions ### `abs(n: int) -> int` diff --git a/docs/specs/0027-TestingFramework.md b/docs/specs/0027-TestingFramework.md index 126134ac..425c626c 100644 --- a/docs/specs/0027-TestingFramework.md +++ b/docs/specs/0027-TestingFramework.md @@ -56,6 +56,11 @@ The `body` argument must be a zero-parameter function: an inline lambda (Default `fn() => …`, ML `\() => …`) or the name of a zero-parameter function. Any other expression is a compile-time codegen error. +Test cases must not nest: a `test` call evaluated while another case is +running does not run its body — it prints a +`# nested test '' skipped …` diagnostic and fails the enclosing case, +so the mistake is loud rather than silently reshuffling the run's counters. + ```osprey test("addition works", fn() => { expect(add(2, 3), 5) @@ -85,22 +90,26 @@ Both assertions are valid anywhere an expression is — inside `test` bodies, in helper functions called from tests, or at the top level of a script. **`[TESTING-SHADOWING]`** Unlike other runtime built-ins, `test`, `expect`, -and `check` do NOT reserve their names: a user-defined function with the same -name shadows the built-in in both the type environment and codegen dispatch. -This keeps pre-existing programs (e.g. a `fn check(t: Tree)` helper) compiling -unchanged. +and `check` do NOT reserve their names: a user-defined function or `extern` +declaration with the same name shadows the built-in in both the type +environment and codegen dispatch. This keeps pre-existing programs (e.g. a +`fn check(t: Tree)` helper or an `extern fn check(...)`) compiling unchanged. ## Equality semantics -**`[TESTING-EQUALITY]`** Assertion equality is *canonical-string equality*: -both sides are auto-unwrapped if they are `Result` values (mirroring the `==` -operator's checker rule), rendered with the same `toString` lowering used by -string interpolation, and compared with `strcmp`. This gives uniform, -structural, human-explainable equality across ints, bools, floats, strings, -`Result`s, records, and lists — the diagnostic shows exactly the two rendered -strings that were compared. Corollary: values of different types that render -identically (e.g. `5` and `"5"`) compare equal; assert on the value the test -actually computes. +**`[TESTING-EQUALITY]`** Assertion equality is *canonical-string equality* +over values with a canonical string rendering: ints, bools, floats, strings, +and `Result`s of those. Both sides render with the same `toString` lowering +used by string interpolation and compare with `strcmp`; the diagnostic shows +exactly the two rendered strings that were compared. A `Result` operand +renders discriminant-aware: a `Success` as its bare payload (so +`expect(intDiv(4, 2), 2)` passes), an `Error` as `Error()` (so +asserting against a failed computation is a visible mismatch, never a blind +payload read). Lists, maps, and records have no canonical rendering yet, so +an assertion operand of those types is a compile-time codegen error rather +than a silent pointer comparison. Corollary: values of different types that +render identically (e.g. `5` and `"5"`) compare equal; assert on the value +the test actually computes. ## TAP output protocol @@ -125,9 +134,10 @@ not ok 2 - subtraction works - A failing assertion outside any test prints its diagnostic and counts toward the run's failure total without producing a result line. - After the program's last statement, the runtime epilogue prints the plan - `1..N` (N = cases executed) and a `# tests=N passed=P failed=F` summary. - The epilogue is emitted only for programs that use a testing built-in; - ordinary programs are unaffected. + `1..N` (N = cases executed) and a `# tests=N passed=P failed=F` summary — + including `1..0` when zero cases executed, so a filter that matched nothing + stays visible. The epilogue is emitted only for programs that use a testing + built-in; ordinary programs are unaffected. ## Exit code @@ -158,7 +168,7 @@ gate — any Osprey program may call the testing built-ins. Runs test files and aggregates results. `path` (default `.`) is either a single file (run as-is, regardless of naming) or a directory searched recursively for `[TESTING-FILE-CONVENTION]` files (sorted, deterministic -order, hidden/`target` dirs skipped). Each file is compiled and executed like +order; hidden/`target`/`node_modules` dirs skipped; symlinks not followed). Each file is compiled and executed like `osprey --run`; its TAP output streams through unmodified under a `# file: ` header line. `--filter` sets `OSPREY_TEST_FILTER` for the child processes. After all files, the runner prints @@ -171,15 +181,18 @@ failures or compile errors), else `0`. An empty discovery set is a failure Static test discovery for editors. Parses the file (skipping the type gate, like `--symbols`, so discovery works mid-edit) and prints a JSON array of the statically visible test cases — `test(...)` calls whose first argument is a -string literal, found anywhere in the program's expression trees: +string literal, found wherever a call stands as a statement value (top level, +block statements, lambda/handler/match bodies, namespaces, modules): ```json [{"name":"addition works","line":3,"column":1}] ``` -`line`/`column` are 1-based and point at the `test` call. Dynamically named -tests (non-literal first argument) still run and report via TAP; they are -simply not listed statically. +`line`/`column` are 1-based and point at the test call's nearest enclosing +statement — the call's own line in the conventional top-level layout; for a +test that is a function or lambda body, the enclosing declaration's line. +Dynamically named tests (non-literal first argument) still run and report via +TAP; they are simply not listed statically. ## VS Code Test Explorer diff --git a/examples/tested/testing/calculator.test.expectedoutput b/examples/tested/testing/calculator.test.expectedoutput new file mode 100644 index 00000000..f39519cf --- /dev/null +++ b/examples/tested/testing/calculator.test.expectedoutput @@ -0,0 +1,6 @@ +ok 1 - addition works +ok 2 - pipes and lambdas compose +ok 3 - pattern matching classifies +ok 4 - interpolation and bools +1..4 +# tests=4 passed=4 failed=0 diff --git a/examples/tested/testing/calculator.test.osp b/examples/tested/testing/calculator.test.osp new file mode 100644 index 00000000..e5de583a --- /dev/null +++ b/examples/tested/testing/calculator.test.osp @@ -0,0 +1,28 @@ +// The testing framework's own executable example [TESTING-BUILTINS]: +// Jest-style test/expect in the Default flavor, twinned with the ML file. +fn add(a, b) = a + b +fn double(x) = x * 2 +fn parity(n) = match n % 2 == 0 { + true => "even" + false => "odd" +} + +fn additionCase() = { + expect(add(2, 3), 5) + expect(add(-1, 1), 0) +} + +fn pipelineCase() = { + expect(10 |> double |> double, 40) + expect(5 |> fn(x) => x + 100, 105) +} + +fn patternCase() = { + expect(parity(4), "even") + expect(parity(7), "odd") +} + +test("addition works", additionCase) +test("pipes and lambdas compose", pipelineCase) +test("pattern matching classifies", patternCase) +test("interpolation and bools", fn() => expect("sum=${add(20, 22)} big=${3 < 5 && 5 >= 5}", "sum=42 big=true")) diff --git a/examples/tested/testing/calculator.test.ospml b/examples/tested/testing/calculator.test.ospml new file mode 100644 index 00000000..c012dee4 --- /dev/null +++ b/examples/tested/testing/calculator.test.ospml @@ -0,0 +1,25 @@ +// The testing framework's own executable example [TESTING-BUILTINS]: +// test/expect in the ML flavor, twinned with the Default file. +add (a, b) = a + b +double x = x * 2 +parity n = + match n % 2 == 0 + true => "even" + false => "odd" + +additionCase () = + expect (add (2, 3)) 5 + expect (add (-1, 1)) 0 + +pipelineCase () = + expect (10 |> double |> double) 40 + expect (5 |> \x => x + 100) 105 + +patternCase () = + expect (parity 4) "even" + expect (parity 7) "odd" + +test "addition works" additionCase +test "pipes and lambdas compose" pipelineCase +test "pattern matching classifies" patternCase +test "interpolation and bools" (\() => expect "sum=${add (20, 22)} big=${3 < 5 && 5 >= 5}" "sum=42 big=true") diff --git a/examples/tested/testing/mlcheck.test.expectedoutput b/examples/tested/testing/mlcheck.test.expectedoutput new file mode 100644 index 00000000..47617ff0 --- /dev/null +++ b/examples/tested/testing/mlcheck.test.expectedoutput @@ -0,0 +1,5 @@ +ok 1 - arithmetic checks +ok 2 - classification checks +ok 3 - string and list checks +1..3 +# tests=3 passed=3 failed=0 diff --git a/examples/tested/testing/mlcheck.test.osp b/examples/tested/testing/mlcheck.test.osp new file mode 100644 index 00000000..92ab7f8c --- /dev/null +++ b/examples/tested/testing/mlcheck.test.osp @@ -0,0 +1,29 @@ +// Alcotest-style check(label, expected, actual) in the Default flavor +// [TESTING-BUILTIN-CHECK], twinned with the ML file. +fn sub(a, b) = a - b +fn classify(n) = match n { + 0 => "zero" + 1 => "one" + _ => "many" +} + +fn arithmeticCase() = { + check("difference", 4, sub(7, 3)) + check("product", 42, 6 * 7) +} + +fn classifyCase() = { + check("zero", "zero", classify(0)) + check("one", "one", classify(1)) + check("many", "many", classify(9)) +} + +fn stringsCase() = { + check("contains", true, contains("talon bank", "bank")) + check("repeat unwraps Result", "ababab", repeat("ab", 3)) + check("list length", 3, listLength([10, 20, 30])) +} + +test("arithmetic checks", arithmeticCase) +test("classification checks", classifyCase) +test("string and list checks", stringsCase) diff --git a/examples/tested/testing/mlcheck.test.ospml b/examples/tested/testing/mlcheck.test.ospml new file mode 100644 index 00000000..47140ab4 --- /dev/null +++ b/examples/tested/testing/mlcheck.test.ospml @@ -0,0 +1,26 @@ +// Alcotest-style check(label, expected, actual) in the ML flavor +// [TESTING-BUILTIN-CHECK], twinned with the Default file. +sub (a, b) = a - b +classify n = + match n + 0 => "zero" + 1 => "one" + _ => "many" + +arithmeticCase () = + check "difference" 4 (sub (7, 3)) + check "product" 42 (6 * 7) + +classifyCase () = + check "zero" "zero" (classify 0) + check "one" "one" (classify 1) + check "many" "many" (classify 9) + +stringsCase () = + check "contains" true (contains ("talon bank", "bank")) + check "repeat unwraps Result" "ababab" (repeat ("ab", 3)) + check "list length" 3 (listLength [10, 20, 30]) + +test "arithmetic checks" arithmeticCase +test "classification checks" classifyCase +test "string and list checks" stringsCase diff --git a/vscode-extension/client/src/extension.ts b/vscode-extension/client/src/extension.ts index 1fdbc1c5..82be9785 100644 --- a/vscode-extension/client/src/extension.ts +++ b/vscode-extension/client/src/extension.ts @@ -21,6 +21,7 @@ import { TransportKind, } from "vscode-languageclient/node"; import { registerOspreyDebugPanel } from "./debug-panel"; +import { registerOspreyTestExplorer } from "./test-explorer"; // @nimblesite/shipwright-vscode is ESM-only; this extension is CommonJS, so it // is loaded via dynamic import() (never a static require) inside activate(). @@ -355,6 +356,11 @@ export function activate(context: ExtensionContext) { outputChannel.appendLine("=== Osprey Extension Activation ==="); outputChannel.show(); + // Native Test Explorer integration ([TESTING-VSCODE]). Registered before the + // server-enabled gate: test discovery/running only needs the compiler CLI, so + // it must keep working even with the LSP disabled. + registerOspreyTestExplorer(context, () => resolveServerCommand(context)); + // Check if Osprey server is enabled const config = workspace.getConfiguration("osprey"); if (!config.get("server.enabled", true)) { diff --git a/vscode-extension/client/src/test-explorer-parse.ts b/vscode-extension/client/src/test-explorer-parse.ts new file mode 100644 index 00000000..273deeb0 --- /dev/null +++ b/vscode-extension/client/src/test-explorer-parse.ts @@ -0,0 +1,300 @@ +// Pure logic for the Osprey Test Explorer ([TESTING-VSCODE]): parsing the +// compiler's `--list-tests` JSON and TAP run output, planning which files and +// leaf tests a run request targets, and mapping TAP results back onto test +// items. No `vscode` import — everything here unit-tests directly; the wiring +// lives in test-explorer.ts (mirroring debug-panel.ts's pure/wiring split). + +/** One statically discovered test case from `osprey --list-tests`. */ +export interface DiscoveredTest { + readonly name: string; + /** 1-based source line of the `test(...)` call. */ + readonly line: number; + /** 1-based source column of the `test(...)` call. */ + readonly column: number; +} + +/** The outcome of parsing a `--list-tests` invocation. */ +export type TestListParse = + | { readonly ok: true; readonly tests: DiscoveredTest[] } + | { readonly ok: false; readonly error: string }; + +/** One TAP result line with the `#` diagnostics that preceded it. */ +export interface TapResult { + readonly name: string; + readonly ok: boolean; + readonly comments: string[]; +} + +/** What a run should report for one leaf test ([TESTING-TAP]). */ +export type LeafOutcome = + | { readonly status: "passed" } + | { readonly status: "failed"; readonly message: string } + | { readonly status: "skipped" }; + +/** What one finished compiler process looked like. */ +export interface ExecResult { + readonly stdout: string; + readonly stderr: string; + readonly exitCode: number; +} + +/** The shape of vscode.TestItem that run planning needs (two-level tree). */ +export interface TestItemLike { + readonly id: string; + readonly parent?: TestItemLike | undefined; +} + +/** One file's share of a run request. */ +export interface FilePlan { + readonly file: T; + /** Requested leaves; ignored when `wholeFile` is set. */ + readonly leaves: T[]; + wholeFile: boolean; +} + +function isDiscoveredTest(value: unknown): value is DiscoveredTest { + const record = value as { name?: unknown; line?: unknown; column?: unknown }; + return ( + typeof value === "object" && + value !== null && + typeof record.name === "string" && + typeof record.line === "number" && + typeof record.column === "number" + ); +} + +/** Parse the JSON array printed by `--list-tests` ([TESTING-LIST]). */ +export function parseTestList(json: string): TestListParse { + let parsed: unknown; + try { + parsed = JSON.parse(json); + } catch (error) { + return { ok: false, error: `--list-tests printed invalid JSON: ${error}` }; + } + if (!Array.isArray(parsed)) { + return { ok: false, error: "--list-tests did not print a JSON array" }; + } + const bad = parsed.find((entry) => !isDiscoveredTest(entry)); + if (bad !== undefined) { + return { ok: false, error: `--list-tests entry is malformed: ${JSON.stringify(bad)}` }; + } + return { ok: true, tests: parsed as DiscoveredTest[] }; +} + +/** Fold a whole `--list-tests` process result into a parse outcome. */ +export function discoveryOutcome(result: ExecResult): TestListParse { + if (result.exitCode !== 0) { + const detail = result.stderr.trim(); + return { + ok: false, + error: detail || `--list-tests exited with code ${result.exitCode}`, + }; + } + return parseTestList(result.stdout); +} + +/** Everything a TAP stream carries beyond the per-case results. */ +export interface TapStream { + readonly results: TapResult[]; + /** `#` lines not attached to any following result (e.g. stray-assert diagnostics). */ + readonly strayComments: string[]; + /** Whether a `1..N` plan line was seen — proof the test runtime epilogue ran. */ + readonly sawPlan: boolean; +} + +// The runtime prints results as exactly `ok N - name` / `not ok N - name` +// ([TESTING-TAP]); the name is everything after "- " to end of line, captured +// byte-exact (leading/trailing whitespace preserved) so it matches +// `--list-tests` names precisely. +const TAP_RESULT = /^(not )?ok \d+ - (.*)$/; +const TAP_COMMENT = /^#\s?(.*)$/; +const TAP_PLAN = /^\d+\.\.\d+$/; +const TAP_SUMMARY = /^tests=\d+ passed=\d+ failed=\d+/; + +/** + * Parse a TAP stream ([TESTING-TAP]): one entry per `ok`/`not ok` line, each + * carrying the `#` diagnostic lines seen since the previous result line. + * Ordinary program output is ignored; the plan line (`1..N`, always printed, + * `1..0` included) sets `sawPlan`; `#` lines after the last result (stray + * out-of-case assertion diagnostics, the trailing summary) become + * `strayComments`. + */ +export function parseTapStream(stdout: string): TapStream { + const results: TapResult[] = []; + let comments: string[] = []; + let sawPlan = false; + for (const line of stdout.split(/\r?\n/)) { + const result = TAP_RESULT.exec(line); + if (result) { + results.push({ name: result[2], ok: result[1] === undefined, comments }); + comments = []; + } else if (TAP_PLAN.test(line)) { + sawPlan = true; + } else { + const comment = TAP_COMMENT.exec(line); + if (comment) { + comments.push(comment[1]); + } + } + } + return { results, strayComments: comments, sawPlan }; +} + +/** Just the per-case results of a TAP stream. */ +export function parseTapOutput(stdout: string): TapResult[] { + return parseTapStream(stdout).results; +} + +// A leaf id embeds the parent uri and the exact test name; the separator can +// never occur in a `file:` uri string, so ids stay collision-free. +const LEAF_ID_SEPARATOR = " "; + +/** The TestItem id for a test file (its uri string). */ +export function fileTestId(uriString: string): string { + return uriString; +} + +/** The TestItem id for one named test inside a file. */ +export function leafTestId(uriString: string, name: string): string { + return `${uriString}${LEAF_ID_SEPARATOR}${name}`; +} + +/** A zero-based document position (what vscode.Position takes). */ +export interface ZeroBasedPosition { + readonly line: number; + readonly character: number; +} + +/** Convert a discovered test's 1-based line/column to a 0-based position. */ +export function testRangeStart(test: DiscoveredTest): ZeroBasedPosition { + return { + line: Math.max(0, test.line - 1), + character: Math.max(0, test.column - 1), + }; +} + +/** The ids a run request excludes (both file and leaf items). */ +export function excludedIdSet( + exclude: readonly TestItemLike[] | undefined, +): ReadonlySet { + return new Set((exclude ?? []).map((item) => item.id)); +} + +function isExcluded(item: TestItemLike, excluded: ReadonlySet): boolean { + return excluded.has(item.id) || (item.parent !== undefined && excluded.has(item.parent.id)); +} + +/** + * Group a run request's items into per-file plans: a requested file item means + * "run the whole file" (one unfiltered process); requested leaves of a file + * not itself requested each get their own OSPREY_TEST_FILTER run + * ([TESTING-FILTER]). Excluded items (or leaves of excluded files) drop out. + */ +export function planRun( + requested: readonly T[], + excluded: ReadonlySet = new Set(), +): FilePlan[] { + const plans = new Map>(); + for (const item of requested) { + if (isExcluded(item, excluded)) { + continue; + } + const file = (item.parent ?? item) as T; + const plan = plans.get(file.id) ?? { file, leaves: [], wholeFile: false }; + plans.set(file.id, plan); + if (item.parent === undefined) { + plan.wholeFile = true; + } else { + plan.leaves.push(item); + } + } + return [...plans.values()]; +} + +/** + * Map one requested leaf onto the TAP results. Absent from the output means + * skipped (e.g. filtered out, or removed from the file since discovery); a + * duplicate name resolves to the last matching result. + */ +export function outcomeForLeaf( + name: string, + results: readonly TapResult[], +): LeafOutcome { + const matches = results.filter((result) => result.name === name); + const result = matches[matches.length - 1]; + if (result === undefined) { + return { status: "skipped" }; + } + if (result.ok) { + return { status: "passed" }; + } + return { + status: "failed", + message: result.comments.join("\n") || `Test failed: ${name}`, + }; +} + +/** + * A non-zero exit with no TAP at all (no results, no plan line) means the file + * never ran — a compile/type error. A run whose plan printed but produced no + * results (e.g. a filter matching nothing) is NOT a compile failure. + */ +export function isCompileFailure(exitCode: number, stream: TapStream): boolean { + return exitCode !== 0 && !stream.sawPlan && stream.results.length === 0; +} + +/** + * The failure message for a run that exited non-zero although no test case + * reported `not ok` — an assertion OUTSIDE any test failed ([TESTING-TAP]). + * Returns the collected `#` diagnostics (summary line excluded), else stderr, + * else a generic message; undefined when the exit code or a `not ok` result + * already explains the failure. Call after ruling out a compile failure. + */ +export function strayFailureMessage( + stream: TapStream, + exitCode: number, + stderr: string, +): string | undefined { + if (exitCode === 0 || stream.results.some((result) => !result.ok)) { + return undefined; + } + const diagnostics = [ + ...stream.results.flatMap((result) => result.comments), + ...stream.strayComments, + ].filter((comment) => !TAP_SUMMARY.test(comment)); + return ( + diagnostics.join("\n") || + stderr.trim() || + `osprey --run exited with code ${exitCode} although every test case passed` + ); +} + +/** + * The child environment for one `--run` invocation ([TESTING-FILTER]): a + * filtered run sets OSPREY_TEST_FILTER explicitly; an unfiltered run DELETES + * it so a stray value inherited from the editor's environment cannot silently + * skip test cases. Never mutates `base`. + */ +export function testRunEnv( + base: NodeJS.ProcessEnv, + filter: string | undefined, +): NodeJS.ProcessEnv { + const env = { ...base }; + if (filter === undefined) { + delete env.OSPREY_TEST_FILTER; + } else { + env.OSPREY_TEST_FILTER = filter; + } + return env; +} + +/** The message for a run that produced no TAP ([TESTING-EXIT] compile path). */ +export function compileFailureMessage(stderr: string, exitCode: number): string { + const detail = stderr.trim(); + return detail || `osprey --run exited with code ${exitCode} and produced no TAP output`; +} + +/** Test Explorer output is a pseudoterminal: lines must end in CRLF. */ +export function toTerminalOutput(text: string): string { + return text.replace(/\r?\n/g, "\r\n"); +} diff --git a/vscode-extension/client/src/test-explorer.ts b/vscode-extension/client/src/test-explorer.ts new file mode 100644 index 00000000..c27087f6 --- /dev/null +++ b/vscode-extension/client/src/test-explorer.ts @@ -0,0 +1,418 @@ +// Native VS Code Test Explorer integration for Osprey ([TESTING-VSCODE]): +// discovers `*.test.{osp,ospml}` files, resolves their cases via +// `osprey --list-tests`, and runs them via `osprey --run`, +// mapping the TAP stream back onto test items. All decision logic is pure and +// lives in test-explorer-parse.ts; this file is the thin vscode/child_process +// wiring, structured like debug-panel.ts. + +import { spawn, type ChildProcess } from "child_process"; +import * as path from "path"; +import type { Readable } from "stream"; +import * as vscode from "vscode"; +import { + compileFailureMessage, + discoveryOutcome, + excludedIdSet, + fileTestId, + isCompileFailure, + leafTestId, + outcomeForLeaf, + parseTapStream, + planRun, + strayFailureMessage, + testRangeStart, + testRunEnv, + toTerminalOutput, + type DiscoveredTest, + type ExecResult, + type FilePlan, + type LeafOutcome, + type TestListParse, +} from "./test-explorer-parse"; + +/** The discovery glob — both flavors ([TESTING-FILE-CONVENTION]). */ +export const TEST_FILE_GLOB = "**/*.test.{osp,ospml}"; + +const CONTROLLER_ID = "ospreyTests"; +const CONTROLLER_LABEL = "Osprey Tests"; + +/** + * The slice of vscode.TestRun the executor reports through. A real TestRun + * satisfies it structurally; tests substitute a recording sink to observe the + * run without touching Test Explorer internals. + */ +export interface TestRunSink { + enqueued(test: vscode.TestItem): void; + started(test: vscode.TestItem): void; + passed(test: vscode.TestItem, duration?: number): void; + failed( + test: vscode.TestItem, + message: vscode.TestMessage | readonly vscode.TestMessage[], + duration?: number, + ): void; + errored( + test: vscode.TestItem, + message: vscode.TestMessage | readonly vscode.TestMessage[], + duration?: number, + ): void; + skipped(test: vscode.TestItem): void; + appendOutput(output: string): void; + end(): void; +} + +// On POSIX the compiler child is spawned detached (its own process group) so +// cancellation can kill the WHOLE tree: `osprey --run` execs the compiled test +// binary as a grandchild, and killing only osprey would leave a hanging test +// running forever. +const POSIX = process.platform !== "win32"; + +// killProcessTree hard-kills a compiler invocation and everything it spawned: +// the process group on POSIX (guarded — the group may already be gone), a +// direct kill otherwise (win32, or an undefined pid after a failed spawn). +function killProcessTree(child: ChildProcess): void { + if (POSIX && child.pid !== undefined) { + try { + process.kill(-child.pid, "SIGKILL"); + return; + } catch { + // Group already exited or child is not a leader; fall back to direct kill. + } + } + child.kill("SIGKILL"); +} + +function collectOutput(stream: Readable): () => string { + let data = ""; + stream.setEncoding("utf8"); + stream.on("data", (chunk: string) => (data += chunk)); + return () => data; +} + +// runCompiler spawns the osprey compiler and resolves (never rejects) with the +// process outcome. spawn — not execFile — is deliberate: no maxBuffer cap to +// truncate verbose test output, and `detached` enables the group kill above. A +// spawn failure (e.g. ENOENT) maps to exit -1 with the message in stderr. +// Cancellation kills the process tree AND settles the promise immediately, so +// a run always reaches its end even if the child were to linger. +function runCompiler( + command: string, + args: readonly string[], + cwd: string, + env: NodeJS.ProcessEnv, + token?: vscode.CancellationToken, +): Promise { + return new Promise((resolve) => { + const child = spawn(command, [...args], { cwd, env, detached: POSIX }); + const stdout = collectOutput(child.stdout); + const stderr = collectOutput(child.stderr); + let spawnFailure = ""; + let settled = false; + const settle = (exitCode: number): void => { + if (!settled) { + settled = true; + resolve({ stdout: stdout(), stderr: `${spawnFailure}${stderr()}`, exitCode }); + } + }; + child.on("error", (error) => { + spawnFailure = `${error.message}\n`; + settle(-1); + }); + child.on("close", (code) => settle(code ?? -1)); + token?.onCancellationRequested(() => { + killProcessTree(child); + settle(-1); + }); + }); +} + +/** A test file's Explorer label: workspace-relative path, or basename outside one. */ +export function testFileLabel(uri: vscode.Uri): string { + return vscode.workspace.getWorkspaceFolder(uri) !== undefined + ? vscode.workspace.asRelativePath(uri, false) + : path.basename(uri.fsPath); +} + +function getOrCreateFileItem( + controller: vscode.TestController, + uri: vscode.Uri, +): vscode.TestItem { + const id = fileTestId(uri.toString()); + const existing = controller.items.get(id); + if (existing !== undefined) { + return existing; + } + const item = controller.createTestItem(id, testFileLabel(uri), uri); + controller.items.add(item); + return item; +} + +function makeLeafItem( + controller: vscode.TestController, + uri: vscode.Uri, + test: DiscoveredTest, +): vscode.TestItem { + const leaf = controller.createTestItem(leafTestId(uri.toString(), test.name), test.name, uri); + const start = testRangeStart(test); + leaf.range = new vscode.Range(start.line, start.character, start.line, start.character); + return leaf; +} + +function applyDiscovery( + controller: vscode.TestController, + item: vscode.TestItem, + uri: vscode.Uri, + outcome: TestListParse, +): void { + if (!outcome.ok) { + item.error = outcome.error; + item.children.replace([]); + return; + } + item.error = undefined; + item.children.replace(outcome.tests.map((test) => makeLeafItem(controller, uri, test))); +} + +/** + * (Re-)discover one test file: create/refresh its file-level item and replace + * its children from `--list-tests` ([TESTING-LIST]). A parse failure surfaces + * as the file item's error message (discovery skips the type gate, so this + * only happens on syntax errors). + */ +export async function refreshTestFile( + controller: vscode.TestController, + uri: vscode.Uri, + compiler: string, +): Promise { + const item = getOrCreateFileItem(controller, uri); + const result = await runCompiler( + compiler, + [uri.fsPath, "--list-tests"], + path.dirname(uri.fsPath), + process.env, + ); + applyDiscovery(controller, item, uri, discoveryOutcome(result)); + return item; +} + +/** Drop a deleted test file's item from the tree. */ +export function removeTestFile(controller: vscode.TestController, uri: vscode.Uri): void { + controller.items.delete(fileTestId(uri.toString())); +} + +/** Initial workspace scan. `findFiles` is injectable so tests can seed uris. */ +export async function scanWorkspaceTestFiles( + controller: vscode.TestController, + resolveCompiler: () => string, + findFiles: (glob: string) => Thenable = (glob) => + vscode.workspace.findFiles(glob), +): Promise { + for (const uri of await findFiles(TEST_FILE_GLOB)) { + await refreshTestFile(controller, uri, resolveCompiler()); + } +} + +/** The items a request targets: its `include`, or every root when absent. */ +export function requestedItems( + controller: vscode.TestController, + request: Pick, +): vscode.TestItem[] { + if (request.include !== undefined) { + return [...request.include]; + } + const roots: vscode.TestItem[] = []; + controller.items.forEach((item) => roots.push(item)); + return roots; +} + +function markLeaf(leaf: vscode.TestItem, outcome: LeafOutcome, sink: TestRunSink): void { + if (outcome.status === "passed") { + sink.passed(leaf); + } else if (outcome.status === "failed") { + sink.failed(leaf, new vscode.TestMessage(outcome.message)); + } else { + sink.skipped(leaf); + } +} + +function includedChildren( + file: vscode.TestItem, + excluded: ReadonlySet, +): vscode.TestItem[] { + const leaves: vscode.TestItem[] = []; + file.children.forEach((leaf) => { + if (!excluded.has(leaf.id)) { + leaves.push(leaf); + } + }); + return leaves; +} + +// runLeaves executes one `osprey --run` process (filtered to a single +// case when `filter` is set — [TESTING-FILTER]) and reports every leaf's +// outcome. A compile error (non-zero exit, no TAP) marks `errorTarget` (the +// file item for whole-file runs, the leaf for filtered runs) and any other +// started leaves errored with the compiler's stderr. +async function runLeaves( + errorTarget: vscode.TestItem, + leaves: vscode.TestItem[], + filter: string | undefined, + sink: TestRunSink, + token: vscode.CancellationToken, + compiler: string, +): Promise { + const uri = errorTarget.uri; + if (uri === undefined) { + return; + } + for (const leaf of leaves) { + sink.enqueued(leaf); + sink.started(leaf); + } + const env = testRunEnv(process.env, filter); + const result = await runCompiler(compiler, [uri.fsPath, "--run"], path.dirname(uri.fsPath), env, token); + if (token.isCancellationRequested) { + return; + } + reportLeaves(errorTarget, leaves, result, sink); +} + +function reportCompileFailure( + errorTarget: vscode.TestItem, + leaves: vscode.TestItem[], + result: ExecResult, + sink: TestRunSink, +): void { + const message = new vscode.TestMessage(compileFailureMessage(result.stderr, result.exitCode)); + sink.errored(errorTarget, message); + for (const leaf of leaves.filter((item) => item !== errorTarget)) { + sink.errored(leaf, message); + } +} + +function reportLeaves( + errorTarget: vscode.TestItem, + leaves: vscode.TestItem[], + result: ExecResult, + sink: TestRunSink, +): void { + sink.appendOutput(toTerminalOutput(result.stdout + result.stderr)); + const stream = parseTapStream(result.stdout); + if (isCompileFailure(result.exitCode, stream)) { + reportCompileFailure(errorTarget, leaves, result, sink); + return; + } + for (const leaf of leaves) { + markLeaf(leaf, outcomeForLeaf(leaf.label, stream.results), sink); + } + // Exit 1 with every case ok: an assertion OUTSIDE any test failed. Surface + // it on the file item (or the requested leaf) or the run looks green. + const stray = strayFailureMessage(stream, result.exitCode, result.stderr); + if (stray !== undefined) { + sink.failed(errorTarget, new vscode.TestMessage(stray)); + } +} + +async function runPlan( + plan: FilePlan, + excluded: ReadonlySet, + sink: TestRunSink, + token: vscode.CancellationToken, + compiler: string, +): Promise { + const leaves = plan.wholeFile ? includedChildren(plan.file, excluded) : plan.leaves; + // One unfiltered process only when the whole file truly runs. A whole-file + // request with exclusions falls through to per-leaf filtered runs so the + // excluded cases never execute — not merely go unreported. + if (plan.wholeFile && leaves.length === plan.file.children.size) { + await runLeaves(plan.file, leaves, undefined, sink, token, compiler); + return; + } + for (const leaf of leaves) { + if (token.isCancellationRequested) { + return; + } + await runLeaves(leaf, [leaf], leaf.label, sink, token, compiler); + } +} + +// A whole-file run needs the file's cases; if a run lands before discovery has +// (e.g. "Run All" during activation), resolve the file first. +async function ensureFileResolved( + controller: vscode.TestController, + plan: FilePlan, + compiler: string, +): Promise { + const uri = plan.file.uri; + if (plan.wholeFile && uri !== undefined && plan.file.children.size === 0) { + await refreshTestFile(controller, uri, compiler); + } +} + +/** Execute a run request against the sink, honoring cancellation throughout. */ +export async function executeRunRequest( + controller: vscode.TestController, + request: vscode.TestRunRequest, + sink: TestRunSink, + token: vscode.CancellationToken, + resolveCompiler: () => string, +): Promise { + const excluded = excludedIdSet(request.exclude); + for (const plan of planRun(requestedItems(controller, request), excluded)) { + if (token.isCancellationRequested) { + break; + } + const compiler = resolveCompiler(); + await ensureFileResolved(controller, plan, compiler); + await runPlan(plan, excluded, sink, token, compiler); + } + sink.end(); +} + +/** The handler behind the default Run profile: one real TestRun per request. */ +export function makeRunHandler( + controller: vscode.TestController, + resolveCompiler: () => string, +): (request: vscode.TestRunRequest, token: vscode.CancellationToken) => Promise { + return (request, token) => + executeRunRequest(controller, request, controller.createTestRun(request), token, resolveCompiler); +} + +/** The file-watcher callbacks (exported so they are directly testable). */ +export function makeWatcherHandlers( + controller: vscode.TestController, + resolveCompiler: () => string, +): { refresh: (uri: vscode.Uri) => Promise; remove: (uri: vscode.Uri) => void } { + return { + refresh: (uri) => refreshTestFile(controller, uri, resolveCompiler()), + remove: (uri) => removeTestFile(controller, uri), + }; +} + +/** + * Register the Osprey Test Explorer: controller + default Run profile, initial + * workspace scan, and a watcher that re-resolves changed/created test files + * and drops deleted ones. `resolveCompiler` is the same resolution chain the + * LSP uses (setting → bundled → PATH). `controllerId` is overridable only so + * tests can register disposable controllers beside the real one. + */ +export function registerOspreyTestExplorer( + context: vscode.ExtensionContext, + resolveCompiler: () => string, + controllerId: string = CONTROLLER_ID, +): vscode.TestController { + const controller = vscode.tests.createTestController(controllerId, CONTROLLER_LABEL); + controller.createRunProfile( + "Run", + vscode.TestRunProfileKind.Run, + makeRunHandler(controller, resolveCompiler), + true, + ); + const handlers = makeWatcherHandlers(controller, resolveCompiler); + const watcher = vscode.workspace.createFileSystemWatcher(TEST_FILE_GLOB); + watcher.onDidCreate((uri) => void handlers.refresh(uri)); + watcher.onDidChange((uri) => void handlers.refresh(uri)); + watcher.onDidDelete(handlers.remove); + void scanWorkspaceTestFiles(controller, resolveCompiler); + context.subscriptions.push(controller, watcher); + return controller; +} diff --git a/vscode-extension/package.json b/vscode-extension/package.json index 0548b972..0065b5fb 100644 --- a/vscode-extension/package.json +++ b/vscode-extension/package.json @@ -39,7 +39,9 @@ "onCommand:osprey.compile", "onCommand:osprey.run", "onCommand:osprey.debug", - "onDebugResolve:osprey" + "onDebugResolve:osprey", + "workspaceContains:**/*.test.osp", + "workspaceContains:**/*.test.ospml" ], "contributes": { "languages": [ diff --git a/vscode-extension/test/suite/test-explorer-harness.ts b/vscode-extension/test/suite/test-explorer-harness.ts new file mode 100644 index 00000000..fb680a74 --- /dev/null +++ b/vscode-extension/test/suite/test-explorer-harness.ts @@ -0,0 +1,90 @@ +// Shared harness for the Test Explorer integration suite: the Osprey fixture +// sources and a recording TestRunSink that captures run events for assertion. + +import * as vscode from "vscode"; +import type { TestRunSink } from "../../client/src/test-explorer"; + +/** Two passing cases ("addition works" line 3, "zero identity" line 7). */ +export const PASS_FIXTURE = `fn add(a, b) = a + b + +test("addition works", fn() => { + expect(add(2, 3), 5) +}) + +test("zero identity", fn() => { + expect(add(0, 0), 0) +}) +`; + +/** "bad math" fails (expected 3, got 2), "good math" passes. */ +export const FAIL_FIXTURE = `fn add(a, b) = a + b + +test("bad math", fn() => { + expect(add(1, 1), 3) +}) + +test("good math", fn() => { + expect(add(1, 1), 2) +}) +`; + +/** One passing ML-flavor case, "ml addition". */ +export const ML_FIXTURE = `add (a, b) = a + b + +test "ml addition" (\\() => + check "sum" 5 (add (2, 3))) +`; + +/** Does not parse — `--list-tests` and `--run` both fail with syntax errors. */ +export const BROKEN_FIXTURE = "fn broken( = nonsense !!\n"; + +/** + * One passing case plus a failing assertion OUTSIDE any test: TAP is all-ok + * but the process exits 1 ([TESTING-EXIT]). + */ +export const STRAY_FIXTURE = `fn add(a, b) = a + b + +test("fine", fn() => { + expect(add(1, 1), 2) +}) + +expect(add(1, 1), 5) +`; + +export interface SinkEvent { + kind: "enqueued" | "started" | "passed" | "failed" | "errored" | "skipped" | "end"; + id?: string; + message?: string; +} + +type SinkMessage = vscode.TestMessage | readonly vscode.TestMessage[]; + +function messageText(message: SinkMessage): string { + const first = (Array.isArray(message) ? message[0] : message) as vscode.TestMessage; + return typeof first.message === "string" ? first.message : first.message.value; +} + +/** A TestRunSink that records every reported event and all appended output. */ +export class RecordingSink implements TestRunSink { + public readonly events: SinkEvent[] = []; + public output = ""; + + private record(kind: SinkEvent["kind"], test?: vscode.TestItem, message?: SinkMessage): void { + this.events.push({ + kind, + ...(test ? { id: test.id } : {}), + ...(message ? { message: messageText(message) } : {}), + }); + } + public enqueued(test: vscode.TestItem): void { this.record("enqueued", test); } + public started(test: vscode.TestItem): void { this.record("started", test); } + public passed(test: vscode.TestItem): void { this.record("passed", test); } + public failed(test: vscode.TestItem, message: SinkMessage): void { this.record("failed", test, message); } + public errored(test: vscode.TestItem, message: SinkMessage): void { this.record("errored", test, message); } + public skipped(test: vscode.TestItem): void { this.record("skipped", test); } + public appendOutput(output: string): void { this.output += output; } + public end(): void { this.record("end"); } + public ofKind(kind: SinkEvent["kind"]): SinkEvent[] { + return this.events.filter((event) => event.kind === kind); + } +} diff --git a/vscode-extension/test/suite/test-explorer-parse.test.ts b/vscode-extension/test/suite/test-explorer-parse.test.ts new file mode 100644 index 00000000..825c9e3e --- /dev/null +++ b/vscode-extension/test/suite/test-explorer-parse.test.ts @@ -0,0 +1,248 @@ +// Tests for the Osprey Test Explorer's pure logic ([TESTING-VSCODE]): TAP +// stream parsing, `--list-tests` JSON parsing, id/range helpers, outcome +// mapping, and run planning. No fixtures, compiler, or controller needed — +// the discovery/run flows are covered in test-explorer.test.ts. + +import * as assert from "assert"; +import { + compileFailureMessage, + discoveryOutcome, + excludedIdSet, + fileTestId, + isCompileFailure, + leafTestId, + outcomeForLeaf, + parseTapOutput, + parseTapStream, + parseTestList, + planRun, + strayFailureMessage, + testRangeStart, + testRunEnv, + toTerminalOutput, + type TestItemLike, +} from "../../client/src/test-explorer-parse"; + +suite("Test Explorer parsing", () => { + suite("parseTapOutput", () => { + test("maps result lines and attaches preceding diagnostics", () => { + const stream = [ + "# expect failed: expected 3, got 2", + "not ok 1 - bad math", + "ok 2 - good math", + "1..2", + "# tests=2 passed=1 failed=1", + ].join("\n"); + assert.deepStrictEqual(parseTapOutput(stream), [ + { name: "bad math", ok: false, comments: ["expect failed: expected 3, got 2"] }, + { name: "good math", ok: true, comments: [] }, + ]); + }); + + test("joins multiple diagnostics, resets between results, ignores noise and CRLF", () => { + const stream = + "program output\r\n# first\r\n# second\r\nnot ok 1 - x\r\nok 2 - y\r\n1..2\r\n"; + assert.deepStrictEqual(parseTapOutput(stream), [ + { name: "x", ok: false, comments: ["first", "second"] }, + { name: "y", ok: true, comments: [] }, + ]); + }); + + test("returns no results for empty output or compile-error text", () => { + assert.deepStrictEqual(parseTapOutput(""), []); + assert.deepStrictEqual( + parseTapOutput('broken.test.osp:1:0: syntax error near "fn"'), + [], + ); + }); + + test("captures names byte-exact: leading/trailing spaces and dashes survive", () => { + const results = parseTapOutput( + "ok 1 - padded\nok 2 - trailing \nnot ok 3 - a - b - c\n1..3\n", + ); + assert.deepStrictEqual( + results.map((result) => result.name), + [" padded", "trailing ", "a - b - c"], + ); + }); + + test("parseTapStream reports the plan line and stray trailing diagnostics", () => { + const stream = parseTapStream( + "ok 1 - fine\n# expect failed: expected 5, got 2\n1..1\n# tests=1 passed=1 failed=0\n", + ); + assert.strictEqual(stream.sawPlan, true); + assert.deepStrictEqual(stream.results.map((result) => result.name), ["fine"]); + assert.deepStrictEqual(stream.strayComments, [ + "expect failed: expected 5, got 2", + "tests=1 passed=1 failed=0", + ]); + const empty = parseTapStream("1..0\n# tests=0 passed=0 failed=0\n"); + assert.strictEqual(empty.sawPlan, true); + assert.deepStrictEqual(empty.results, []); + assert.strictEqual(parseTapStream("").sawPlan, false); + }); + }); + + suite("parseTestList and discoveryOutcome", () => { + const valid = '[{"name":"a","line":3,"column":1},{"name":"b","line":8,"column":2}]'; + + test("parses a valid list and an empty list", () => { + const parsed = parseTestList(valid); + assert.ok(parsed.ok); + assert.deepStrictEqual(parsed.tests.map((t) => t.name), ["a", "b"]); + const empty = parseTestList("[]"); + assert.ok(empty.ok); + assert.deepStrictEqual(empty.tests, []); + }); + + test("rejects malformed JSON, non-arrays, and malformed entries", () => { + const invalid = parseTestList("not json {"); + assert.ok(!invalid.ok); + assert.match(invalid.error, /invalid JSON/); + const nonArray = parseTestList('{"name":"a"}'); + assert.ok(!nonArray.ok); + assert.match(nonArray.error, /JSON array/); + const badEntry = parseTestList('[{"name":"a"}]'); + assert.ok(!badEntry.ok); + assert.match(badEntry.error, /malformed/); + const nonObject = parseTestList("[5]"); + assert.ok(!nonObject.ok); + }); + + test("discoveryOutcome folds exit codes and stderr", () => { + assert.ok(discoveryOutcome({ stdout: valid, stderr: "", exitCode: 0 }).ok); + const failed = discoveryOutcome({ stdout: "", stderr: "x.osp:1:0: bad\n", exitCode: 1 }); + assert.ok(!failed.ok); + assert.strictEqual(failed.error, "x.osp:1:0: bad"); + const silent = discoveryOutcome({ stdout: "", stderr: "", exitCode: 3 }); + assert.ok(!silent.ok); + assert.match(silent.error, /exited with code 3/); + assert.ok(!discoveryOutcome({ stdout: "garbage", stderr: "", exitCode: 0 }).ok); + }); + }); + + suite("ids, ranges, and outcomes", () => { + test("file and leaf ids are stable and distinct per test name", () => { + const uri = "file:///work/a.test.osp"; + assert.strictEqual(fileTestId(uri), uri); + assert.ok(leafTestId(uri, "adds").startsWith(uri)); + assert.notStrictEqual(leafTestId(uri, "adds"), leafTestId(uri, "subtracts")); + assert.ok(leafTestId(uri, "adds").includes("adds")); + }); + + test("testRangeStart converts 1-based positions and clamps at zero", () => { + assert.deepStrictEqual( + testRangeStart({ name: "t", line: 3, column: 5 }), + { line: 2, character: 4 }, + ); + assert.deepStrictEqual( + testRangeStart({ name: "t", line: 0, column: 0 }), + { line: 0, character: 0 }, + ); + }); + + test("outcomeForLeaf maps pass, fail, fallback message, absent, and duplicates", () => { + const results = [ + { name: "p", ok: true, comments: [] }, + { name: "f", ok: false, comments: ["expected 3, got 2", "second"] }, + { name: "bare", ok: false, comments: [] }, + { name: "dup", ok: true, comments: [] }, + { name: "dup", ok: false, comments: ["later loss"] }, + ]; + assert.deepStrictEqual(outcomeForLeaf("p", results), { status: "passed" }); + assert.deepStrictEqual(outcomeForLeaf("f", results), { + status: "failed", + message: "expected 3, got 2\nsecond", + }); + assert.deepStrictEqual(outcomeForLeaf("bare", results), { + status: "failed", + message: "Test failed: bare", + }); + assert.deepStrictEqual(outcomeForLeaf("missing", results), { status: "skipped" }); + assert.strictEqual(outcomeForLeaf("dup", results).status, "failed"); + }); + + test("isCompileFailure and compileFailureMessage", () => { + const noTap = parseTapStream("x.osp:1:0: syntax error"); + assert.strictEqual(isCompileFailure(1, noTap), true); + assert.strictEqual(isCompileFailure(0, noTap), false); + assert.strictEqual(isCompileFailure(1, parseTapStream("not ok 1 - t\n1..1")), false); + // A plan line proves the tests ran, even with zero results (1..0). + assert.strictEqual(isCompileFailure(1, parseTapStream("1..0")), false); + assert.strictEqual(compileFailureMessage(" x.osp:1:1: bad \n", 1), "x.osp:1:1: bad"); + assert.match(compileFailureMessage("", 2), /exited with code 2/); + }); + + test("strayFailureMessage flags all-ok runs that exit non-zero", () => { + const stray = parseTapStream( + "ok 1 - fine\n# expect failed: expected 5, got 2\n1..1\n# tests=1 passed=1 failed=0\n", + ); + assert.strictEqual( + strayFailureMessage(stray, 1, ""), + "expect failed: expected 5, got 2", + ); + // Diagnostics attached to passing results are collected too. + const attached = parseTapStream("# early stray\nok 1 - fine\n1..1\n"); + assert.strictEqual(strayFailureMessage(attached, 1, ""), "early stray"); + // No diagnostics: stderr, then a generic message. + const bare = parseTapStream("ok 1 - fine\n1..1\n"); + assert.strictEqual(strayFailureMessage(bare, 1, " boom \n"), "boom"); + assert.match(String(strayFailureMessage(bare, 1, "")), /exited with code 1/); + // Explained failures produce nothing. + assert.strictEqual(strayFailureMessage(bare, 0, ""), undefined); + assert.strictEqual( + strayFailureMessage(parseTapStream("not ok 1 - t\n1..1"), 1, ""), + undefined, + ); + }); + + test("testRunEnv sets the filter or scrubs an inherited one, without mutating", () => { + const base: NodeJS.ProcessEnv = { PATH: "/bin", OSPREY_TEST_FILTER: "stale" }; + const unfiltered = testRunEnv(base, undefined); + assert.strictEqual(unfiltered.OSPREY_TEST_FILTER, undefined); + assert.ok(!("OSPREY_TEST_FILTER" in unfiltered)); + assert.strictEqual(unfiltered.PATH, "/bin"); + const filtered = testRunEnv(base, "one test"); + assert.strictEqual(filtered.OSPREY_TEST_FILTER, "one test"); + assert.strictEqual(base.OSPREY_TEST_FILTER, "stale"); + }); + + test("toTerminalOutput normalizes line endings to CRLF", () => { + assert.strictEqual(toTerminalOutput("a\nb\n"), "a\r\nb\r\n"); + assert.strictEqual(toTerminalOutput("a\r\nb"), "a\r\nb"); + }); + }); + + suite("planRun", () => { + const fileA: TestItemLike = { id: "A" }; + const leafA1: TestItemLike = { id: "A#1", parent: fileA }; + const leafA2: TestItemLike = { id: "A#2", parent: fileA }; + const fileB: TestItemLike = { id: "B" }; + const leafB1: TestItemLike = { id: "B#1", parent: fileB }; + + test("a requested file becomes a whole-file plan", () => { + const plans = planRun([fileA]); + assert.strictEqual(plans.length, 1); + assert.strictEqual(plans[0].file.id, "A"); + assert.strictEqual(plans[0].wholeFile, true); + }); + + test("leaves group by file; a file request subsumes its leaves", () => { + const leafPlans = planRun([leafA1, leafA2, leafB1]); + assert.strictEqual(leafPlans.length, 2); + assert.deepStrictEqual(leafPlans[0].leaves.map((l) => l.id), ["A#1", "A#2"]); + assert.strictEqual(leafPlans[0].wholeFile, false); + const merged = planRun([leafA1, fileA]); + assert.strictEqual(merged.length, 1); + assert.strictEqual(merged[0].wholeFile, true); + }); + + test("excluded files and leaves drop out", () => { + assert.deepStrictEqual(planRun([fileA], excludedIdSet([fileA])), []); + assert.deepStrictEqual(planRun([leafA1], excludedIdSet([fileA])), []); + const plans = planRun([leafA1, leafA2], excludedIdSet([leafA2])); + assert.deepStrictEqual(plans[0].leaves.map((l) => l.id), ["A#1"]); + assert.strictEqual(excludedIdSet(undefined).size, 0); + }); + }); +}); diff --git a/vscode-extension/test/suite/test-explorer.test.ts b/vscode-extension/test/suite/test-explorer.test.ts new file mode 100644 index 00000000..bd6b2111 --- /dev/null +++ b/vscode-extension/test/suite/test-explorer.test.ts @@ -0,0 +1,491 @@ +// Integration tests for the Osprey Test Explorer ([TESTING-VSCODE]): discovery +// and run flows against a real TestController, temp-dir fixture files, and the +// freshly built osprey compiler. The pure parsing/planning helpers are covered +// in test-explorer-parse.test.ts. + +import * as assert from "assert"; +import * as fs from "fs"; +import * as os from "os"; +import * as path from "path"; +import * as vscode from "vscode"; +import { fileTestId, leafTestId } from "../../client/src/test-explorer-parse"; +import { + executeRunRequest, makeRunHandler, makeWatcherHandlers, refreshTestFile, + registerOspreyTestExplorer, removeTestFile, requestedItems, + scanWorkspaceTestFiles, testFileLabel, +} from "../../client/src/test-explorer"; +import { resolveBuiltOsprey } from "./osprey-test-env"; +import { + BROKEN_FIXTURE, FAIL_FIXTURE, ML_FIXTURE, PASS_FIXTURE, RecordingSink, + STRAY_FIXTURE, +} from "./test-explorer-harness"; + +suite("Osprey Test Explorer", () => { + const compiler = resolveBuiltOsprey(); + let fixtureDir: string; + let passUri: vscode.Uri; + let failUri: vscode.Uri; + let mlUri: vscode.Uri; + let brokenUri: vscode.Uri; + let strayUri: vscode.Uri; + const disposables: vscode.Disposable[] = []; + let controllerSequence = 0; + + function newController( + resolveCompiler: () => string = () => compiler ?? "osprey", + ): vscode.TestController { + controllerSequence += 1; + const context = { subscriptions: disposables } as unknown as vscode.ExtensionContext; + return registerOspreyTestExplorer( + context, + resolveCompiler, + `ospreyTests-spec-${controllerSequence}`, + ); + } + + function writeFixture(name: string, content: string): vscode.Uri { + const filePath = path.join(fixtureDir, name); + fs.writeFileSync(filePath, content); + return vscode.Uri.file(filePath); + } + + suiteSetup(() => { + fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), "osprey-test-explorer-")); + passUri = writeFixture("pass.test.osp", PASS_FIXTURE); + failUri = writeFixture("fail.test.osp", FAIL_FIXTURE); + mlUri = writeFixture("ml.test.ospml", ML_FIXTURE); + brokenUri = writeFixture("broken.test.osp", BROKEN_FIXTURE); + strayUri = writeFixture("stray.test.osp", STRAY_FIXTURE); + }); + + suiteTeardown(() => { + fs.rmSync(fixtureDir, { recursive: true, force: true }); + }); + + teardown(() => { + for (const disposable of disposables.splice(0)) { + disposable.dispose(); + } + }); + + suite("discovery", () => { + test("registerOspreyTestExplorer wires controller, run profile, and watcher", () => { + const controller = newController(); + assert.strictEqual(controller.label, "Osprey Tests"); + assert.ok(controller.id.startsWith("ospreyTests-spec-")); + assert.strictEqual(disposables.length, 2); + }); + + test("testFileLabel outside a workspace is the basename", () => { + assert.strictEqual(testFileLabel(passUri), "pass.test.osp"); + }); + + test("refreshTestFile discovers leaves with names, ids, and ranges", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const item = await refreshTestFile(controller, passUri, compiler); + assert.strictEqual(item.error, undefined); + assert.strictEqual(item.label, "pass.test.osp"); + assert.strictEqual(item.children.size, 2); + const first = item.children.get(leafTestId(passUri.toString(), "addition works")); + assert.ok(first); + assert.strictEqual(first.label, "addition works"); + assert.strictEqual(first.range?.start.line, 2); + assert.strictEqual(first.range?.start.character, 0); + const second = item.children.get(leafTestId(passUri.toString(), "zero identity")); + assert.strictEqual(second?.range?.start.line, 6); + }); + + test("refreshTestFile re-resolves children after edits", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const uri = writeFixture("edited.test.osp", PASS_FIXTURE); + const before = await refreshTestFile(controller, uri, compiler); + assert.strictEqual(before.children.size, 2); + fs.writeFileSync(uri.fsPath, 'test("only one", fn() => expect(1, 1))\n'); + const after = await refreshTestFile(controller, uri, compiler); + assert.strictEqual(after.children.size, 1); + assert.strictEqual(after, before); + }); + + test("refreshTestFile discovers the ML flavor", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const item = await refreshTestFile(controller, mlUri, compiler); + assert.strictEqual(item.children.size, 1); + assert.ok(item.children.get(leafTestId(mlUri.toString(), "ml addition"))); + }); + + test("a syntax error surfaces on the file item with no children", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const item = await refreshTestFile(controller, brokenUri, compiler); + assert.match(String(item.error), /syntax error/); + assert.strictEqual(item.children.size, 0); + }); + + test("a missing compiler surfaces as the file item's error", async () => { + const controller = newController(); + const item = await refreshTestFile(controller, passUri, "/nonexistent/osprey-xyz"); + assert.match(String(item.error), /ENOENT|nonexistent/); + }); + + test("removeTestFile and the watcher handlers add and drop items", async () => { + const controller = newController(); + const handlers = makeWatcherHandlers(controller, () => "/nonexistent/osprey-xyz"); + await handlers.refresh(passUri); + assert.ok(controller.items.get(fileTestId(passUri.toString()))); + handlers.remove(passUri); + assert.strictEqual(controller.items.get(fileTestId(passUri.toString())), undefined); + await refreshTestFile(controller, passUri, "/nonexistent/osprey-xyz"); + removeTestFile(controller, passUri); + assert.strictEqual(controller.items.size, 0); + }); + + test("scanWorkspaceTestFiles seeds items from the finder", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + await scanWorkspaceTestFiles(controller, () => compiler, () => + Promise.resolve([passUri]), + ); + assert.strictEqual(controller.items.get(fileTestId(passUri.toString()))?.children.size, 2); + const emptyHost = newController(); + await scanWorkspaceTestFiles(emptyHost, () => compiler ?? "osprey"); + assert.strictEqual(emptyHost.items.size, 0); + }); + }); + + suite("run", () => { + function token(): vscode.CancellationToken { + return new vscode.CancellationTokenSource().token; + } + + async function discoveredFile( + controller: vscode.TestController, + uri: vscode.Uri, + ): Promise { + const item = await refreshTestFile(controller, uri, compiler ?? "osprey"); + assert.strictEqual(item.error, undefined); + return item; + } + + test("a whole-file run maps TAP results onto leaves with diagnostics", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, failUri); + const sink = new RecordingSink(); + const request = new vscode.TestRunRequest([file]); + await executeRunRequest(controller, request, sink, token(), () => compiler); + const goodId = leafTestId(failUri.toString(), "good math"); + const badId = leafTestId(failUri.toString(), "bad math"); + assert.deepStrictEqual(sink.ofKind("passed").map((e) => e.id), [goodId]); + const failures = sink.ofKind("failed"); + assert.deepStrictEqual(failures.map((e) => e.id), [badId]); + assert.match(String(failures[0].message), /expect failed: expected 3, got 2/); + assert.strictEqual(sink.ofKind("enqueued").length, 2); + assert.ok(sink.output.includes("\r\n")); + assert.ok(sink.output.includes("not ok 1 - bad math")); + assert.deepStrictEqual(sink.events[sink.events.length - 1], { kind: "end" }); + }); + + test("a single requested leaf runs with OSPREY_TEST_FILTER", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, failUri); + const good = file.children.get(leafTestId(failUri.toString(), "good math")); + assert.ok(good); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([good]), + sink, + token(), + () => compiler, + ); + assert.deepStrictEqual(sink.ofKind("passed").map((e) => e.id), [good.id]); + assert.strictEqual(sink.ofKind("failed").length, 0); + // The filter skipped "bad math": "good math" is the only executed case. + assert.ok(sink.output.includes("ok 1 - good math")); + assert.ok(!sink.output.includes("bad math")); + }); + + test("several leaves of one file run as sequential filtered invocations", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, failUri); + const bad = file.children.get(leafTestId(failUri.toString(), "bad math")); + const good = file.children.get(leafTestId(failUri.toString(), "good math")); + assert.ok(bad && good); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([bad, good]), + sink, + token(), + () => compiler, + ); + assert.deepStrictEqual(sink.ofKind("failed").map((e) => e.id), [bad.id]); + assert.deepStrictEqual(sink.ofKind("passed").map((e) => e.id), [good.id]); + const kinds = sink.events.map((e) => `${e.kind}:${e.id ?? ""}`); + assert.ok(kinds.indexOf(`failed:${bad.id}`) < kinds.indexOf(`enqueued:${good.id}`)); + }); + + test("a compile error marks the file item errored with stderr", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await refreshTestFile(controller, brokenUri, compiler); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([file]), + sink, + token(), + () => compiler, + ); + const errors = sink.ofKind("errored"); + assert.deepStrictEqual(errors.map((e) => e.id), [file.id]); + assert.match(String(errors[0].message), /syntax error/); + assert.strictEqual(sink.ofKind("passed").length, 0); + }); + + test("a requested leaf absent from the output is skipped", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, passUri); + const ghost = controller.createTestItem( + leafTestId(passUri.toString(), "ghost test"), + "ghost test", + passUri, + ); + file.children.add(ghost); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([ghost]), + sink, + token(), + () => compiler, + ); + assert.deepStrictEqual(sink.ofKind("skipped").map((e) => e.id), [ghost.id]); + }); + + test("a request without include runs every root", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + await discoveredFile(controller, passUri); + const sink = new RecordingSink(); + const request = new vscode.TestRunRequest(); + assert.strictEqual(requestedItems(controller, request).length, 1); + await executeRunRequest(controller, request, sink, token(), () => compiler); + assert.strictEqual(sink.ofKind("passed").length, 2); + }); + + test("a whole-file run resolves children on demand", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const bare = controller.createTestItem( + fileTestId(passUri.toString()), + "pass.test.osp", + passUri, + ); + controller.items.add(bare); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([bare]), + sink, + token(), + () => compiler, + ); + assert.strictEqual(bare.children.size, 2); + assert.strictEqual(sink.ofKind("passed").length, 2); + }); + + test("excluded leaves never execute during a whole-file run", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, failUri); + const bad = file.children.get(leafTestId(failUri.toString(), "bad math")); + assert.ok(bad); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([file], [bad]), + sink, + token(), + () => compiler, + ); + assert.strictEqual(sink.ofKind("failed").length, 0); + assert.deepStrictEqual( + sink.ofKind("passed").map((e) => e.id), + [leafTestId(failUri.toString(), "good math")], + ); + // The excluded case must not run at all — the run degrades to filtered + // per-leaf invocations, so its TAP line never appears in the output. + assert.ok(!sink.output.includes("bad math")); + assert.strictEqual(sink.ofKind("started").length, 1); + }); + + test("a stray assertion failure outside any test marks the file failed", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, strayUri); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([file]), + sink, + token(), + () => compiler, + ); + // The one real case passed, but the run must not look green: the file + // item fails with the stray diagnostic. + assert.deepStrictEqual( + sink.ofKind("passed").map((e) => e.id), + [leafTestId(strayUri.toString(), "fine")], + ); + const failures = sink.ofKind("failed"); + assert.deepStrictEqual(failures.map((e) => e.id), [file.id]); + assert.match(String(failures[0].message), /expect failed: expected 5, got 2/); + assert.strictEqual(sink.ofKind("errored").length, 0); + }); + + test("an unfiltered run scrubs an inherited OSPREY_TEST_FILTER", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, passUri); + const sink = new RecordingSink(); + process.env.OSPREY_TEST_FILTER = "zero identity"; + try { + await executeRunRequest( + controller, + new vscode.TestRunRequest([file]), + sink, + token(), + () => compiler, + ); + } finally { + delete process.env.OSPREY_TEST_FILTER; + } + // Both cases ran despite the stray filter in the editor's environment. + assert.strictEqual(sink.ofKind("passed").length, 2); + assert.strictEqual(sink.ofKind("skipped").length, 0); + }); + + test("a pre-cancelled token produces no results", async function () { + if (!compiler) { + this.skip(); + } + const controller = newController(); + const file = await discoveredFile(controller, passUri); + const source = new vscode.CancellationTokenSource(); + source.cancel(); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([file]), + sink, + source.token, + () => compiler, + ); + assert.deepStrictEqual(sink.events, [{ kind: "end" }]); + }); + + test("cancellation mid-run kills the compiler and reports nothing", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, passUri); + const source = new vscode.CancellationTokenSource(); + const sink = new RecordingSink(); + const running = executeRunRequest( + controller, + new vscode.TestRunRequest([file]), + sink, + source.token, + () => compiler, + ); + setTimeout(() => source.cancel(), 50); + await running; + const resultKinds = ["passed", "failed", "errored", "skipped"]; + assert.ok(sink.events.every((event) => !resultKinds.includes(event.kind))); + assert.deepStrictEqual(sink.events[sink.events.length - 1], { kind: "end" }); + }); + + test("an item without a uri is ignored gracefully", async () => { + const controller = newController(); + const bare = controller.createTestItem("no-uri", "no uri"); + controller.items.add(bare); + const sink = new RecordingSink(); + await executeRunRequest( + controller, + new vscode.TestRunRequest([bare]), + sink, + token(), + () => "/nonexistent/osprey-xyz", + ); + assert.deepStrictEqual(sink.events, [{ kind: "end" }]); + }); + + test("makeRunHandler drives a real TestRun end to end", async function () { + if (!compiler) { + this.skip(); + } + this.timeout(30000); + const controller = newController(); + const file = await discoveredFile(controller, passUri); + const good = file.children.get(leafTestId(passUri.toString(), "addition works")); + assert.ok(good); + const handler = makeRunHandler(controller, () => compiler); + await handler(new vscode.TestRunRequest([good]), token()); + assert.ok(true, "run handler completed against a real TestRun"); + }); + }); +}); From 3a4e746d7f42d5608ff21046aa223d1ee258ef94 Mon Sep 17 00:00:00 2001 From: Christian Findlay <16697547+MelbourneDeveloper@users.noreply.github.com> Date: Tue, 14 Jul 2026 20:23:56 +1000 Subject: [PATCH 09/17] Bank --- Makefile | 35 +- compiler/runtime/http_server_runtime.c | 55 +- compiler/runtime/http_server_send_tests.c | 102 ++++ compiler/runtime/web_runtime.c | 32 ++ crates/osprey-cli/src/wasm.rs | 180 +++++- crates/osprey-cli/tests/project_e2e.rs | 3 +- crates/osprey-codegen/src/lib.rs | 29 +- crates/osprey-syntax/src/ml/lower.rs | 39 +- docs/specs/0014-HTTP.md | 3 + docs/specs/0022-WebAssemblyTarget.md | 63 ++- examples/projects/modules/README.md | 237 ++++---- examples/projects/modules/client/osprey.toml | 8 + .../modules/client/src/account_view.ospml | 45 ++ .../modules/client/src/activity_view.ospml | 102 ++++ .../projects/modules/client/src/app.ospml | 33 ++ .../projects/modules/client/src/bridge.ospml | 12 + .../modules/client/src/commands.ospml | 22 + .../projects/modules/client/src/data.ospml | 103 ++++ .../projects/modules/client/src/layout.ospml | 87 +++ .../projects/modules/client/src/main.ospml | 10 + .../projects/modules/client/src/model.ospml | 89 +++ .../modules/client/src/pages/accounts.ospml | 40 ++ .../modules/client/src/pages/activity.ospml | 30 + .../modules/client/src/pages/move.ospml | 61 ++ .../modules/client/src/pages/overview.ospml | 34 ++ .../modules/client/src/pages/security.ospml | 19 + examples/projects/modules/client/src/ui.ospml | 49 ++ .../projects/modules/client/src/update.ospml | 237 ++++++++ .../projects/modules/e2e/playwright.config.js | 2 +- .../projects/modules/e2e/tests/bank.spec.js | 394 +++++++++---- examples/projects/modules/expectedoutput | 6 +- .../projects/modules/src/api/routes.ospml | 69 ++- .../modules/src/domain/accounts.ospml | 2 +- .../projects/modules/src/domain/json.ospml | 27 +- examples/projects/modules/src/main.ospml | 36 +- .../projects/modules/src/store/ledger.ospml | 35 +- .../projects/modules/src/web/bundle.ospml | 10 + examples/projects/modules/src/web/pages.ospml | 120 +--- examples/projects/modules/web/.gitignore | 3 + examples/projects/modules/web/README.md | 50 ++ .../projects/modules/web/package-lock.json | 533 ++++++++++++++++++ examples/projects/modules/web/package.json | 23 + .../projects/modules/web/scripts/build.mjs | 139 +++++ .../projects/modules/web/scripts/embed.mjs | 91 +++ examples/projects/modules/web/src/host.js | 304 ++++++++++ examples/projects/modules/web/src/index.jsx | 8 + examples/projects/modules/web/src/protocol.js | 242 ++++++++ examples/projects/modules/web/src/styles.css | 8 + .../modules/web/src/styles/components.css | 451 +++++++++++++++ .../projects/modules/web/src/styles/forms.css | 467 +++++++++++++++ .../modules/web/src/styles/foundation.css | 203 +++++++ .../modules/web/src/styles/layout.css | 279 +++++++++ .../projects/modules/web/src/styles/pages.css | 89 +++ .../modules/web/src/styles/responsive.css | 237 ++++++++ examples/projects/modules/web/src/wasi.js | 102 ++++ .../projects/modules/web/test/embed.test.mjs | 33 ++ .../modules/web/test/protocol.test.mjs | 122 ++++ .../projects/modules/web/test/wasi.test.mjs | 25 + 58 files changed, 5444 insertions(+), 425 deletions(-) create mode 100644 compiler/runtime/http_server_send_tests.c create mode 100644 compiler/runtime/web_runtime.c create mode 100644 examples/projects/modules/client/osprey.toml create mode 100644 examples/projects/modules/client/src/account_view.ospml create mode 100644 examples/projects/modules/client/src/activity_view.ospml create mode 100644 examples/projects/modules/client/src/app.ospml create mode 100644 examples/projects/modules/client/src/bridge.ospml create mode 100644 examples/projects/modules/client/src/commands.ospml create mode 100644 examples/projects/modules/client/src/data.ospml create mode 100644 examples/projects/modules/client/src/layout.ospml create mode 100644 examples/projects/modules/client/src/main.ospml create mode 100644 examples/projects/modules/client/src/model.ospml create mode 100644 examples/projects/modules/client/src/pages/accounts.ospml create mode 100644 examples/projects/modules/client/src/pages/activity.ospml create mode 100644 examples/projects/modules/client/src/pages/move.ospml create mode 100644 examples/projects/modules/client/src/pages/overview.ospml create mode 100644 examples/projects/modules/client/src/pages/security.ospml create mode 100644 examples/projects/modules/client/src/ui.ospml create mode 100644 examples/projects/modules/client/src/update.ospml create mode 100644 examples/projects/modules/src/web/bundle.ospml create mode 100644 examples/projects/modules/web/.gitignore create mode 100644 examples/projects/modules/web/README.md create mode 100644 examples/projects/modules/web/package-lock.json create mode 100644 examples/projects/modules/web/package.json create mode 100644 examples/projects/modules/web/scripts/build.mjs create mode 100644 examples/projects/modules/web/scripts/embed.mjs create mode 100644 examples/projects/modules/web/src/host.js create mode 100644 examples/projects/modules/web/src/index.jsx create mode 100644 examples/projects/modules/web/src/protocol.js create mode 100644 examples/projects/modules/web/src/styles.css create mode 100644 examples/projects/modules/web/src/styles/components.css create mode 100644 examples/projects/modules/web/src/styles/forms.css create mode 100644 examples/projects/modules/web/src/styles/foundation.css create mode 100644 examples/projects/modules/web/src/styles/layout.css create mode 100644 examples/projects/modules/web/src/styles/pages.css create mode 100644 examples/projects/modules/web/src/styles/responsive.css create mode 100644 examples/projects/modules/web/src/wasi.js create mode 100644 examples/projects/modules/web/test/embed.test.mjs create mode 100644 examples/projects/modules/web/test/protocol.test.mjs create mode 100644 examples/projects/modules/web/test/wasi.test.mjs diff --git a/Makefile b/Makefile index 1ed0df3a..06a3390a 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ # --run`) and TypeScript sub-projects (vscode-extension, webcompiler, website). # ============================================================================= -.PHONY: build test lint fmt clean ci setup run install bench wasm wasm-site wasm-serve vsix-rebuild-reinstall bank bank-e2e +.PHONY: build test lint fmt clean ci setup run install bench wasm wasm-site wasm-serve vsix-rebuild-reinstall bank bank-web bank-e2e # --------------------------------------------------------------------------- # OS Detection @@ -89,9 +89,10 @@ WASI_SYSROOT ?= $(shell for d in "$$OSPREY_WASI_SYSROOT" \ /usr/share/wasi-sysroot; do [ -n "$$d" ] && [ -d "$$d" ] && { echo "$$d"; break; }; done) WASM_CFLAGS ?= --target=$(WASM_TARGET) --sysroot=$(WASI_SYSROOT) -O2 -std=c11 -Wall -Wextra -Werror -c # Portable subset that compiles for wasm32: allocator + strings + value -# containers + JSON + effects. Excludes fiber (pthreads), http/websocket -# (sockets/OpenSSL), system (fork/wait), term (termios) and ffi (dlopen). -WASM_RT_SRC ?= memory_runtime string_runtime string_runtime_list list_runtime map_runtime map_runtime_hamt json_runtime effects_runtime test_runtime +# containers + JSON + effects + the browser host bridge. Excludes fiber +# (pthreads), http/websocket (sockets/OpenSSL), system (fork/wait), term +# (termios) and ffi (dlopen). +WASM_RT_SRC ?= memory_runtime string_runtime string_runtime_list list_runtime map_runtime map_runtime_hamt json_runtime effects_runtime test_runtime web_runtime # `make wasm-serve` static-host dir + port for the in-browser example. WASM_SERVE_DIR ?= examples/wasm WASM_SERVE_PORT ?= 8080 @@ -128,6 +129,13 @@ bank: build (sleep 2 && (command -v open >/dev/null && open http://127.0.0.1:18790 || true)) & \ ./$(BIN) examples/projects/modules --run +## bank-web: Regenerate the embedded React host + Osprey WebAssembly client. +## Requires Node and a WASI sysroot; the generated Osprey Bundle is +## committed so ordinary native/CI builds do not need either tool. +bank-web: build _runtime_wasm + @echo "==> Building Talon Bank browser application..." + cd examples/projects/modules/web && npm ci && npm run build + ## bank-e2e: Browser end-to-end tests for the Talon Bank modules showcase ## (examples/projects/modules) — real Chromium via Playwright drives ## the compiled osprey binary serving its HTTP API and web UI. @@ -202,7 +210,7 @@ wasm: build _runtime_wasm echo "$$out" | grep -Eq '(^| )NOEXP=0 ' || { echo 'FAIL: example missing .expectedoutput'; exit 1; } @echo "==> wasm ready: built + validated + WASI/browser smoke + golden suite green" -wasm wasm-site _runtime_wasm: export PATH := $(WASM_PATH_PREFIX)$(PATH) +wasm wasm-site _runtime_wasm bank-web: export PATH := $(WASM_PATH_PREFIX)$(PATH) ## wasm-site: Build only the WebAssembly artifacts published by the website. ## Used by GitHub Pages before `npm run build`; does not rely on checked-in @@ -338,16 +346,21 @@ _coverage_check_rust: echo "[rust] OK: all crates meet their thresholds" # Hardened C runtime unit tests (assertion-driven; a failed assert aborts the -# binary). Covers the string cursor (BUILTIN-STRING-CURSOR) + the error-message -# contract ([ERR-PAYLOAD]) exhaustively, under the same hardening flags the -# archives use. Built as an executable (no `-c`), so it links the runtime TUs -# directly. Runs on the `make test` (ubuntu) job; Windows CI uses its own steps. +# binary). Covers the string cursor (BUILTIN-STRING-CURSOR), error-message +# contract ([ERR-PAYLOAD]), and full HTTP response writes, under the same +# hardening flags the archives use. Built as executables (no `-c`), so they link +# the runtime TUs directly. Runs on `make test`; Windows CI uses its own steps. _test_c_runtime: - @echo "==> [c-runtime] string cursor + error-message contract tests..." + @echo "==> [c-runtime] string/error contract + HTTP write tests..." @cd compiler && $(CC) -O2 -D_FORTIFY_SOURCE=2 -fstack-protector-strong -Werror -Wall -Wextra \ -ftrapv -std=c11 -D_GNU_SOURCE \ runtime/string_runtime_tests.c runtime/string_runtime.c runtime/string_runtime_list.c \ - -o bin/string_runtime_tests && ./bin/string_runtime_tests + -o bin/string_runtime_tests && ./bin/string_runtime_tests && \ + $(CC) -O2 -D_FORTIFY_SOURCE=2 -fstack-protector-strong -Werror -Wall -Wextra \ + -ftrapv -std=c11 -D_GNU_SOURCE $(OSSL) \ + `pkg-config --cflags openssl 2>/dev/null || echo ""` \ + runtime/http_server_send_tests.c -pthread \ + -o bin/http_server_send_tests && ./bin/http_server_send_tests # Differential golden harness: every examples/tested/*.osp run through # `osprey --run` must match its .expectedoutput byte-for-byte, and the diff --git a/compiler/runtime/http_server_runtime.c b/compiler/runtime/http_server_runtime.c index 653b80f2..b7a13459 100644 --- a/compiler/runtime/http_server_runtime.c +++ b/compiler/runtime/http_server_runtime.c @@ -1,4 +1,5 @@ #include "http_shared.h" +#include // Forward declaration of fiber functions extern int64_t fiber_spawn(int64_t (*fn)(void)); @@ -16,6 +17,38 @@ static const char *simple_response_headers = "HTTP/1.1 200 OK\r\n" "Connection: close\r\n" "\r\n"; +// `send` is allowed to write fewer bytes than requested (and can be interrupted +// after writing none). HTTP Content-Length promises the whole payload, so every +// response write must drain the buffer before the connection is closed. +static bool send_was_interrupted(void) { +#ifdef _WIN32 + return WSAGetLastError() == WSAEINTR; +#else + return errno == EINTR; +#endif +} + +static int send_some(int socket_fd, const char *data, size_t length) { + int chunk = length > (size_t)INT_MAX ? INT_MAX : (int)length; + int written = send(socket_fd, data, chunk, 0); + if (written > 0) { + return written; + } + return written < 0 && send_was_interrupted() ? 0 : -1; +} + +static int send_all(int socket_fd, const char *data, size_t length) { + size_t offset = 0; + while (offset < length) { + int written = send_some(socket_fd, data + offset, length - offset); + if (written < 0) { + return -1; + } + offset += (size_t)written; + } + return 0; +} + // Server loop fiber function that actually handles requests static int64_t server_loop_fiber(void) { // Get server from runtime (thread-safe) @@ -80,7 +113,7 @@ static int64_t server_loop_fiber(void) { if (response && response->partialBody) { // Calculate actual body length instead of using hardcoded partialLength size_t actual_body_length = strlen(response->partialBody); - + // Build proper HTTP response with status and headers snprintf(http_response, sizeof(http_response), "HTTP/1.1 %" PRId64 " %s\r\n" @@ -96,20 +129,22 @@ static int64_t server_loop_fiber(void) { response->headers ? response->headers : "", actual_body_length); - // Send headers first - send(client_fd, http_response, strlen(http_response), 0); - - // Send body using actual string length, not hardcoded partialLength - send(client_fd, response->partialBody, actual_body_length, 0); + // Send headers first, then every body byte. Large generated JS/CSS + // bundles commonly exceed one socket-buffer write. + if (send_all(client_fd, http_response, strlen(http_response)) == 0) { + (void)send_all(client_fd, response->partialBody, actual_body_length); + } // Clean up allocated memory (if needed) // Note: Osprey-allocated memory should be managed by Osprey } else { // Fallback to simple response with dynamic length calculation size_t body_len = strlen(simple_response_body); - snprintf(http_response, sizeof(http_response), simple_response_headers, body_len); - send(client_fd, http_response, strlen(http_response), 0); - send(client_fd, simple_response_body, body_len, 0); + snprintf(http_response, sizeof(http_response), simple_response_headers, + body_len); + if (send_all(client_fd, http_response, strlen(http_response)) == 0) { + (void)send_all(client_fd, simple_response_body, body_len); + } } } close(client_fd); @@ -232,4 +267,4 @@ int64_t http_stop_server(int64_t server_id) { pthread_mutex_unlock(&runtime_mutex); return 0; -} \ No newline at end of file +} diff --git a/compiler/runtime/http_server_send_tests.c b/compiler/runtime/http_server_send_tests.c new file mode 100644 index 00000000..2cd60206 --- /dev/null +++ b/compiler/runtime/http_server_send_tests.c @@ -0,0 +1,102 @@ +#include "http_shared.h" + +#include + +// Include the production translation unit with only its socket send primitive +// replaced. This deterministically exercises short writes and EINTR, which a +// real loopback socket cannot guarantee on every kernel. +static ssize_t mock_send(int socket_fd, const void *data, size_t length, + int flags); +#define send mock_send +#include "http_server_runtime.c" +#undef send + +// Minimal definitions for the rest of http_server_runtime.c; these tests call +// only its static send_all helper. +HttpServer *servers[MAX_SERVERS] = {0}; +pthread_mutex_t runtime_mutex = PTHREAD_MUTEX_INITIALIZER; + +int64_t get_next_id(void) { return 1; } + +int64_t fiber_spawn(int64_t (*fn)(void)) { + (void)fn; + return -1; +} + +static ssize_t actions[8]; +static int action_errnos[8]; +static size_t action_count; +static size_t action_index; +static char captured[128]; +static size_t captured_length; + +static void reset_mock(const ssize_t *next_actions, const int *next_errnos, + size_t count) { + assert(count <= sizeof(actions) / sizeof(actions[0])); + if (count > 0) { + memcpy(actions, next_actions, count * sizeof(actions[0])); + memcpy(action_errnos, next_errnos, count * sizeof(action_errnos[0])); + } + action_count = count; + action_index = 0; + captured_length = 0; + memset(captured, 0, sizeof(captured)); +} + +static ssize_t mock_send(int socket_fd, const void *data, size_t length, + int flags) { + assert(socket_fd == 42); + assert(flags == 0); + assert(action_index < action_count); + ssize_t action = actions[action_index]; + int next_errno = action_errnos[action_index]; + action_index++; + if (action <= 0) { + errno = next_errno; + return action; + } + size_t written = (size_t)action < length ? (size_t)action : length; + assert(captured_length + written <= sizeof(captured)); + memcpy(captured + captured_length, data, written); + captured_length += written; + return (ssize_t)written; +} + +static void test_short_writes_and_eintr_are_retried(void) { + static const ssize_t next_actions[] = {3, -1, 2, 99}; + static const int next_errnos[] = {0, EINTR, 0, 0}; + reset_mock(next_actions, next_errnos, + sizeof(next_actions) / sizeof(next_actions[0])); + + assert(send_all(42, "abcdefgh", 8) == 0); + assert(action_index == 4); + assert(captured_length == 8); + assert(memcmp(captured, "abcdefgh", 8) == 0); +} + +static void test_closed_or_failed_socket_stops_the_write(void) { + static const ssize_t failed_actions[] = {-1}; + static const int failed_errnos[] = {EPIPE}; + reset_mock(failed_actions, failed_errnos, 1); + assert(send_all(42, "abc", 3) == -1); + assert(action_index == 1); + + static const ssize_t closed_actions[] = {0}; + static const int closed_errnos[] = {0}; + reset_mock(closed_actions, closed_errnos, 1); + assert(send_all(42, "abc", 3) == -1); + assert(action_index == 1); +} + +static void test_empty_buffer_needs_no_socket_call(void) { + reset_mock(NULL, NULL, 0); + assert(send_all(42, "", 0) == 0); + assert(action_index == 0); +} + +int main(void) { + test_short_writes_and_eintr_are_retried(); + test_closed_or_failed_socket_stops_the_write(); + test_empty_buffer_needs_no_socket_call(); + return 0; +} diff --git a/compiler/runtime/web_runtime.c b/compiler/runtime/web_runtime.c new file mode 100644 index 00000000..3da10b47 --- /dev/null +++ b/compiler/runtime/web_runtime.c @@ -0,0 +1,32 @@ +// Browser host bridge for Osprey's wasm target. [WASM-WEB-ABI] +// +// React (or another DOM framework) stays in JavaScript. Osprey crosses the +// wasm boundary with coarse-grained, NUL-terminated UTF-8/JSON messages rather +// than making one host call per DOM node. This unit is intentionally present +// only in WASM_RT_SRC; native builds have no `osprey_web` import module. + +#ifndef __wasm__ +#error "web_runtime.c is only supported by the WebAssembly runtime" +#endif + +#include + +__attribute__((import_module("osprey_web"), import_name("render"))) +extern void osprey_web_host_render(const char *message); + +__attribute__((import_module("osprey_web"), import_name("command"))) +extern void osprey_web_host_command(const char *message); + +// Osprey declarations: +// extern fn osprey_web_render(message: string) -> int +// extern fn osprey_web_command(message: string) -> int +// The host imports are notifications, while the Osprey-facing status is i64. +int64_t osprey_web_render(char *message) { + osprey_web_host_render(message); + return 0; +} + +int64_t osprey_web_command(char *message) { + osprey_web_host_command(message); + return 0; +} diff --git a/crates/osprey-cli/src/wasm.rs b/crates/osprey-cli/src/wasm.rs index 37c853bf..d111e6c4 100644 --- a/crates/osprey-cli/src/wasm.rs +++ b/crates/osprey-cli/src/wasm.rs @@ -16,9 +16,10 @@ //! step 3 control the exact link line and sidestep the missing builtins archive. //! The result is a command module (`_start` → `__wasm_call_ctors` → //! `__main_void`) that runs uniformly under `wasmtime`, Node's WASI and a browser -//! WASI shim. The non-portable runtime (fibers/HTTP/FFI) is out of scope: a -//! program that references those symbols fails at link with a clear undefined -//! symbol, not silently. +//! WASI shim. The non-portable runtime (fibers/socket HTTP/FFI) is out of scope: +//! a program that references those symbols fails at link with a clear undefined +//! symbol, not silently. Browser UI messaging uses the portable `osprey_web` +//! host ABI below. use crate::{find_runtime_lib, scratch_stem}; use std::path::{Path, PathBuf}; @@ -30,6 +31,12 @@ const TRIPLE: &str = "wasm32-wasip1"; const RUNTIME_LIB: &str = "libosprey_runtime_wasm.a"; /// Candidate multiarch lib subdir names inside a WASI sysroot, newest first. const LIB_SUBDIRS: [&str; 2] = ["wasm32-wasip1", "wasm32-wasi"]; +/// Source-level browser event entry point. When present it is rooted and +/// exported from the otherwise command-oriented WASI module. [WASM-WEB-ABI] +const WEB_DISPATCH: &str = "osprey_web_dispatch"; +/// A flattened project symbol ends in a length-prefixed, hex-encoded source +/// segment. This is the mangled terminal segment for [`WEB_DISPATCH`]. +const WEB_DISPATCH_MANGLED_SUFFIX: &str = "_19x6f73707265795f7765625f6469737061746368"; /// Lower `program` to the `.wasm` at `out`. [WASM-TARGET] /// @@ -38,8 +45,9 @@ const LIB_SUBDIRS: [&str; 2] = ["wasm32-wasip1", "wasm32-wasi"]; /// Returns the CLI failure code if codegen fails, the toolchain (sysroot / /// runtime archive / `wasm-ld`) is missing, or clang/`wasm-ld` exits non-zero. pub(crate) fn build(path: &str, program: &osprey_ast::Program, out: &Path) -> Result<(), ExitCode> { + let web_dispatch = web_dispatch_export(program); let ir = match osprey_codegen::compile_program(program) { - Ok(ir) => with_entry_thunk(&ir), + Ok(ir) => with_web_dispatch_thunk(&with_entry_thunk(&ir), web_dispatch), Err(e) => return Err(fail(&format!("{path}: {e}"))), }; let sysroot = wasi_sysroot().map_err(|e| fail(&e))?; @@ -50,7 +58,7 @@ pub(crate) fn build(path: &str, program: &osprey_ast::Program, out: &Path) -> Re )) })?; let obj = compile_object(&scratch_stem(path), &ir)?; - link(&obj, &archive, &libdir, out) + link(&obj, &archive, &libdir, out, web_dispatch) } /// `--run` for wasm: build to a temp `.wasm`, then execute it under a WASI host. @@ -82,10 +90,16 @@ fn compile_object(stem: &str, ir: &str) -> Result { } /// Link the wasm object + runtime archive + libc into a command module. -fn link(obj: &Path, archive: &str, libdir: &Path, out: &Path) -> Result<(), ExitCode> { +fn link( + obj: &Path, + archive: &str, + libdir: &Path, + out: &Path, + web_dispatch: Option<&str>, +) -> Result<(), ExitCode> { run_tool( &tool("OSPREY_WASM_LD", "wasm-ld"), - &link_argv(obj, archive, libdir, out), + &link_argv(obj, archive, libdir, out, web_dispatch), ) } @@ -105,18 +119,67 @@ fn clang_argv(ll: &Path, obj: &Path) -> Vec { /// `wasm-ld` argv: the sysroot's `crt1-command.o` `_start`, the program object, /// the runtime archive (on-demand), and libc from the sysroot lib dir. -fn link_argv(obj: &Path, archive: &str, libdir: &Path, out: &Path) -> Vec { +/// Exporting `osp_alloc` also roots its on-demand archive member so browser +/// hosts can copy UTF-8 request JSON into wasm memory. [WASM-WEB-ABI] +fn link_argv( + obj: &Path, + archive: &str, + libdir: &Path, + out: &Path, + web_dispatch: Option<&str>, +) -> Vec { + let mut argv = base_link_argv(obj, archive, libdir, out); + argv.extend( + web_dispatch + .is_some() + .then(|| format!("--export={WEB_DISPATCH}")), + ); + argv +} + +fn base_link_argv(obj: &Path, archive: &str, libdir: &Path, out: &Path) -> Vec { vec![ libdir.join("crt1-command.o").display().to_string(), obj.display().to_string(), archive.to_string(), format!("-L{}", libdir.display()), "-lc".to_string(), + "--export=osp_alloc".to_string(), "-o".to_string(), out.display().to_string(), ] } +/// Return the actual LLVM/linkage name of the browser dispatcher, if the +/// flattened AST defines it. Single-file programs retain the source spelling; +/// project assembly uses `__osp_x...` and preserves the source name +/// in the terminal segment. [WASM-WEB-ABI] +fn web_dispatch_export(program: &osprey_ast::Program) -> Option<&str> { + program.statements.iter().find_map(|statement| { + let osprey_ast::Stmt::Function { name, .. } = statement else { + return None; + }; + (name == WEB_DISPATCH || is_mangled_web_dispatch(name)).then_some(name.as_str()) + }) +} + +fn is_mangled_web_dispatch(name: &str) -> bool { + name.starts_with("__osp_") && name.ends_with(WEB_DISPATCH_MANGLED_SUFFIX) +} + +/// Add a stable browser ABI symbol in front of a project-mangled dispatcher. +/// The Osprey convention is `fn osprey_web_dispatch(message: string) -> int`; +/// strings are `i8*` and `int` is `i64` in the LLVM ABI. A single-file source +/// already emits the stable name and needs no duplicate definition. +fn with_web_dispatch_thunk(ir: &str, actual: Option<&str>) -> String { + match actual { + Some(symbol) if symbol != WEB_DISPATCH => format!( + "{ir}\ndefine i64 @{WEB_DISPATCH}(i8* %message) {{\n %r = call i64 @{symbol}(i8* %message)\n ret i64 %r\n}}\n" + ), + _ => ir.to_string(), + } +} + /// Locate a WASI sysroot: `OSPREY_WASI_SYSROOT` if set, else the first existing /// of the conventional Homebrew / wasi-sdk / Linux locations. fn wasi_sysroot() -> Result { @@ -223,6 +286,14 @@ mod tests { /// (`OSPREY_WASM_*`, `*_SYSROOT`) so they neither race each other nor the /// end-to-end build below — env is shared across the parallel test threads. static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(()); + const WEB_ABI_SOURCE: &str = "namespace app;\n\ + extern fn osprey_web_render(message: string) -> int\n\ + extern fn osprey_web_command(message: string) -> int\n\ + fn osprey_web_dispatch(message: string) -> int = 0\n\ + fn main() = {\n\ + let rendered = osprey_web_render(\"boot\")\n\ + osprey_web_command(\"ready\")\n\ + }\n"; fn lock_env() -> std::sync::MutexGuard<'static, ()> { ENV_LOCK @@ -230,6 +301,20 @@ mod tests { .unwrap_or_else(std::sync::PoisonError::into_inner) } + fn assemble_web_program(source: &str, root: &str) -> osprey_ast::Program { + osprey_project::assemble( + &osprey_project::ProjectConfig::for_root(Path::new(root)), + &[osprey_project::SourceFile { + path: PathBuf::from("client.osp"), + flavor: osprey_syntax::Flavor::Default, + source: source.to_string(), + program: osprey_syntax::parse_program(source).program, + }], + ) + .expect("assemble web project") + .program + } + #[test] fn entry_thunk_wraps_main_for_the_wasi_start_path() { let out = with_entry_thunk("define i32 @main() {\n ret i32 0\n}\n"); @@ -238,6 +323,18 @@ mod tests { assert!(out.contains("call i32 @main()"), "thunk calls main"); } + #[test] + fn web_dispatch_thunk_stabilizes_a_project_mangled_symbol() { + let mangled = format!("__osp_3x617070{WEB_DISPATCH_MANGLED_SUFFIX}"); + let out = with_web_dispatch_thunk("; module", Some(&mangled)); + assert!(out.contains("define i64 @osprey_web_dispatch(i8* %message)")); + assert!(out.contains(&format!("call i64 @{mangled}(i8* %message)"))); + assert!(out.contains("ret i64 %r")); + + let unchanged = with_web_dispatch_thunk("; module", Some(WEB_DISPATCH)); + assert_eq!(unchanged, "; module", "source spelling needs no thunk"); + } + #[test] fn clang_argv_targets_wasm_and_compiles_only() { let argv = clang_argv(Path::new("/tmp/p.ll"), Path::new("/tmp/p.o")); @@ -256,15 +353,51 @@ mod tests { "/lib/libosprey_runtime_wasm.a", Path::new("/sys/lib/wasm32-wasip1"), Path::new("/out/p.wasm"), + None, ); assert!(argv.iter().any(|a| a.ends_with("crt1-command.o"))); assert!(argv.iter().any(|a| a == "/lib/libosprey_runtime_wasm.a")); assert!(argv.iter().any(|a| a == "-L/sys/lib/wasm32-wasip1")); assert!(argv.iter().any(|a| a == "-lc")); + assert!(argv.iter().any(|a| a == "--export=osp_alloc")); + assert!(!argv.iter().any(|a| a.contains(WEB_DISPATCH))); let oi = argv.iter().position(|a| a == "-o").expect("has -o"); assert_eq!(argv.get(oi + 1).map(String::as_str), Some("/out/p.wasm")); } + #[test] + fn link_argv_exports_the_discovered_web_dispatch_symbol() { + let mangled = format!("__osp_3x617070{WEB_DISPATCH_MANGLED_SUFFIX}"); + let argv = link_argv( + Path::new("/tmp/p.o"), + "/lib/libosprey_runtime_wasm.a", + Path::new("/sys/lib/wasm32-wasip1"), + Path::new("/out/p.wasm"), + Some(&mangled), + ); + assert!(argv.iter().any(|a| a == "--export=osprey_web_dispatch")); + assert!(!argv.iter().any(|a| a == &format!("--export={mangled}"))); + } + + #[test] + fn finds_source_and_project_mangled_web_dispatch_functions() { + let source = + osprey_syntax::parse_program("fn osprey_web_dispatch(message: string) -> int = 0\n") + .program; + assert_eq!(web_dispatch_export(&source), Some(WEB_DISPATCH)); + + let project_source = "namespace app;\nfn osprey_web_dispatch(message: string) -> int = 0\n"; + let project = assemble_web_program(project_source, "/tmp/web-dispatch-project"); + let mangled = web_dispatch_export(&project).expect("find flattened dispatcher"); + assert_ne!(mangled, WEB_DISPATCH); + assert!(mangled.starts_with("__osp_")); + assert!(mangled.ends_with(WEB_DISPATCH_MANGLED_SUFFIX)); + + let ordinary = + osprey_syntax::parse_program("fn dispatch(message: string) = message\n").program; + assert_eq!(web_dispatch_export(&ordinary), None); + } + #[test] fn tool_falls_back_to_default_when_env_unset() { assert_eq!( @@ -349,6 +482,7 @@ mod tests { "/tmp/rt.a", Path::new("/tmp/libdir"), Path::new("/tmp/out.wasm"), + None, ); // A stand-in that exits non-zero → link reports a CLI failure. std::env::set_var("OSPREY_WASM_LD", "false"); @@ -357,6 +491,7 @@ mod tests { "/tmp/rt.a", Path::new("/tmp/libdir"), Path::new("/tmp/out.wasm"), + None, ); match prev { Some(v) => std::env::set_var("OSPREY_WASM_LD", v), @@ -489,5 +624,34 @@ mod tests { build("e2e.osp", &program, &out).expect("wasm build"); let bytes = std::fs::read(&out).expect("read wasm"); assert!(bytes.starts_with(b"\0asm"), "wasm magic header"); + build_web_abi_fixture(); + } + + fn build_web_abi_fixture() { + let web = assemble_web_program(WEB_ABI_SOURCE, "/tmp/web-abi-e2e"); + let actual = web_dispatch_export(&web).expect("flattened web dispatcher"); + assert_ne!(actual, WEB_DISPATCH); + let web_out = + std::env::temp_dir().join(format!("osprey_wasm_web_e2e_{}.wasm", std::process::id())); + build("web-e2e.osp", &web, &web_out).expect("web ABI wasm build"); + let web_bytes = std::fs::read(&web_out).expect("read web wasm"); + assert_web_abi_names(&web_bytes); + } + + fn assert_web_abi_names(web_bytes: &[u8]) { + for expected in [ + "osprey_web_dispatch", + "osp_alloc", + "osprey_web", + "render", + "command", + ] { + assert!( + web_bytes + .windows(expected.len()) + .any(|window| window == expected.as_bytes()), + "web module contains import/export name {expected}" + ); + } } } diff --git a/crates/osprey-cli/tests/project_e2e.rs b/crates/osprey-cli/tests/project_e2e.rs index d5281022..0f43fbdf 100644 --- a/crates/osprey-cli/tests/project_e2e.rs +++ b/crates/osprey-cli/tests/project_e2e.rs @@ -50,7 +50,7 @@ fn arg(path: &Path) -> String { path.to_string_lossy().into_owned() } -const FIXTURE_SOURCES: [&str; 10] = [ +const FIXTURE_SOURCES: [&str; 11] = [ "osprey.toml", "src/main.ospml", "src/lib/sqlite.ospml", @@ -60,6 +60,7 @@ const FIXTURE_SOURCES: [&str; 10] = [ "src/store/ledger.ospml", "src/store/metrics.ospml", "src/api/routes.ospml", + "src/web/bundle.ospml", "src/web/pages.ospml", ]; diff --git a/crates/osprey-codegen/src/lib.rs b/crates/osprey-codegen/src/lib.rs index 18666d8f..124a7868 100644 --- a/crates/osprey-codegen/src/lib.rs +++ b/crates/osprey-codegen/src/lib.rs @@ -81,7 +81,7 @@ fn stmt_idents(s: &osprey_ast::Stmt, out: &mut std::collections::BTreeSet String { let parsed = parse_program(src); @@ -93,6 +93,16 @@ mod tests { compile_program(&parsed.program).expect("codegen should succeed") } + fn ml_module(src: &str) -> String { + let parsed = parse_program_with_flavor(src, Flavor::Ml); + assert!( + parsed.errors.is_empty(), + "syntax errors: {:?}", + parsed.errors + ); + compile_program(&parsed.program).expect("ML codegen should succeed") + } + fn debug_module(src: &str) -> String { let parsed = parse_program(src); assert!( @@ -775,6 +785,23 @@ mod tests { assert!(ir.contains("store i64")); } + #[test] + fn ml_curried_string_result_compares_with_string_parameter() { + let ir = ml_module( + r#"value : int -> string -> string -> string +value doc path fallback = fallback + +card : int -> int -> string -> string +card doc index selected = + id = value doc "[${index}].id" "0" + match id == selected + true => " selected" + false => "" +"#, + ); + assert!(ir.contains("call i32 @strcmp(i8*")); + } + // ---- fibers (fiber.rs) ---- #[test] diff --git a/crates/osprey-syntax/src/ml/lower.rs b/crates/osprey-syntax/src/ml/lower.rs index 583d33b0..a3b5d1be 100644 --- a/crates/osprey-syntax/src/ml/lower.rs +++ b/crates/osprey-syntax/src/ml/lower.rs @@ -795,27 +795,40 @@ fn build_function( fn curry_params(params: Vec, body: Expr, spine: &[MlType], pos: Position) -> Expr { let mut acc = body; for (i, param) in params.into_iter().enumerate().rev() { - let parameters = match param { - MlParam::Named(name) => vec![Parameter { - name, - ty: spine.get(i).and_then(type_expr), - }], - MlParam::Typed(name, ty) => vec![Parameter { - name, - ty: type_expr(&ty), - }], - MlParam::Unit => Vec::new(), - }; acc = Expr::Lambda { - parameters, + parameters: curry_parameter(param, spine.get(i)), return_type: arrow_of(spine.get(i + 1..).unwrap_or(&[])), body: Box::new(acc), - position: Some(pos), + position: Some(curry_position(pos, i)), }; } acc } +fn curry_parameter(param: MlParam, inferred: Option<&MlType>) -> Vec { + match param { + MlParam::Named(name) => vec![Parameter { + name, + ty: inferred.and_then(type_expr), + }], + MlParam::Typed(name, ty) => vec![Parameter { + name, + ty: type_expr(&ty), + }], + MlParam::Unit => Vec::new(), + } +} + +/// Give every synthesized curry lambda its own `ProgramTypes::lambdas` key; +/// sharing the binding position lets an outer parameter ABI replace an inner. +fn curry_position(pos: Position, index: usize) -> Position { + let offset = u32::try_from(index).unwrap_or(u32::MAX); + Position { + line: pos.line, + column: pos.column.saturating_add(offset).saturating_add(1), + } +} + /// Lower a lambda head over an already-lowered `body`. A unit-only or empty head /// `\() => body` / `\=> body` is a single zero-parameter lambda (nothing to /// curry); otherwise the parameters curry into nested one-parameter lambdas diff --git a/docs/specs/0014-HTTP.md b/docs/specs/0014-HTTP.md index e64f2cd4..93451b5e 100644 --- a/docs/specs/0014-HTTP.md +++ b/docs/specs/0014-HTTP.md @@ -48,6 +48,9 @@ httpStopServer(serverID: ServerID) -> Result ``` The C runtime parses incoming requests and calls `handler` per request. All routing and application logic lives in Osprey; the C side provides only the transport. +It computes `Content-Length` from `partialBody` and drains both the header and +body buffers with retry-on-interrupt writes, so a short socket write cannot +truncate large generated JavaScript or CSS responses. ```osprey fn handleRequest(method, path, headers, body) = diff --git a/docs/specs/0022-WebAssemblyTarget.md b/docs/specs/0022-WebAssemblyTarget.md index dce779a6..2abf8fc5 100644 --- a/docs/specs/0022-WebAssemblyTarget.md +++ b/docs/specs/0022-WebAssemblyTarget.md @@ -96,12 +96,60 @@ which the portable core doesn't need (wasm has native `i64`). Sysroot and tool locations are discovered from `OSPREY_WASI_SYSROOT` / `OSPREY_WASM_LD` or the conventional Homebrew / wasi-sdk / Linux paths. +### Browser application ABI [WASM-WEB-ABI] + +The wasm runtime provides a deliberately small message bridge so Osprey can own +application state and behaviour while React (or another JavaScript UI library) +owns the DOM. An Osprey web program declares the two host notifications as +ordinary externs; no JavaScript or React detail leaks into the language surface: + +```osprey +extern fn osprey_web_render(message: string) -> int +extern fn osprey_web_command(message: string) -> int +``` + +`compiler/runtime/web_runtime.c` implements those functions and imports +`render(pointer)` and `command(pointer)` from the WebAssembly import module +`osprey_web`. Each message is a NUL-terminated UTF-8 string, conventionally +JSON. The JavaScript import must decode the message synchronously; the wrapper +then returns status `0` to Osprey. Because `web_runtime.o` is pulled from the +runtime archive only on demand, command-line wasm programs that do not call the +bridge acquire no `osprey_web` imports. + +Browser events travel in the other direction through one optional convention: + +```osprey +fn osprey_web_dispatch(message: string) -> int = { + // decode the event, update Osprey state, then render + 0 +} +``` + +The wasm linker always exports `osp_alloc`. When this function is present it +also exports a stable `osprey_web_dispatch`. Project assembly normally mangles +module function names, so the compiler scans the flattened AST for either the +source spelling or its mangled terminal segment and emits an `i8* -> i64` +forwarding thunk under the stable name. The browser therefore never needs to +know Osprey's project mangling. To dispatch an event, the host UTF-8-encodes its +JSON plus a trailing NUL, reserves that many bytes with `osp_alloc`, copies them +into exported linear memory, and calls `osprey_web_dispatch(pointer)`. At the +JavaScript API boundary `osp_alloc` is `(i64) -> i32`, so its byte-count argument +is a `BigInt`; the dispatcher's `i64` status is likewise returned as a `BigInt`. +Because allocation can grow linear memory, the host creates its `Uint8Array` +view from `memory.buffer` *after* the allocation. + +This is an event/render boundary, not a per-DOM-node FFI. A render crosses wasm +once with a view model and React reconciles it entirely in JavaScript; an event +crosses once in the opposite direction. The bridge cost therefore scales with +message size and event frequency rather than component count. + ### Runtime subset [WASM-TARGET-RUNTIME] `make _runtime_wasm` cross-compiles the portable C units — allocator, strings, -list/map containers, JSON, and the effect *handler stack* — to -`libosprey_runtime_wasm.a` (the thread-based effect *continuations* are split -out; see [WASM-TARGET-EFFECTS]). The allocator is the default `malloc` +list/map containers, JSON, the browser message bridge, and the effect *handler +stack* — to `libosprey_runtime_wasm.a` (the thread-based effect +*continuations* are split out; see [WASM-TARGET-EFFECTS]). The allocator is the +default `malloc` passthrough (`@osp_alloc`); how memory is managed on wasm — and why the tracing GC is excluded — is detailed in [WASM-TARGET-MEMORY] below. Non-portable units (fibers, HTTP/WebSocket, system, terminal, FFI, CSPRNG) are excluded; because @@ -178,11 +226,13 @@ wasm uses the default allocate-and-leak-until-exit backend. ## Limitations -- **No fibers/HTTP/WebSocket/FFI/`random`/`input`/resumable effects.** These +- **No fibers/socket HTTP/WebSocket/FFI/`random`/`input`/resumable effects.** These depend on pthreads / sockets / OpenSSL / `dlopen` / syscalls absent under `wasm32-wasip1`. A program using them fails at link, not silently. Effect *handlers* still work on wasm; only `resume`-based continuations are excluded - ([WASM-TARGET-EFFECTS]). + ([WASM-TARGET-EFFECTS]). Browser-hosted UI messaging is available through the + separate `osprey_web` ABI described above; it does not provide network + sockets inside wasm. - **WASI in the browser** needs a shim (`examples/wasm/wasi-shim.mjs`, loaded by `index.html` and exercised headlessly by `scripts/wasm-browser-smoke.mjs`), mapping `fd_write` to the page/console. A future `wasm32-unknown-unknown` mode @@ -207,3 +257,6 @@ wasm uses the default allocate-and-leak-until-exit backend. (undefined symbol) are SKIPped. Reports `PASS=47 FAIL=0 SKIP=23 NOEXP=0`. - CI `wasm` job runs the validate + Node-WASI smoke **and** the golden suite on every PR. +- `cargo test -p osprey-cli wasm::tests` — asserts dispatcher discovery, stable + thunk generation, and the exact `wasm-ld` export flags without requiring a + browser host. diff --git a/examples/projects/modules/README.md b/examples/projects/modules/README.md index 97c7d1fd..eed04d93 100644 --- a/examples/projects/modules/README.md +++ b/examples/projects/modules/README.md @@ -1,123 +1,158 @@ -# Talon Bank — the Osprey modules showcase +# Talon Bank — a full Osprey web application -A complete, layered banking application in ML-flavor Osprey. One -`osprey.toml` project, eight source files, every module-system feature doing -real work: a SQLite library over the C FFI (with a bound prepared-statement -cursor API), a double-entry journal, a storage capability as an algebraic -effect, a JSON API over the data (`/api/accounts`, `/api/activity`, deposits, -withdrawals, transfers, overdraft refusals), and a server-driven web -dashboard — stat tiles, accounts, a color-coded activity feed — that is -*provably* unable to touch the database. +Talon Bank is a polished banking operations console whose application logic is +written in Osprey. The browser client is compiled to WebAssembly and owns its +model, routing, validation, updates, view tree, and effect commands. React sits +under that surface as a generic renderer; it does not contain banking logic. -Spec: [docs/specs/0025-ModulesAndNamespaces.md](../../../docs/specs/0025-ModulesAndNamespaces.md) · -Plan: [docs/plans/0014-modules-and-namespaces.md](../../../docs/plans/0014-modules-and-namespaces.md) +The native Osprey service exposes the protected JSON API and SQLite ledger. +Its algebraic-effect boundary means neither the WebAssembly client nor the +React host can acquire database authority. -## Run it +## Run the demo + +Build the browser bundle after changing the client, host, or styles: ```sh -target/release/osprey examples/projects/modules --run +make bank-web ``` -Output is deterministic and byte-compared against `expectedoutput` by -`crates/osprey-cli/tests/project_e2e.rs`. +Then launch the complete app: + +```sh +make bank +``` -## Architecture +Open . The demo includes: + +- a portfolio overview with live balances and recent activity; +- account browsing, selection, detail, and account creation; +- deposit, withdrawal, and atomic transfer workflows; +- a searchable, filterable audit ledger, including refused movements; +- client-side routes with browser back/forward support; +- loading, validation, success, refusal, and service-failure states; +- a responsive mobile navigation experience; and +- an inspectable security view explaining the capability boundaries. + +The generated `src/web/bundle.ospml` is committed, so the native project still +builds without Node or a WASI SDK. `make bank-web` is the explicit regeneration +step. + +## Browser architecture + +```text +browser event / HTTP response + │ flat JSON + opaque model + ▼ + Osprey WebAssembly application + model · update · routing · validation · view · commands + │ one declarative JSON tree per render + ▼ + generic React renderer + browser command host + │ fetch only; no storage capability + ▼ + Osprey JSON API + │ Ledger::Store algebraic effect + ▼ + SQLite ledger +``` +The bridge is deliberately coarse. Osprey produces a complete render envelope, +and the host parses it once before React reconciles the tree. Events return as +small flat messages through the stable `osprey_web_dispatch` WebAssembly +export. `osp_alloc` provides safe host-to-Wasm string allocation. This avoids a +chatty component-level FFI and keeps React replaceable. + +The reusable pieces are split clearly: + +```text +client/src/ + model.ospml opaque serializable application model + update.ospml event, form, route, and HTTP-response transitions + ui.ospml React-neutral element-tree constructors + commands.ospml generic HTTP, focus, and navigation commands + bridge.ospml the single render boundary + pages/ complete Osprey page views + +web/src/ + host.js Wasm lifecycle and generic command interpreter + protocol.js safe element-tree-to-React adapter + wasi.js minimal browser WASI Preview 1 host + styles.css responsive Talon design system ``` + +`web/scripts/build.mjs` compiles the client for `wasm32-wasip1`, bundles React, +minifies the host and CSS, embeds the Wasm bytes, and generates the native +Osprey `Bundle` module served at `/app.js` and `/app.css`. + +## Server architecture + +```text src/ - lib/sqlite.ospml module Sqlite SQLite library: C FFI externs + typed helpers - domain/money.ospml module Money pure cents arithmetic (signature-ascribed) - domain/json.ospml module Json typed JSON encoder, escaping in one place (signature-ascribed) - domain/accounts.ospml module Accounts Account record, Outcome union, pure rules - store/ledger.ospml module Ledger effect Store (capability) + SQL implementations - store/metrics.ospml state Metrics the namespace's ONE state module (request counter) - api/routes.ospml module Api JSON routes + effect Audit; performs Store - web/pages.ospml module Pages server-driven HTML; sees ONLY bank::Api - main.ospml (entry) composition root: binds every capability + lib/sqlite.ospml bound SQLite helpers over the C FFI + domain/money.ospml exact whole-cent formatting + domain/json.ospml central JSON encoding and scalar projection + domain/accounts.ospml account records, outcomes, and pure rules + store/ledger.ospml Store effect and transactional SQL implementation + store/metrics.ospml the namespace's single state owner + api/routes.ospml validated JSON routes and Audit effect + web/pages.ospml capability-free app shell and embedded assets + web/bundle.ospml generated React host, CSS, and Osprey Wasm client + main.ospml composition root and capability handlers ``` -The dependency arrows only point down, and the module system enforces them: +- **Storage is a capability.** `Ledger::Store` is an algebraic effect. Only the + composition root binds it to SQLite, so an unhandled or illicit storage + operation is a compile error. +- **Transfers are atomic.** Debit, credit, and both journal entries commit in + one SQLite transaction. +- **Refusals are domain outcomes.** Overdraft attempts return HTTP 422 and are + still recorded in the audit ledger. +- **Money is integral.** The full path uses cents, avoiding floating-point + drift. +- **Input is bound and output is encoded.** SQL uses prepared parameters, JSON + strings are escaped centrally, and the React adapter rejects executable DOM + properties and raw HTML injection. +- **The UI has no database route.** `pages.ospml` serves static app assets and + imports no Ledger or SQLite module. Browser data crosses only `/api/*`. + +## Tests + +Run the host unit tests and regenerate the bundle: +```sh +cd examples/projects/modules/web +npm ci +npm test +npm run build ``` -web ("bank/web") ──imports──▶ api ──performs──▶ Ledger::Store ──SQL──▶ Sqlite ──▶ libsqlite3 - │ - └──performs──▶ Api::Audit (bound to console in main) + +Run the real-browser suite against the compiled Osprey server: + +```sh +make bank-e2e ``` -- **The UI never talks to the database.** `web/pages.ospml` imports only - `bank::Api`. There is no `Ledger` or `Sqlite` path in scope, so a database - call from the UI is not merely bad style — it does not resolve. -- **Storage is a capability.** `Ledger::Store` is an algebraic effect. The api - layer `perform`s it; only `main.ospml` decides what a `debit` physically is. - An unhandled operation is a compile error. Swapping SQLite for an in-memory - fake is a main-only edit. -- **Refusal is a domain outcome, not an error.** `debit` returns the - `Outcome` union (`Landed`/`Refused`); every caller pattern-matches it - exhaustively, and an overdraft surfaces as HTTP 422 with a reason. -- **Double-entry journal.** Every movement — refusals included — lands as a - bound-parameter row in `entries`; a transfer writes both sides. The activity - feed is an audit ledger, not a best-effort log. -- **JSON is built from strong types, never spliced.** No layer hand-writes - `"{\"error\":\"...\"}"`. `domain/json.ospml` owns encoding through typed - combinators (`strField`/`numField`/`obj`/`arr`), so string escaping lives in - exactly one place — an owner name like `Amelia "Mel" Chen` yields valid JSON - instead of a broken document. (SQL input is bound, never spliced, too.) -- **One state owner.** `state Metrics` owns the only mutable cell in the app. - The cell is readable and writable exclusively inside its own effect's - handler arms, and that region exists only while the exported installer - (`track`) is running. +Playwright covers the public API, WebAssembly boot, bridge telemetry, SPA +navigation, account creation, money movement, refusals, filtering, responsive +layout, and injection-safe rendering. + +The deterministic native tour remains byte-compared with `expectedoutput` by +`crates/osprey-cli/tests/project_e2e.rs`. ## Module-system features exercised | Feature | Where | |---|---| -| File-scoped `namespace` | every file (`namespace bank`) | -| Quoted namespace + alias import | `web/pages.ospml` (`namespace "bank/web"`), `import "bank/web" as web` in main | -| Cross-file namespace merging | `Account`/`Outcome` declared in domain, used in api with no import | -| `module` with `export` markers | Sqlite, Accounts, Ledger, Api, Pages | -| Signature-ascribed module (no redundant exports) | `module Money : MoneyApi`, `module Json : JsonApi` | -| Signature-ascribed **state** module | `state Metrics : MetricsApi` | -| Effect declared in a signature | `MetricsApi.MetricsFx` | -| Effect exported from a module | `Ledger::Store`, `Api::Audit` | -| Effect rows on module exports | `route : … ! [Ledger::Store, Audit]` | -| Handler installer + private cells | `Metrics::track` | -| Qualified paths in perform/handle | `perform Ledger::Store.debit`, `handle Api::Audit` | -| Member imports | `import bank::Sqlite`, etc. | -| Multi-file project manifest | `osprey.toml` (`source_roots`, `default_namespace`, `entry`) | -| `@link` directive from a non-entry file | `lib/sqlite.ospml` links `sqlite3` | - -## Browser end-to-end tests (Playwright) - -```sh -cd examples/projects/modules/e2e -npm install && npx playwright install chromium -npx playwright test -``` - -The suite boots the real compiled binary (the `/tmp/talon_bank.hold` marker -file pauses the demo just before shutdown so the server stays up), then -drives Chromium through the dashboard and the JSON API: seeded balances, -styled rendering, an overdraft refusal (422), and the server-driven proof -that an API mutation appears on the next rendered page. - -## Known compiler defects encountered (worked around here, not fixed) - -Found while building this app; each reproduces in a few lines. The module -system itself needed **zero** workarounds. - -1. **`deleteFile` is a phantom builtin** — typed in - `crates/osprey-types/src/builtins.rs` but absent from the runtime, so any - use fails at link time. Workaround: idempotent `DROP TABLE IF EXISTS`. -2. **`Result` loses its variant tag through effect `resume`** — a handler arm - returning `Error(…)` for an op typed `… => Result` matches - `Success` at the perform site with a garbage payload. User-defined unions - round-trip correctly, which is why `debit` returns the domain `Outcome` - union instead. -3. **`HttpResponse` field readback corrupts** — constructing an - `HttpResponse` and then reading a string field back (e.g. `.partialBody`) - yields garbage or a segfault. Custom records are unaffected. Workaround: - `Api::accountsJson` hands the web layer the JSON string directly. -4. **Undocumented HTTP contract** — the `headers` string of a server - `HttpResponse` is spliced verbatim into the wire response, so every header - line must be CRLF-terminated (`"Content-Type: text/html; charset=utf-8\r\n"`), - or browsers receive a mangled header block and fall back to text/plain. +| File-scoped and quoted namespaces | native modules and `bank/web` | +| Multi-root Osprey project | browser client plus shared domain modules | +| Signature-ascribed modules and state | `Money`, `Json`, `Metrics` | +| Exported algebraic effects | `Ledger::Store`, `Api::Audit` | +| Effect rows and exhaustive outcomes | API routes and ledger mutations | +| Private state behind an installer | request metrics | +| Stable WebAssembly host ABI | `osprey_web_dispatch`, `osp_alloc` | +| C FFI linking from a library module | SQLite adapter | + +The relevant language specifications are +[`0022-WebAssemblyTarget.md`](../../../docs/specs/0022-WebAssemblyTarget.md) and +[`0025-ModulesAndNamespaces.md`](../../../docs/specs/0025-ModulesAndNamespaces.md). diff --git a/examples/projects/modules/client/osprey.toml b/examples/projects/modules/client/osprey.toml new file mode 100644 index 00000000..15ee0699 --- /dev/null +++ b/examples/projects/modules/client/osprey.toml @@ -0,0 +1,8 @@ +[project] +name = "talon-bank-client" +source_roots = ["src", "../src/domain"] +default_namespace = "talon" +entry = "src/main.ospml" + +[modules] +allow_wildcard_imports = false diff --git a/examples/projects/modules/client/src/account_view.ospml b/examples/projects/modules/client/src/account_view.ospml new file mode 100644 index 00000000..34cf9a09 --- /dev/null +++ b/examples/projects/modules/client/src/account_view.ospml @@ -0,0 +1,45 @@ +namespace talon + +import talon::UI +import talon::BankData + +module AccountView + increment : int -> int + increment number = match number + 1 + Success value => value + Error message => number + + export card : int -> int -> string -> string + card doc index selected = + id = BankData::value doc "[${index}].id" "0" + owner = BankData::value doc "[${index}].owner" "Account" + balance = BankData::value doc "[${index}].balance" "$0.00" + accent = match index + 0 => "violet" + 1 => "cyan" + _ => "gold" + active = match id == selected + true => " selected" + false => "" + top = UI::node "span" (UI::prop "className" "account-card-top") (UI::leaf "span" (UI::prop "className" "account-mark ${accent}") "T" + "," + UI::leaf "span" (UI::prop "className" "account-more") "•••") + UI::node "button" (UI::prop "id" "account-${id}" + "," + UI::prop "event" "click" + "," + UI::prop "type" "button" + "," + UI::prop "className" "account-card ${accent}${active}") (top + "," + UI::leaf "span" (UI::prop "className" "account-owner") owner + "," + UI::leaf "strong" (UI::prop "className" "account-balance") balance + "," + UI::leaf "small" "" "Talon account · #${id}") + + cardsFrom : int -> int -> int -> string -> string + cardsFrom doc index limit selected = match index >= limit + true => "" + false => + owner = jsonGet doc "[${index}].owner" + match owner + Error message => "" + Success value => + rest = cardsFrom doc (increment index) limit selected + match length rest == 0 + true => card doc index selected + false => card doc index selected + "," + rest + + export cards : string -> int -> string -> string + cards source limit selected = + doc = jsonParse source + rendered = cardsFrom doc 0 limit selected + freed = jsonFree doc + rendered diff --git a/examples/projects/modules/client/src/activity_view.ospml b/examples/projects/modules/client/src/activity_view.ospml new file mode 100644 index 00000000..44798216 --- /dev/null +++ b/examples/projects/modules/client/src/activity_view.ospml @@ -0,0 +1,102 @@ +namespace talon + +import talon::UI +import talon::BankData +import bank::Money + +module ActivityView + visible : string -> string -> string -> string -> string -> bool + visible kind note owner filter search = + kindMatch = match filter + "all" => true + "in" => kind == "credit" + "out" => kind == "debit" + "refused" => kind == "refused" + _ => true + query = toLowerCase (trim search) + haystack = toLowerCase (note + " " + owner) + searchMatch = match length query == 0 + true => true + false => contains haystack query + kindMatch && searchMatch + + mark : string -> string + mark kind = match kind + "credit" => "↙" + "debit" => "↗" + _ => "!" + + label : string -> string + label kind = match kind + "credit" => "Money in" + "debit" => "Money out" + _ => "Declined" + + amount : string -> int -> string + amount kind cents = match kind + "credit" => "+${Money::show cents}" + "debit" => "−${Money::show cents}" + _ => Money::show cents + + increment : int -> int + increment number = match number + 1 + Success value => value + Error message => number + + export row : int -> int -> string + row doc index = + kind = BankData::value doc "[${index}].kind" "refused" + note = BankData::value doc "[${index}].note" "Bank movement" + owner = BankData::value doc "[${index}].owner" "Talon customer" + account = BankData::value doc "[${index}].account" "—" + cents = BankData::integer doc "[${index}].cents" + icon = UI::leaf "span" (UI::prop "className" "movement-icon ${kind}") (mark kind) + copy = UI::node "span" (UI::prop "className" "movement-copy") (UI::leaf "strong" "" note + "," + UI::leaf "small" "" "${owner} · Account #${account}") + meta = UI::node "span" (UI::prop "className" "movement-meta") (UI::leaf "strong" (UI::prop "className" "movement-amount ${kind}") (amount kind cents) + "," + UI::leaf "small" "" (label kind)) + UI::node "div" (UI::prop "className" "movement-row ${kind}") (icon + "," + copy + "," + meta) + + rowsFrom : int -> int -> int -> string -> string -> int -> string + rowsFrom doc index limit filter search shown = match shown >= limit + true => "" + false => + found = jsonGet doc "[${index}].kind" + match found + Error message => "" + Success kind => + note = BankData::value doc "[${index}].note" "" + owner = BankData::value doc "[${index}].owner" "" + show = visible kind note owner filter search + nextShown = match show + true => increment shown + false => shown + rest = rowsFrom doc (index + 1) limit filter search nextShown + match show + false => rest + true => match length rest == 0 + true => row doc index + false => row doc index + "," + rest + + export rows : string -> int -> string -> string -> string + rows source limit filter search = + doc = jsonParse source + content = rowsFrom doc 0 limit filter search 0 + freed = jsonFree doc + content + + countFrom : int -> int -> string -> int -> int + countFrom doc index kind running = + found = jsonGet doc "[${index}].kind" + match found + Error message => running + Success value => + nextCount = match value == kind + true => increment running + false => running + countFrom doc (index + 1) kind nextCount + + export count : string -> string -> int + count source kind = + doc = jsonParse source + total = countFrom doc 0 kind 0 + freed = jsonFree doc + total diff --git a/examples/projects/modules/client/src/app.ospml b/examples/projects/modules/client/src/app.ospml new file mode 100644 index 00000000..2930ba89 --- /dev/null +++ b/examples/projects/modules/client/src/app.ospml @@ -0,0 +1,33 @@ +namespace talon + +import talon::OverviewPage +import talon::AccountsPage +import talon::MovePage +import talon::ActivityPage +import talon::SecurityPage +import talon::Layout +import talon::Model +import talon::Commands +import talon::Bridge +import talon::Update + +module App + page : AppModel -> string + page model = match model.route + "overview" => OverviewPage::view model + "accounts" => AccountsPage::view model + "move" => MovePage::view model + "activity" => ActivityPage::view model + "security" => SecurityPage::view model + _ => OverviewPage::view model + + export present : AppModel -> string -> int + present model commands = Bridge::present (Model::encode model) (Layout::shell model (page model)) commands + + export start : Unit -> int + start () = present (Model::initial ()) (Commands::hydrate ()) + + export receive : string -> int + receive payload = + updated = Update::dispatch payload + present updated.model updated.commands diff --git a/examples/projects/modules/client/src/bridge.ospml b/examples/projects/modules/client/src/bridge.ospml new file mode 100644 index 00000000..e5e0aaab --- /dev/null +++ b/examples/projects/modules/client/src/bridge.ospml @@ -0,0 +1,12 @@ +// The complete React/WASM boundary: one coarse data crossing, no component FFI. +namespace talon + +import bank::Json + +extern osprey_web_render (payload : string) -> int + +module Bridge + export present : string -> string -> string -> int + present model view commands = + envelope = Json::obj (Json::strField "model" model + "," + Json::rawField "view" view + "," + Json::rawField "commands" commands) + osprey_web_render envelope diff --git a/examples/projects/modules/client/src/commands.ospml b/examples/projects/modules/client/src/commands.ospml new file mode 100644 index 00000000..5320801e --- /dev/null +++ b/examples/projects/modules/client/src/commands.ospml @@ -0,0 +1,22 @@ +namespace talon + +import bank::Json + +module Commands + http : string -> string -> string -> string -> string + http id method url body = Json::obj (Json::strField "kind" "http" + "," + Json::strField "id" id + "," + Json::strField "method" method + "," + Json::strField "url" url + "," + Json::strField "body" body) + + export none : string + none = "[]" + + export hydrate : Unit -> string + hydrate () = Json::arr (http "accounts" "GET" "/api/accounts" "" + "," + http "activity" "GET" "/api/activity" "") + + export focus : string -> string + focus id = Json::arr (Json::obj (Json::strField "kind" "focus" + "," + Json::strField "id" id)) + + export navigate : string -> string + navigate route = Json::arr (Json::obj (Json::strField "kind" "navigate" + "," + Json::strField "url" "#/${route}")) + + export post : string -> string -> string -> string + post id url body = Json::arr (http id "POST" url body) diff --git a/examples/projects/modules/client/src/data.ospml b/examples/projects/modules/client/src/data.ospml new file mode 100644 index 00000000..05ab9bd5 --- /dev/null +++ b/examples/projects/modules/client/src/data.ospml @@ -0,0 +1,103 @@ +// Read-only projections over the API JSON strings held inside the scalar model. +namespace talon + +import talon::UI + +module BankData + export value : int -> string -> string -> string + value doc path fallback = match jsonGet doc path + Success found => found + Error message => fallback + + export integer : int -> string -> int + integer doc path = match parseInt (value doc path "0") + Success found => found + Error message => 0 + + export accountCount : string -> int + accountCount source = + doc = jsonParse source + count = jsonLength doc "" + freed = jsonFree doc + count + + export activityCount : string -> int + activityCount source = accountCount source + + parsed : string -> int + parsed value = match parseInt value + Success n => n + Error message => 0 + + add : int -> int -> int + add left right = match left + right + Success value => value + Error message => 0 + + multiply : int -> int -> int + multiply left right = match left * right + Success value => value + Error message => 0 + + // Form-only decimal parsing; canonical display stays in bank::Money. + export amountCents : string -> int + amountCents source = + withoutDollar = match replace (trim source) "$" "" + Success value => value + Error message => source + dot = indexOf withoutDollar "." + match dot + Error message => multiply (parsed withoutDollar) 100 + Success at => + whole = parsed (take withoutDollar at) + tail = take (drop withoutDollar (add at 1)) 2 + fraction = match length tail + 0 => 0 + 1 => multiply (parsed tail) 10 + _ => parsed tail + add (multiply whole 100) fraction + + totalFrom : int -> int -> int -> int + totalFrom doc index running = + item = jsonGet doc "[${index}].cents" + match item + Error message => running + Success value => match parseInt value + Error bad => totalFrom doc (index + 1) running + Success cents => totalFrom doc (index + 1) (running + cents) + + export total : string -> int + total source = + doc = jsonParse source + amount = totalFrom doc 0 0 + freed = jsonFree doc + amount + + findIndex : int -> int -> int -> int + findIndex doc index wanted = + candidate = jsonGet doc "[${index}].id" + match candidate + Error message => 0 + Success raw => match parseInt raw + Success id => match id == wanted + true => index + false => findIndex doc (index + 1) wanted + Error bad => findIndex doc (index + 1) wanted + + export accountIndex : int -> string -> int + accountIndex doc selected = match parseInt selected + Success wanted => findIndex doc 0 wanted + Error message => 0 + + export accountOptions : int -> int -> string + accountOptions doc index = + owner = jsonGet doc "[${index}].owner" + match owner + Error message => "" + Success name => + id = value doc "[${index}].id" "0" + option = UI::option id "#${id} · ${name}" + rest = accountOptions doc (index + 1) + match length rest == 0 + true => option + false => option + "," + rest diff --git a/examples/projects/modules/client/src/layout.ospml b/examples/projects/modules/client/src/layout.ospml new file mode 100644 index 00000000..4f9a26ba --- /dev/null +++ b/examples/projects/modules/client/src/layout.ospml @@ -0,0 +1,87 @@ +namespace talon + +import talon::UI + +module Layout + routeTitle : string -> string + routeTitle route = match route + "overview" => "Overview" + "accounts" => "Accounts" + "move" => "Move money" + "activity" => "Activity" + _ => "Security" + + navItem : AppModel -> string -> string -> string -> string + navItem model route icon label = + active = match model.route == route + true => " active" + false => "" + current = match model.route == route + true => "," + UI::prop "aria-current" "page" + false => "" + UI::node "button" (UI::prop "id" "nav-${route}" + "," + UI::prop "event" "click" + "," + UI::prop "type" "button" + "," + UI::prop "className" "nav-item${active}" + current) (UI::leaf "span" (UI::prop "className" "nav-icon") icon + "," + UI::leaf "span" (UI::prop "className" "nav-label") label) + + sidebar : AppModel -> string + sidebar model = + mobile = match model.menu + "open" => " open" + _ => "" + brand = UI::node "div" (UI::prop "className" "brand") (UI::node "span" (UI::prop "className" "brand-mark") (UI::leaf "span" "" "T") + "," + UI::node "span" (UI::prop "className" "brand-copy") (UI::leaf "strong" "" "Talon" + "," + UI::leaf "small" "" "PRIVATE BANK")) + nav = UI::node "nav" (UI::prop "className" "main-nav" + "," + UI::prop "aria-label" "Primary navigation") (UI::leaf "span" (UI::prop "className" "nav-section-label") "BANKING" + "," + navItem model "overview" "⌂" "Overview" + "," + navItem model "accounts" "◫" "Accounts" + "," + navItem model "move" "⇄" "Move money" + "," + navItem model "activity" "◎" "Activity" + "," + UI::leaf "span" (UI::prop "className" "nav-section-label secondary") "SYSTEM" + "," + navItem model "security" "◇" "Security") + profile = UI::node "div" (UI::prop "className" "sidebar-profile") (UI::leaf "span" (UI::prop "className" "avatar") "TO" + "," + UI::node "span" "" (UI::leaf "strong" "" "Talon Operations" + "," + UI::leaf "small" "" "Bank console") + "," + UI::leaf "span" (UI::prop "className" "profile-more") "•••") + UI::node "aside" (UI::prop "className" "sidebar${mobile}") (brand + "," + nav + "," + UI::node "div" (UI::prop "className" "sidebar-bottom") (UI::node "div" (UI::prop "className" "secure-chip") (UI::leaf "span" "" "◇" + "," + UI::leaf "span" "" "Protected session") + "," + profile)) + + topbar : AppModel -> string + topbar model = + title = routeTitle model.route + menu = UI::button "toggle-menu" "icon-button mobile-menu" "Menu" "☰" + greeting = UI::node "div" (UI::prop "className" "topbar-title") (UI::leaf "small" "" "LIVE OPERATIONS · OSPREY ONLINE" + "," + UI::leaf "strong" "" title) + actions = UI::node "div" (UI::prop "className" "topbar-actions") (UI::button "topbar-refresh" "icon-button" "Refresh" "↻" + "," + UI::node "button" (UI::prop "id" "topbar-activity" + "," + UI::prop "event" "click" + "," + UI::prop "type" "button" + "," + UI::prop "className" "icon-button notification-button" + "," + UI::prop "aria-label" "Activity notifications") (UI::leaf "span" "" "♢" + "," + UI::leaf "span" (UI::prop "className" "notification-dot") "") + "," + UI::button "topbar-open" "button primary top-open" "Open account" "+") + UI::node "header" (UI::prop "className" "topbar") (menu + "," + greeting + "," + actions) + + loading : Unit -> string + loading () = UI::node "div" (UI::prop "className" "page loading-page" + "," + UI::prop "aria-label" "Loading bank data") (UI::node "div" (UI::prop "className" "skeleton skeleton-hero") "" + "," + UI::node "div" (UI::prop "className" "skeleton-grid") (UI::leaf "span" (UI::prop "className" "skeleton") "" + "," + UI::leaf "span" (UI::prop "className" "skeleton") "" + "," + UI::leaf "span" (UI::prop "className" "skeleton") "") + "," + UI::node "div" (UI::prop "className" "skeleton skeleton-table") "") + + notice : AppModel -> string + notice model = match length model.noticeTone == 0 + true => "" + false => + icon = match model.noticeTone + "success" => "✓" + "error" => "!" + _ => "◎" + UI::node "aside" (UI::prop "className" "toast ${model.noticeTone}" + "," + UI::prop "role" "status") (UI::leaf "span" (UI::prop "className" "toast-icon") icon + "," + UI::node "span" (UI::prop "className" "toast-copy") (UI::leaf "strong" "" model.noticeTitle + "," + UI::leaf "small" "" model.noticeBody) + "," + UI::button "dismiss-notice" "toast-close" "Dismiss" "×") + + modal : AppModel -> string + modal model = match model.modal == "open" + false => "" + true => + head = UI::node "div" (UI::prop "className" "modal-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "eyebrow") "NEW TALON ACCOUNT" + "," + UI::leaf "h2" (UI::prop "id" "open-account-title") "Open account" + "," + UI::leaf "p" "" "Create a protected client account in one step.") + "," + UI::button "close-modal" "icon-button modal-close" "Close" "×") + owner = UI::field "new-owner" "name" "Account owner" "Full legal name" "text" + reassurance = UI::node "div" (UI::prop "className" "modal-reassurance") (UI::leaf "span" "" "◇" + "," + UI::leaf "p" "" "Storage access remains server-side. Your browser receives only the account response.") + actions = UI::node "div" (UI::prop "className" "modal-actions") (UI::button "cancel-modal" "button secondary" "Cancel" "" + "," + UI::node "button" (UI::prop "type" "submit" + "," + UI::prop "className" "button primary") (UI::leaf "span" "" "Open account" + "," + UI::leaf "span" "" "→")) + form = UI::node "form" (UI::prop "id" "submit-open-account" + "," + UI::prop "event" "submit" + "," + UI::prop "className" "modal-form") (head + "," + owner + "," + reassurance + "," + actions) + UI::node "div" (UI::prop "className" "modal-backdrop") (UI::node "section" (UI::prop "className" "modal" + "," + UI::prop "role" "dialog" + "," + UI::prop "aria-modal" "true" + "," + UI::prop "aria-labelledby" "open-account-title") form) + + export shell : AppModel -> string -> string + shell model content = + progress = match model.loading == "true" || model.busy == "true" + true => UI::leaf "div" (UI::prop "className" "top-progress") "" + false => "" + progressPart = match length progress == 0 + true => "" + false => "," + progress + body = match model.loading == "true" + true => loading () + false => content + toast = notice model + dialog = modal model + extras = match length toast == 0 + true => dialog + false => match length dialog == 0 + true => toast + false => toast + "," + dialog + suffix = match length extras == 0 + true => "" + false => "," + extras + UI::node "div" (UI::prop "className" "app-shell") (sidebar model + "," + UI::node "div" (UI::prop "className" "app-main") (topbar model + progressPart + "," + UI::node "main" (UI::prop "className" "content" + "," + UI::prop "id" "main-content") body) + suffix) diff --git a/examples/projects/modules/client/src/main.ospml b/examples/projects/modules/client/src/main.ospml new file mode 100644 index 00000000..e2707fd6 --- /dev/null +++ b/examples/projects/modules/client/src/main.ospml @@ -0,0 +1,10 @@ +// Browser composition root. The compiler exposes osprey_web_dispatch as a +// callable wasm export; _start invokes main for the initial render. +namespace talon + +import talon::App + +osprey_web_dispatch : string -> int +osprey_web_dispatch payload = App::receive payload + +main () = App::start () diff --git a/examples/projects/modules/client/src/model.ospml b/examples/projects/modules/client/src/model.ospml new file mode 100644 index 00000000..e84d256a --- /dev/null +++ b/examples/projects/modules/client/src/model.ospml @@ -0,0 +1,89 @@ +// The host persists this as opaque JSON. Every field is deliberately scalar; +// API documents are escaped JSON strings because jsonGet cannot return trees. +namespace talon + +import bank::Json + +type AppModel = + route : string + moveMode : string + selected : string + activityFilter : string + search : string + modal : string + menu : string + loading : string + busy : string + accountsLoaded : string + activityLoaded : string + noticeTone : string + noticeTitle : string + noticeBody : string + accounts : string + activity : string + +module Model + export initial : Unit -> AppModel + initial () = AppModel(route = "overview", moveMode = "transfer", selected = "1", activityFilter = "all", search = "", modal = "closed", menu = "closed", loading = "true", busy = "false", accountsLoaded = "false", activityLoaded = "false", noticeTone = "", noticeTitle = "", noticeBody = "", accounts = "[]", activity = "[]") + + export decode : string -> AppModel + decode source = match length source == 0 + true => initial () + false => AppModel( + route = Json::getOr source "route" "overview", + moveMode = Json::getOr source "moveMode" "transfer", + selected = Json::getOr source "selected" "1", + activityFilter = Json::getOr source "activityFilter" "all", + search = Json::getOr source "search" "", + modal = Json::getOr source "modal" "closed", + menu = Json::getOr source "menu" "closed", + loading = Json::getOr source "loading" "false", + busy = Json::getOr source "busy" "false", + accountsLoaded = Json::getOr source "accountsLoaded" "false", + activityLoaded = Json::getOr source "activityLoaded" "false", + noticeTone = Json::getOr source "noticeTone" "", + noticeTitle = Json::getOr source "noticeTitle" "", + noticeBody = Json::getOr source "noticeBody" "", + accounts = Json::getOr source "accounts" "[]", + activity = Json::getOr source "activity" "[]") + + export encode : AppModel -> string + encode m = Json::obj ( + Json::strField "route" m.route + "," + Json::strField "moveMode" m.moveMode + "," + + Json::strField "selected" m.selected + "," + Json::strField "activityFilter" m.activityFilter + "," + + Json::strField "search" m.search + "," + Json::strField "modal" m.modal + "," + + Json::strField "menu" m.menu + "," + Json::strField "loading" m.loading + "," + + Json::strField "busy" m.busy + "," + Json::strField "accountsLoaded" m.accountsLoaded + "," + + Json::strField "activityLoaded" m.activityLoaded + "," + Json::strField "noticeTone" m.noticeTone + "," + + Json::strField "noticeTitle" m.noticeTitle + "," + Json::strField "noticeBody" m.noticeBody + "," + + Json::strField "accounts" m.accounts + "," + Json::strField "activity" m.activity) + + choose : string -> string -> string -> string -> string + choose changed target value old = match changed == target + true => value + false => old + + export set : AppModel -> string -> string -> AppModel + set m changed value = AppModel( + route = choose changed "route" value m.route, + moveMode = choose changed "moveMode" value m.moveMode, + selected = choose changed "selected" value m.selected, + activityFilter = choose changed "activityFilter" value m.activityFilter, + search = choose changed "search" value m.search, + modal = choose changed "modal" value m.modal, + menu = choose changed "menu" value m.menu, + loading = choose changed "loading" value m.loading, + busy = choose changed "busy" value m.busy, + accountsLoaded = choose changed "accountsLoaded" value m.accountsLoaded, + activityLoaded = choose changed "activityLoaded" value m.activityLoaded, + noticeTone = choose changed "noticeTone" value m.noticeTone, + noticeTitle = choose changed "noticeTitle" value m.noticeTitle, + noticeBody = choose changed "noticeBody" value m.noticeBody, + accounts = choose changed "accounts" value m.accounts, + activity = choose changed "activity" value m.activity) + + export notice : AppModel -> string -> string -> string -> AppModel + notice m tone title body = set (set (set m "noticeTone" tone) "noticeTitle" title) "noticeBody" body + + export clearNotice : AppModel -> AppModel + clearNotice m = notice m "" "" "" diff --git a/examples/projects/modules/client/src/pages/accounts.ospml b/examples/projects/modules/client/src/pages/accounts.ospml new file mode 100644 index 00000000..724631ad --- /dev/null +++ b/examples/projects/modules/client/src/pages/accounts.ospml @@ -0,0 +1,40 @@ +namespace talon + +import talon::UI +import talon::BankData +import talon::AccountView +import talon::ActivityView + +module AccountsPage + detail : AppModel -> string + detail model = + doc = jsonParse model.accounts + index = BankData::accountIndex doc model.selected + id = BankData::value doc "[${index}].id" "—" + owner = BankData::value doc "[${index}].owner" "No account selected" + balance = BankData::value doc "[${index}].balance" "$0.00" + cents = BankData::integer doc "[${index}].cents" + freed = jsonFree doc + available = match cents > 0 + true => "Ready to move" + false => "Waiting for first deposit" + heading = UI::node "div" (UI::prop "className" "detail-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "account-mark violet") "T" + "," + UI::leaf "div" "" (UI::leaf "small" "" "TALON ACCOUNT #${id}" + "," + UI::leaf "h2" "" owner)) + "," + UI::leaf "span" (UI::prop "className" "status-pill success") "● Active") + balanceBlock = UI::node "div" (UI::prop "className" "detail-balance") (UI::leaf "small" "" "Available balance" + "," + UI::leaf "strong" "" balance + "," + UI::leaf "span" "" available) + actions = UI::node "div" (UI::prop "className" "detail-actions") (UI::button "quick-deposit" "button primary" "Deposit" "+" + "," + UI::button "quick-withdraw" "button secondary" "Withdraw" "−" + "," + UI::button "quick-transfer" "button secondary" "Transfer" "↗") + facts = UI::node "dl" (UI::prop "className" "detail-facts") (UI::node "div" "" (UI::leaf "dt" "" "Account ID" + "," + UI::leaf "dd" "" "#${id}") + "," + UI::node "div" "" (UI::leaf "dt" "" "Ledger" + "," + UI::leaf "dd" "" "Journaled") + "," + UI::node "div" "" (UI::leaf "dt" "" "Overdrafts" + "," + UI::leaf "dd" "" "Refused")) + UI::node "section" (UI::prop "className" "card account-detail") (heading + "," + balanceBlock + "," + actions + "," + facts) + + export view : AppModel -> string + view model = + cards = AccountView::cards model.accounts 99 model.selected + recent = ActivityView::rows model.activity 4 "all" "" + pageHead = UI::node "header" (UI::prop "className" "page-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "eyebrow") "ACCOUNTS" + "," + UI::leaf "h1" "" "Client accounts" + "," + UI::leaf "p" "" "Every managed balance and protected client account in one view.") + "," + UI::button "accounts-open" "button primary" "Open account" "+") + allCards = match length cards == 0 + true => UI::empty "◇" "No accounts yet" "Open an account in seconds—no paperwork required." + false => UI::node "div" (UI::prop "className" "account-grid account-grid-wide") cards + recentBody = match length recent == 0 + true => UI::empty "↯" "No movements" "Activity for this account will show here." + false => UI::node "div" (UI::prop "className" "activity-list") recent + recentCard = UI::node "section" (UI::prop "className" "card compact-activity") (UI::node "div" (UI::prop "className" "section-heading") (UI::leaf "h2" "" "Latest movements" + "," + UI::button "accounts-activity" "text-button" "See all" "→") + "," + recentBody) + detailGrid = UI::node "div" (UI::prop "className" "account-detail-grid") (detail model + "," + recentCard) + UI::node "div" (UI::prop "className" "page accounts-page") (pageHead + "," + allCards + "," + detailGrid) diff --git a/examples/projects/modules/client/src/pages/activity.ospml b/examples/projects/modules/client/src/pages/activity.ospml new file mode 100644 index 00000000..4545e08d --- /dev/null +++ b/examples/projects/modules/client/src/pages/activity.ospml @@ -0,0 +1,30 @@ +namespace talon + +import talon::UI +import talon::BankData +import talon::ActivityView + +module ActivityPage + stat : string -> string -> int -> string + stat icon label value = UI::node "div" (UI::prop "className" "mini-stat") (UI::leaf "span" "" icon + "," + UI::node "div" "" (UI::leaf "small" "" label + "," + UI::leaf "strong" "" (toString value))) + + export view : AppModel -> string + view model = + total = BankData::activityCount model.activity + credits = ActivityView::count model.activity "credit" + debits = ActivityView::count model.activity "debit" + refused = ActivityView::count model.activity "refused" + rows = ActivityView::rows model.activity 100 model.activityFilter model.search + pageHead = UI::node "header" (UI::prop "className" "page-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "eyebrow") "AUDIT TRAIL" + "," + UI::leaf "h1" "" "Activity" + "," + UI::leaf "p" "" "Every credit, debit, transfer side, and refusal in one live ledger.") + "," + UI::button "activity-refresh" "button secondary" "Refresh" "↻") + search = UI::node "label" (UI::prop "className" "search-box" + "," + UI::prop "htmlFor" "activity-search") (UI::leaf "span" "" "⌕" + "," + UI::leaf "input" (UI::prop "id" "activity-search" + "," + UI::prop "name" "search" + "," + UI::prop "event" "input" + "," + UI::prop "value" model.search + "," + UI::prop "placeholder" "Search description or owner" + "," + UI::prop "type" "search") "") + allActive = model.activityFilter == "all" + inActive = model.activityFilter == "in" + outActive = model.activityFilter == "out" + refusedActive = model.activityFilter == "refused" + filters = UI::node "div" (UI::prop "className" "filter-row") (UI::chip "filter-all" "All ${total}" "" allActive + "," + UI::chip "filter-in" "Money in ${credits}" "↙" inActive + "," + UI::chip "filter-out" "Money out ${debits}" "↗" outActive + "," + UI::chip "filter-refused" "Declined ${refused}" "!" refusedActive) + summary = UI::node "div" (UI::prop "className" "mini-stat-grid") (stat "◎" "Total entries" total + "," + stat "↙" "Credits" credits + "," + stat "↗" "Debits" debits + "," + stat "!" "Protected refusals" refused) + body = match length rows == 0 + true => UI::empty "⌕" "No matching activity" "Try another search or broaden the movement filter." + false => UI::node "div" (UI::prop "className" "activity-list activity-list-full") rows + ledger = UI::node "section" (UI::prop "className" "card ledger-card") (UI::node "div" (UI::prop "className" "ledger-toolbar") (search + "," + filters) + "," + body) + UI::node "div" (UI::prop "className" "page activity-page") (pageHead + "," + summary + "," + ledger) diff --git a/examples/projects/modules/client/src/pages/move.ospml b/examples/projects/modules/client/src/pages/move.ospml new file mode 100644 index 00000000..74dfb8ee --- /dev/null +++ b/examples/projects/modules/client/src/pages/move.ospml @@ -0,0 +1,61 @@ +namespace talon + +import talon::UI +import talon::BankData + +module MovePage + selectField : int -> string -> string -> string -> string -> string + selectField doc id name label selected = + options = BankData::accountOptions doc 0 + control = UI::node "select" (UI::prop "id" id + "," + UI::prop "name" name + "," + UI::prop "className" "field-control" + "," + UI::prop "defaultValue" selected) options + UI::node "label" (UI::prop "className" "field") (UI::leaf "span" (UI::prop "className" "field-label") label + "," + control) + + amountField : string -> string + amountField prefix = + control = UI::node "div" (UI::prop "className" "money-input") (UI::leaf "span" "" "$" + "," + UI::leaf "input" (UI::prop "id" "${prefix}-amount" + "," + UI::prop "name" "amount" + "," + UI::prop "className" "field-control" + "," + UI::prop "placeholder" "0.00" + "," + UI::prop "inputMode" "decimal" + "," + UI::prop "required" "true" + "," + UI::prop "type" "text") "") + UI::node "label" (UI::prop "className" "field amount-field") (UI::leaf "span" (UI::prop "className" "field-label") "Amount" + "," + control) + + noteField : string -> string + noteField prefix = UI::field "${prefix}-note" "note" "Description" "What is this for?" "text" + + submit : string -> string -> string + submit label icon = UI::node "button" (UI::prop "className" "button primary submit-button" + "," + UI::prop "type" "submit") (UI::text "button-icon" icon + "," + UI::text "button-label" label) + + deposit : AppModel -> int -> string + deposit model doc = + intro = UI::node "div" (UI::prop "className" "form-intro") (UI::leaf "span" (UI::prop "className" "form-icon deposit") "↙" + "," + UI::node "div" "" (UI::leaf "h2" "" "Deposit funds" + "," + UI::leaf "p" "" "Credit an account instantly and journal the movement.")) + fields = selectField doc "deposit-account" "account" "Deposit to" model.selected + "," + amountField "deposit" + "," + noteField "deposit" + form = UI::node "form" (UI::prop "id" "submit-deposit" + "," + UI::prop "event" "submit" + "," + UI::prop "className" "money-form") (intro + "," + UI::node "div" (UI::prop "className" "form-grid") fields + "," + submit "Deposit" "↙") + form + + withdraw : AppModel -> int -> string + withdraw model doc = + intro = UI::node "div" (UI::prop "className" "form-intro") (UI::leaf "span" (UI::prop "className" "form-icon withdraw") "↗" + "," + UI::node "div" "" (UI::leaf "h2" "" "Withdraw funds" + "," + UI::leaf "p" "" "Debit securely. Overdraft attempts are refused and audited.")) + fields = selectField doc "withdraw-account" "account" "Withdraw from" model.selected + "," + amountField "withdraw" + "," + noteField "withdraw" + UI::node "form" (UI::prop "id" "submit-withdraw" + "," + UI::prop "event" "submit" + "," + UI::prop "className" "money-form") (intro + "," + UI::node "div" (UI::prop "className" "form-grid") fields + "," + submit "Withdraw" "↗") + + transfer : AppModel -> int -> string + transfer model doc = + intro = UI::node "div" (UI::prop "className" "form-intro") (UI::leaf "span" (UI::prop "className" "form-icon transfer") "⇄" + "," + UI::node "div" "" (UI::leaf "h2" "" "Transfer money" + "," + UI::leaf "p" "" "Move funds atomically between Talon accounts.")) + accounts = UI::node "div" (UI::prop "className" "paired-fields") (selectField doc "transfer-from" "from" "From account" model.selected + "," + UI::leaf "span" (UI::prop "className" "swap-mark") "→" + "," + selectField doc "transfer-to" "to" "To account" "2") + fields = accounts + "," + amountField "transfer" + "," + noteField "transfer" + UI::node "form" (UI::prop "id" "submit-transfer" + "," + UI::prop "event" "submit" + "," + UI::prop "className" "money-form") (intro + "," + UI::node "div" (UI::prop "className" "form-grid") fields + "," + submit "Transfer" "⇄") + + tip : string -> string -> string -> string + tip icon title body = UI::node "li" "" (UI::leaf "span" (UI::prop "className" "tip-icon") icon + "," + UI::node "span" "" (UI::leaf "strong" "" title + "," + UI::leaf "small" "" body)) + + export view : AppModel -> string + view model = + doc = jsonParse model.accounts + form = match model.moveMode + "deposit" => deposit model doc + "withdraw" => withdraw model doc + _ => transfer model doc + freed = jsonFree doc + depositActive = model.moveMode == "deposit" + withdrawActive = model.moveMode == "withdraw" + transferActive = model.moveMode == "transfer" + tabs = UI::node "div" (UI::prop "className" "segmented move-tabs" + "," + UI::prop "role" "tablist") (UI::chip "move-deposit" "Deposit" "↙" depositActive + "," + UI::chip "move-withdraw" "Withdraw" "↗" withdrawActive + "," + UI::chip "move-transfer" "Transfer" "⇄" transferActive) + pageHead = UI::node "header" (UI::prop "className" "page-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "eyebrow") "MOVE MONEY" + "," + UI::leaf "h1" "" "Client funds, in motion" + "," + UI::leaf "p" "" "Fast bank operations, guarded by Osprey domain rules.")) + guidance = UI::node "aside" (UI::prop "className" "card guidance-card") (UI::leaf "span" (UI::prop "className" "eyebrow") "BUILT FOR CONFIDENCE" + "," + UI::leaf "h2" "" "Every movement is protected" + "," + UI::node "ul" (UI::prop "className" "tip-list") (tip "✓" "Atomic transfers" "Both sides land together—or not at all." + "," + tip "◎" "Complete journal" "Successful and refused attempts are recorded." + "," + tip "◇" "Integer precision" "Money remains whole cents from form to ledger.") + "," + UI::node "div" (UI::prop "className" "shield-seal") (UI::leaf "strong" "" "T" + "," + UI::leaf "span" "" "Talon Shield active")) + UI::node "div" (UI::prop "className" "page move-page") (pageHead + "," + tabs + "," + UI::node "div" (UI::prop "className" "move-grid") (UI::node "section" (UI::prop "className" "card form-card") form + "," + guidance)) diff --git a/examples/projects/modules/client/src/pages/overview.ospml b/examples/projects/modules/client/src/pages/overview.ospml new file mode 100644 index 00000000..cf1bf688 --- /dev/null +++ b/examples/projects/modules/client/src/pages/overview.ospml @@ -0,0 +1,34 @@ +namespace talon + +import talon::UI +import bank::Money +import talon::BankData +import talon::ActivityView +import talon::AccountView + +module OverviewPage + stat : string -> string -> string -> string -> string + stat icon label value trend = UI::node "article" (UI::prop "className" "stat-card") (UI::leaf "span" (UI::prop "className" "stat-icon") icon + "," + UI::node "span" (UI::prop "className" "stat-copy") (UI::leaf "small" "" label + "," + UI::leaf "strong" "" value + "," + UI::leaf "em" "" trend)) + + export view : AppModel -> string + view model = + total = BankData::total model.accounts + accounts = BankData::accountCount model.accounts + movements = BankData::activityCount model.activity + cards = AccountView::cards model.accounts 3 model.selected + recent = ActivityView::rows model.activity 5 "all" "" + heroCopy = UI::node "div" (UI::prop "className" "hero-copy") (UI::leaf "span" (UI::prop "className" "eyebrow") "MANAGED PORTFOLIO" + "," + UI::leaf "h1" "" (Money::show total) + "," + UI::leaf "p" "" "Across ${accounts} protected client accounts" + "," + UI::node "div" (UI::prop "className" "hero-actions") (UI::button "quick-transfer" "button primary" "Move money" "↗" + "," + UI::button "quick-deposit" "button ghost-on-dark" "Add funds" "+")) + heroArt = UI::node "div" (UI::prop "className" "hero-art" + "," + UI::prop "aria-hidden" "true") (UI::leaf "span" (UI::prop "className" "orb orb-one") "" + "," + UI::leaf "span" (UI::prop "className" "orb orb-two") "" + "," + UI::leaf "span" (UI::prop "className" "hero-monogram") "T") + hero = UI::node "section" (UI::prop "className" "hero-card") (heroCopy + "," + heroArt) + stats = UI::node "section" (UI::prop "className" "stat-grid") (stat "↙" "Money in" (toString (ActivityView::count model.activity "credit")) "healthy inflow" + "," + stat "↗" "Money out" (toString (ActivityView::count model.activity "debit")) "this cycle" + "," + stat "◎" "Journal entries" (toString movements) "fully audited") + accountsHead = UI::node "div" (UI::prop "className" "section-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "eyebrow") "MANAGED CLIENTS" + "," + UI::leaf "h2" "" "Client accounts") + "," + UI::button "overview-accounts" "text-button" "View all" "→") + accountBody = match length cards == 0 + true => UI::empty "◇" "No accounts yet" "Open your first account to start moving money." + false => UI::node "div" (UI::prop "className" "account-grid") cards + accountsSection = UI::node "section" (UI::prop "className" "section-block") (accountsHead + "," + accountBody) + activityHead = UI::node "div" (UI::prop "className" "section-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "eyebrow") "LIVE LEDGER" + "," + UI::leaf "h2" "" "Recent activity") + "," + UI::button "overview-activity" "text-button" "Full history" "→") + activityBody = match length recent == 0 + true => UI::empty "↯" "Nothing to report" "New movements will appear here instantly." + false => UI::node "div" (UI::prop "className" "activity-list") recent + activitySection = UI::node "section" (UI::prop "className" "card section-block") (activityHead + "," + activityBody) + UI::node "div" (UI::prop "className" "page overview-page") (hero + "," + stats + "," + accountsSection + "," + activitySection) diff --git a/examples/projects/modules/client/src/pages/security.ospml b/examples/projects/modules/client/src/pages/security.ospml new file mode 100644 index 00000000..4b425ff3 --- /dev/null +++ b/examples/projects/modules/client/src/pages/security.ospml @@ -0,0 +1,19 @@ +namespace talon + +import talon::UI + +module SecurityPage + control : string -> string -> string -> string -> string + control icon title body status = UI::node "li" (UI::prop "className" "security-control") (UI::leaf "span" (UI::prop "className" "security-icon") icon + "," + UI::node "span" (UI::prop "className" "security-copy") (UI::leaf "strong" "" title + "," + UI::leaf "small" "" body) + "," + UI::leaf "span" (UI::prop "className" "status-pill success") status) + + layer : string -> string -> string -> string -> string + layer number title code body = UI::node "li" (UI::prop "className" "architecture-layer") (UI::leaf "span" (UI::prop "className" "layer-number") number + "," + UI::node "div" "" (UI::leaf "small" "" code + "," + UI::leaf "h3" "" title + "," + UI::leaf "p" "" body)) + + export view : AppModel -> string + view model = + pageHead = UI::node "header" (UI::prop "className" "page-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "eyebrow") "SECURITY & ARCHITECTURE" + "," + UI::leaf "h1" "" "Trust you can inspect" + "," + UI::leaf "p" "" "Talon is a real Osprey application—not a JavaScript mock wearing its data.")) + hero = UI::node "section" (UI::prop "className" "security-hero") (UI::node "div" (UI::prop "className" "security-orbit") (UI::leaf "span" (UI::prop "className" "orbit-ring ring-one") "" + "," + UI::leaf "span" (UI::prop "className" "orbit-ring ring-two") "" + "," + UI::leaf "strong" "" "T") + "," + UI::node "div" (UI::prop "className" "security-hero-copy") (UI::leaf "span" (UI::prop "className" "status-pill success") "● All systems protected" + "," + UI::leaf "h2" "" "Capability-checked by construction" + "," + UI::leaf "p" "" "The browser can request bank operations, but it never receives storage authority. Osprey’s module and effect boundaries decide what code is allowed to do.")) + controls = UI::node "section" (UI::prop "className" "card security-card") (UI::node "div" (UI::prop "className" "section-heading") (UI::node "div" "" (UI::leaf "span" (UI::prop "className" "eyebrow") "ACTIVE CONTROLS" + "," + UI::leaf "h2" "" "Protection status")) + "," + UI::node "ul" (UI::prop "className" "security-list") (control "◇" "Storage isolation" "The UI has no Ledger or SQLite capability." "Enforced" + "," + control "⇄" "Atomic transfers" "Debit and credit commit as one transaction." "Enforced" + "," + control "◎" "Immutable audit trail" "Refused overdrafts are journalled too." "Live" + "," + control "¢" "Whole-cent arithmetic" "No floating-point drift in money flows." "Verified")) + layers = UI::node "ol" (UI::prop "className" "architecture-stack") (layer "01" "React renderer" "HOST / VIEW" "Turns declarative nodes into a fast, accessible interface. It owns no bank logic." + "," + layer "02" "Osprey Web App" "WASM / MODEL · UPDATE · VIEW" "Owns routing, interactions, validation, state transitions, and command descriptions." + "," + layer "03" "HTTP capability" "COMMAND / API" "The only browser-side effect: typed requests to the public bank endpoints." + "," + layer "04" "Ledger service" "OSPREY / EFFECT HANDLERS" "Domain rules and SQLite authority remain on the server, beyond the UI boundary.") + architecture = UI::node "section" (UI::prop "className" "card architecture-card" + "," + UI::prop "id" "architecture") (UI::leaf "span" (UI::prop "className" "eyebrow") "HOW THIS APP RUNS" + "," + UI::leaf "h2" "" "A thin host. A serious Osprey core." + "," + UI::leaf "p" (UI::prop "className" "architecture-lead") "React is deliberately below the Osprey surface. The app emits plain view data and generic commands; the host renders and transports them." + "," + layers) + UI::node "div" (UI::prop "className" "page security-page") (pageHead + "," + hero + "," + UI::node "div" (UI::prop "className" "security-grid") (controls + "," + architecture)) diff --git a/examples/projects/modules/client/src/ui.ospml b/examples/projects/modules/client/src/ui.ospml new file mode 100644 index 00000000..2ef8877a --- /dev/null +++ b/examples/projects/modules/client/src/ui.ospml @@ -0,0 +1,49 @@ +// Declarative React-neutral view nodes. `event` is interpreted by the host and +// never reaches the DOM; Osprey only deals in data and stable event ids. +namespace talon + +import bank::Json + +module UI + export prop : string -> string -> string + prop key value = Json::strField key value + + export props : string -> string + props members = Json::obj members + + export node : string -> string -> string -> string + node tag properties children = Json::obj (Json::strField "tag" tag + "," + Json::rawField "props" (props properties) + "," + Json::rawField "children" (Json::arr children)) + + export leaf : string -> string -> string -> string + leaf tag properties text = Json::obj (Json::strField "tag" tag + "," + Json::strField "text" text + "," + Json::rawField "props" (props properties)) + + export text : string -> string -> string + text className value = leaf "span" (prop "className" className) value + + export button : string -> string -> string -> string -> string + button id className label icon = + children = match length icon == 0 + true => "" + false => text "button-icon" icon + "," + node "button" (prop "id" id + "," + prop "className" className + "," + prop "event" "click" + "," + prop "type" "button") (children + text "button-label" label) + + export chip : string -> string -> string -> bool -> string + chip id label icon active = + activeClass = match active + true => "chip active" + false => "chip" + button id activeClass label icon + + export field : string -> string -> string -> string -> string -> string + field id name label placeholder kind = + control = leaf "input" (prop "id" id + "," + prop "name" name + "," + prop "className" "field-control" + "," + prop "placeholder" placeholder + "," + prop "type" kind) "" + node "label" (prop "className" "field") (leaf "span" (prop "className" "field-label") label + "," + control) + + export selectStart : string -> string -> string -> string + selectStart id name label = leaf "label" (prop "className" "field-label" + "," + prop "htmlFor" id) label + "," + node "select" (prop "id" id + "," + prop "name" name + "," + prop "className" "field-control") "" + + export option : string -> string -> string + option value label = leaf "option" (prop "value" value) label + + export empty : string -> string -> string -> string + empty icon title body = node "div" (prop "className" "empty-state") (leaf "div" (prop "className" "empty-icon") icon + "," + leaf "h3" "" title + "," + leaf "p" "" body) diff --git a/examples/projects/modules/client/src/update.ospml b/examples/projects/modules/client/src/update.ospml new file mode 100644 index 00000000..c5bea389 --- /dev/null +++ b/examples/projects/modules/client/src/update.ospml @@ -0,0 +1,237 @@ +namespace talon + +import bank::Json +import talon::Model +import talon::BankData +import talon::Commands + +type UpdateResult = + model : AppModel + commands : string + +module Update + result : AppModel -> string -> UpdateResult + result model commands = UpdateResult(model = model, commands = commands) + + noCommand : AppModel -> UpdateResult + noCommand model = result model Commands::none + + navigate : AppModel -> string -> AppModel + navigate model route = Model::set (Model::set model "route" route) "menu" "closed" + + go : AppModel -> string -> UpdateResult + go model route = result (navigate model route) (Commands::navigate route) + + move : AppModel -> string -> AppModel + move model mode = Model::set (navigate model "move") "moveMode" mode + + routeFor id = match id + "nav-overview" => "overview" + "nav-accounts" => "accounts" + "overview-accounts" => "accounts" + "nav-move" => "move" + "nav-activity" => "activity" + "overview-activity" => "activity" + "accounts-activity" => "activity" + "topbar-activity" => "activity" + "nav-security" => "security" + _ => "" + + modeFor id = match id + "quick-deposit" => "deposit" + "quick-withdraw" => "withdraw" + "quick-transfer" => "transfer" + "move-deposit" => "deposit" + "move-withdraw" => "withdraw" + "move-transfer" => "transfer" + _ => "" + + filterFor id = match id + "filter-all" => "all" + "filter-in" => "in" + "filter-out" => "out" + "filter-refused" => "refused" + _ => "" + + selectedMode model id mode = match startsWith id "quick-" + true => result (move model mode) (Commands::navigate "move") + false => noCommand (Model::set model "moveMode" mode) + + clickFilter model id = + filter = filterFor id + match length filter > 0 + true => noCommand (Model::set model "activityFilter" filter) + false => clickModal model id + + clickMode model id = + mode = modeFor id + match length mode > 0 + true => selectedMode model id mode + false => clickFilter model id + + openRequest id = match id + "open-account" => true + "accounts-open" => true + "topbar-open" => true + _ => false + + closeRequest id = id == "close-modal" || id == "cancel-modal" + + refreshRequest id = match id + "refresh-data" => true + "activity-refresh" => true + "topbar-refresh" => true + _ => false + + clickModal model id = match openRequest id + true => result (Model::set model "modal" "open") (Commands::focus "new-owner") + false => match closeRequest id + true => noCommand (Model::set model "modal" "closed") + false => clickUtility model id + + clickUtility model id = match refreshRequest id + true => result (Model::set model "loading" "true") (Commands::hydrate ()) + false => match id + "dismiss-notice" => noCommand (Model::clearNotice model) + "toggle-menu" => + menuValue = match model.menu + "open" => "closed" + _ => "open" + noCommand (Model::set model "menu" menuValue) + _ => match startsWith id "account-" + true => result (navigate (Model::set model "selected" (drop id 8)) "accounts") (Commands::navigate "accounts") + false => noCommand model + + click model id = + route = routeFor id + match length route > 0 + true => go model route + false => clickMode model id + + location : AppModel -> string -> UpdateResult + location model value = + route = match startsWith value "#/" + true => drop value 2 + false => value + safe = match route + "overview" => route + "accounts" => route + "move" => route + "activity" => route + "security" => route + _ => "overview" + noCommand (navigate model safe) + + formValue : string -> string -> string + formValue data name = Json::getOr data name "" + + integer : string -> int + integer raw = match parseInt raw + Success value => value + Error message => 0 + + invalid : AppModel -> string -> string -> UpdateResult + invalid model title body = noCommand (Model::notice model "error" title body) + + postMovement : AppModel -> string -> string -> string -> string -> UpdateResult + postMovement model command endpoint body title = + busy = Model::set (Model::notice model "info" title "Contacting the protected ledger…") "busy" "true" + result busy (Commands::post command endpoint body) + + deposit : AppModel -> string -> UpdateResult + deposit model data = + account = integer (formValue data "account") + cents = BankData::amountCents (formValue data "amount") + note = trim (formValue data "note") + match account > 0 && cents > 0 + false => invalid model "Check the deposit" "Choose an account and enter a positive amount." + true => postMovement model "mutate-deposit" "/api/deposit" (Json::obj (Json::numField "account" account + "," + Json::numField "cents" cents + "," + Json::strField "note" note)) "Depositing funds" + + withdraw : AppModel -> string -> UpdateResult + withdraw model data = + account = integer (formValue data "account") + cents = BankData::amountCents (formValue data "amount") + note = trim (formValue data "note") + match account > 0 && cents > 0 + false => invalid model "Check the withdrawal" "Choose an account and enter a positive amount." + true => postMovement model "mutate-withdraw" "/api/withdraw" (Json::obj (Json::numField "account" account + "," + Json::numField "cents" cents + "," + Json::strField "note" note)) "Authorising withdrawal" + + transfer : AppModel -> string -> UpdateResult + transfer model data = + from = integer (formValue data "from") + to = integer (formValue data "to") + cents = BankData::amountCents (formValue data "amount") + note = trim (formValue data "note") + match from == to + true => invalid model "Choose two accounts" "Source and destination must be different." + false => match from > 0 && to > 0 && cents > 0 + false => invalid model "Check the transfer" "Choose both accounts and enter a positive amount." + true => postMovement model "mutate-transfer" "/api/transfer" (Json::obj (Json::numField "from" from + "," + Json::numField "to" to + "," + Json::numField "cents" cents + "," + Json::strField "note" note)) "Transferring funds" + + openAccount : AppModel -> string -> UpdateResult + openAccount model data = + owner = trim (formValue data "name") + match length owner == 0 + true => invalid model "Owner name required" "Enter the client’s full name to open the account." + false => postMovement model "mutate-open" "/api/accounts" (Json::obj (Json::strField "name" owner)) "Opening account" + + submit : AppModel -> string -> string -> UpdateResult + submit model id data = match id + "submit-deposit" => deposit model data + "submit-withdraw" => withdraw model data + "submit-transfer" => transfer model data + "submit-open-account" => openAccount model data + _ => noCommand model + + loaded : AppModel -> AppModel + loaded model = match model.accountsLoaded == "true" && model.activityLoaded == "true" + true => Model::set model "loading" "false" + false => model + + failedLoad : AppModel -> string -> AppModel + failedLoad model resource = + marked = Model::set model resource "true" + loaded (Model::notice marked "error" "Bank data unavailable" "The ${resource} request failed. Refresh to try again.") + + apiError : string -> string + apiError data = Json::getOr data "error" "The ledger could not complete that operation." + + mutation : AppModel -> string -> int -> string -> UpdateResult + mutation model id status data = match status >= 200 && status < 300 + false => result (Model::notice (Model::set model "busy" "false") "error" "Operation refused" (apiError data)) (Commands::hydrate ()) + true => + title = match id + "mutate-open" => "Account opened" + "mutate-deposit" => "Deposit complete" + "mutate-withdraw" => "Withdrawal complete" + _ => "Transfer complete" + ready = Model::set (Model::set model "busy" "false") "modal" "closed" + result (Model::notice ready "success" title "The ledger and activity journal are now up to date.") (Commands::hydrate ()) + + http : AppModel -> string -> int -> string -> UpdateResult + http model id status data = match id + "accounts" => match status >= 200 && status < 300 + true => noCommand (loaded (Model::set (Model::set model "accounts" data) "accountsLoaded" "true")) + false => noCommand (failedLoad model "accountsLoaded") + "activity" => match status >= 200 && status < 300 + true => noCommand (loaded (Model::set (Model::set model "activity" data) "activityLoaded" "true")) + false => noCommand (failedLoad model "activityLoaded") + _ => mutation model id status data + + export dispatch : string -> UpdateResult + dispatch payload = + model = Model::decode (Json::getOr payload "model" "") + kind = Json::getOr payload "kind" "" + id = Json::getOr payload "id" "" + data = Json::getOr payload "data" "{}" + match kind + "click" => click model id + "input" => + inputModel = match id + "activity-search" => Model::set model "search" (Json::getOr payload "value" "") + _ => model + noCommand inputModel + "submit" => submit model id data + "http" => http model id (integer (Json::getOr payload "status" "0")) data + "location" => location model (Json::getOr payload "value" "#/overview") + _ => noCommand model diff --git a/examples/projects/modules/e2e/playwright.config.js b/examples/projects/modules/e2e/playwright.config.js index 8be474d3..a3b6641d 100644 --- a/examples/projects/modules/e2e/playwright.config.js +++ b/examples/projects/modules/e2e/playwright.config.js @@ -15,7 +15,7 @@ module.exports = defineConfig({ }, webServer: { command: - 'touch /tmp/talon_bank.hold && trap "rm -f /tmp/talon_bank.hold" EXIT && ../../../../target/release/osprey ../.. --run', + 'touch /tmp/talon_bank.hold && trap "rm -f /tmp/talon_bank.hold" EXIT && ../../../../target/release/osprey .. --run', cwd: __dirname, url: 'http://127.0.0.1:18790/api/accounts', reuseExistingServer: false, diff --git a/examples/projects/modules/e2e/tests/bank.spec.js b/examples/projects/modules/e2e/tests/bank.spec.js index 3508ab7e..5b4e66d8 100644 --- a/examples/projects/modules/e2e/tests/bank.spec.js +++ b/examples/projects/modules/e2e/tests/bank.spec.js @@ -1,139 +1,283 @@ -// End-to-end tests for Talon Bank: a real browser against the real compiled -// Osprey binary — server-driven HTML, the JSON API, domain refusals, the -// double-entry activity journal, and the architecture rule that the UI -// reflects exactly what the API serves. +// End-to-end coverage for the complete Talon Bank stack: native Osprey API, +// Osprey WebAssembly application, generic React renderer, and real Chromium. const { test, expect } = require('@playwright/test'); test.describe.configure({ mode: 'serial' }); -test.describe('JSON API over the data', () => { - test('lists the seeded accounts with machine and display money', async ({ request }) => { - const reply = await request.get('/api/accounts'); - expect(reply.status()).toBe(200); - const accounts = await reply.json(); - expect(accounts).toEqual([ - { id: 1, owner: 'Amelia Chen', cents: 246240, balance: '$2,462.40' }, - { id: 2, owner: 'Marcus Webb', cents: 191785, balance: '$1,917.85' }, - { id: 3, owner: 'Priya Sharma', cents: 360000, balance: '$3,600.00' }, - ]); - }); +const NEWEST_ACTIVITY = { + id: 7, + account: 2, + kind: 'refused', + cents: 999900, + note: 'vintage synthesizer', + owner: 'Marcus Webb', +}; - test('journals every movement, refusals included, newest first', async ({ request }) => { - const reply = await request.get('/api/activity'); - expect(reply.status()).toBe(200); - const feed = await reply.json(); - expect(feed).toHaveLength(7); - expect(feed[0]).toEqual({ - kind: 'refused', - cents: 999900, - note: 'vintage synthesizer', - owner: 'Marcus Webb', - }); - // The transfer is double-entry: one debit, one credit, same note. - const dinner = feed.filter((entry) => entry.note === 'dinner split'); - expect(dinner.map((entry) => entry.kind).sort()).toEqual(['credit', 'debit']); - }); +const MALFORMED_MUTATIONS = [ + ['/api/withdraw', { account: 1, cents: -5000 }, 'amount must be positive'], + ['/api/transfer', { from: 2, to: 999, cents: 5000 }, 'account not found'], + ['/api/transfer', { from: 2, to: 2, cents: 5000 }, 'accounts must be different'], + ['/api/accounts', {}, 'owner name required'], +]; - test('refuses an overdraft with 422 and a domain reason', async ({ request }) => { - const reply = await request.post('/api/withdraw', { - data: { account: 3, cents: 99999999, note: 'yacht' }, - }); - expect(reply.status()).toBe(422); - expect(await reply.json()).toEqual({ error: 'insufficient funds' }); - }); +async function openApp(page, hash = '') { + await page.goto(`/${hash}`); + await expect(page.locator('html')).toHaveAttribute('data-osprey-ready', 'true'); + await expect(page.locator('.loading-page')).toHaveCount(0); +} - test('refuses an unnamed account with 422', async ({ request }) => { - const reply = await request.post('/api/accounts', { data: {} }); - expect(reply.status()).toBe(422); - expect(await reply.json()).toEqual({ error: 'owner name required' }); - }); +async function accountById(request, id) { + const accounts = await (await request.get('/api/accounts')).json(); + return accounts.find((account) => account.id === id); +} - test('404s unknown endpoints', async ({ request }) => { - const reply = await request.get('/api/nope'); - expect(reply.status()).toBe(404); - }); -}); - -test.describe('server-driven web UI', () => { - test('renders tiles, accounts, and the activity feed from the API', async ({ page }) => { - await page.goto('/'); - await expect(page).toHaveTitle('Talon Bank'); - await expect(page.locator('h1')).toContainText('Talon Bank'); - - const tiles = page.locator('.tile'); - await expect(tiles).toHaveCount(3); - await expect(tiles.nth(0)).toContainText('$7,980.25'); - await expect(tiles.nth(1)).toContainText('3'); - - const rows = page.locator('tbody tr'); - await expect(rows).toHaveCount(3); - await expect(rows.nth(0)).toContainText('Amelia Chen'); - await expect(rows.nth(0)).toContainText('$2,462.40'); - await expect(rows.nth(2)).toContainText('Priya Sharma'); - - const refusal = page.locator('.feed li.refused', { hasText: 'vintage synthesizer' }); - await expect(refusal).toHaveCount(1); - await expect(refusal).toContainText('Marcus Webb'); - await expect(refusal).toContainText('$9,999.00'); - await expect(page.locator('footer')).toContainText('holds no database capability'); +function collectPageErrors(page) { + const errors = []; + page.on('pageerror', (error) => errors.push(error.message)); + page.on('console', (message) => { + if (message.type() === 'error') errors.push(message.text()); }); + return errors; +} - test('is styled, not a bare document', async ({ page }) => { - await page.goto('/'); - const bg = await page - .locator('body') - .evaluate((el) => getComputedStyle(el).backgroundColor); - expect(bg).toBe('rgb(11, 18, 32)'); - const money = await page - .locator('.money') - .first() - .evaluate((el) => getComputedStyle(el).color); - expect(money).toBe('rgb(125, 219, 163)'); - const refusedAmount = await page - .locator('.refused .amt') - .first() - .evaluate((el) => getComputedStyle(el).textDecorationLine); - expect(refusedAmount).toBe('line-through'); - await page.screenshot({ path: 'dashboard.png', fullPage: true }); - }); +async function expectPortfolioOverview(page) { + await expect(page).toHaveTitle('Talon Bank'); + await expect(page.locator('.hero-card')).toContainText('$7,980.25'); + await expect(page.locator('.account-card')).toHaveCount(3); + await expect(page.locator('.overview-page')).toContainText('Amelia Chen'); + await expect(page.locator('.overview-page')).toContainText('vintage synthesizer'); + await expect(page.locator('.sidebar')).toContainText('Talon Operations'); +} - test('mutations through the API appear on the next server-rendered page', async ({ - page, - request, - }) => { - const deposit = await request.post('/api/deposit', { - data: { account: 3, cents: 25, note: 'browser e2e top-up' }, - }); - expect(deposit.status()).toBe(200); - await page.goto('/'); - await expect(page.locator('tbody tr').nth(2)).toContainText('$3,600.25'); - await expect(page.locator('.feed li').first()).toContainText('browser e2e top-up'); - }); +async function expectHealthyBridge(page, errors) { + const telemetry = await page.evaluate(() => window.__TALON_BRIDGE__); + expect(telemetry.ready).toBe(true); + expect(telemetry.renders).toBeGreaterThanOrEqual(3); + expect(telemetry.events).toBeGreaterThanOrEqual(2); + expect(telemetry.lastPayloadBytes).toBeGreaterThan(100); + expect(telemetry.lastDecodeMs).toBeLessThan(250); + expect(errors).toEqual([]); +} + +async function expectActivityDeepLinkAndFilters(page) { + await openApp(page, '#/activity'); + await expect(page.locator('.activity-page h1')).toHaveText('Activity'); + await page.locator('#activity-search').fill('vintage synthesizer'); + await expect(page.locator('.movement-row')).toHaveCount(1); + await expect(page.locator('.movement-row')).toContainText('Marcus Webb'); + await page.locator('#activity-search').fill(''); + await page.locator('#filter-refused').click(); + await expect(page.locator('.movement-row')).toHaveCount(2); + await expect(page.locator('.movement-row').first()).toContainText('API protected refusal'); +} + +async function expectBrowserHistory(page) { + await page.locator('#nav-accounts').click(); + await expect(page).toHaveURL(/#\/accounts$/); + await expect(page.locator('.accounts-page h1')).toHaveText('Client accounts'); + await page.locator('#nav-move').click(); + await expect(page).toHaveURL(/#\/move$/); + await page.goBack(); + await expect(page.locator('.accounts-page h1')).toHaveText('Client accounts'); +} + +async function expectSecurityPage(page) { + await page.locator('#nav-security').click(); + await expect(page.locator('.security-page h1')).toHaveText('Trust you can inspect'); + await expect(page.locator('#architecture')).toContainText('Osprey Web App'); +} + +async function depositThroughForm(page) { + await page.locator('#nav-move').click(); + await page.locator('#move-deposit').click(); + await page.locator('#deposit-account').selectOption('1'); + await page.locator('#deposit-amount').fill('12.34'); + await page.locator('#deposit-note').fill('Wasm deposit flow'); + await page.locator('#submit-deposit button[type="submit"]').click(); + await expect(page.locator('.toast.success')).toContainText('Deposit complete'); +} + +async function transferThroughForm(page) { + await page.locator('#move-transfer').click(); + await page.locator('#transfer-from').selectOption('1'); + await page.locator('#transfer-to').selectOption('2'); + await page.locator('#transfer-amount').fill('10.00'); + await page.locator('#transfer-note').fill('Atomic browser transfer'); + await page.locator('#submit-transfer button[type="submit"]').click(); + await expect(page.locator('.toast.success')).toContainText('Transfer complete'); +} + +async function expectAtomicTransfer(request, accountOneBefore, accountTwoBefore) { + const accountOneAfter = await accountById(request, 1); + const accountTwoAfter = await accountById(request, 2); + expect(accountOneAfter.cents).toBe(accountOneBefore.cents + 234); + expect(accountTwoAfter.cents).toBe(accountTwoBefore.cents + 1000); + const feed = await (await request.get('/api/activity')).json(); + const entries = feed.filter((entry) => entry.note === 'Atomic browser transfer'); + expect(entries.map((entry) => entry.kind).sort()).toEqual(['credit', 'debit']); +} + +async function listsSeededAccounts({ request }) { + const reply = await request.get('/api/accounts'); + expect(reply.status()).toBe(200); + expect(await reply.json()).toEqual([ + { id: 1, owner: 'Amelia Chen', cents: 246240, balance: '$2,462.40' }, + { id: 2, owner: 'Marcus Webb', cents: 191785, balance: '$1,917.85' }, + { id: 3, owner: 'Priya Sharma', cents: 360000, balance: '$3,600.00' }, + ]); +} - test('unknown paths get the 404 page', async ({ page }) => { - const reply = await page.goto('/nowhere'); - expect(reply.status()).toBe(200); - await expect(page.locator('h1')).toHaveText('404'); +async function servesActivityJournal({ request }) { + const reply = await request.get('/api/activity'); + expect(reply.status()).toBe(200); + const feed = await reply.json(); + expect(feed).toHaveLength(7); + expect(feed[0]).toEqual(NEWEST_ACTIVITY); + const transfer = feed.filter((entry) => entry.note === 'dinner split'); + expect(transfer.map((entry) => entry.kind).sort()).toEqual(['credit', 'debit']); +} + +async function refusesOverdrafts({ request }) { + const reply = await request.post('/api/withdraw', { + data: { account: 3, cents: 99999999, note: 'API protected refusal' }, }); -}); - -// Runs last: it opens an account, mutating the shared server's state, so it -// must not precede the count-sensitive assertions above. -test.describe('typed JSON encoding', () => { - test('escapes quotes and backslashes so the response stays valid JSON', async ({ request }) => { - // Without the Json encoder's escaping (domain/json.ospml), an owner name - // containing a quote produces a malformed body and request.json() throws. - const tricky = 'Amelia "Mel" Chen \\ Co.'; - const created = await request.post('/api/accounts', { data: { name: tricky } }); - expect(created.status()).toBe(201); - expect((await created.json()).owner).toBe(tricky); - - const accounts = await (await request.get('/api/accounts')).json(); - expect(accounts.some((a) => a.owner === tricky)).toBe(true); - - // The dashboard re-parses that same JSON, so a broken escape would drop - // the row; the server-rendered page must still show the tricky name. - const page = await request.get('/'); - expect(await page.text()).toContain('Amelia "Mel" Chen'); + expect(reply.status()).toBe(422); + expect(await reply.json()).toEqual({ error: 'insufficient funds' }); + const feed = await (await request.get('/api/activity')).json(); + expect(feed[0]).toMatchObject({ + account: 3, + kind: 'refused', + note: 'API protected refusal', }); -}); +} + +async function rejectsMalformedMutations({ request }) { + const before = await (await request.get('/api/accounts')).json(); + for (const [path, data, error] of MALFORMED_MUTATIONS) { + const reply = await request.post(path, { data }); + expect(reply.status()).toBe(422); + expect(await reply.json()).toEqual({ error }); + } + expect(await (await request.get('/api/accounts')).json()).toEqual(before); +} + +async function servesAssetsAnd404s({ request }) { + const script = await request.get('/app.js'); + expect(script.status()).toBe(200); + expect(script.headers()['content-type']).toContain('application/javascript'); + expect((await script.body()).byteLength).toBeGreaterThan(10_000); + const styles = await request.get('/app.css'); + expect(styles.status()).toBe(200); + expect(styles.headers()['content-type']).toContain('text/css'); + expect((await styles.body()).byteLength).toBeGreaterThan(5_000); + expect((await request.get('/api/nope')).status()).toBe(404); + expect((await request.get('/nowhere')).status()).toBe(404); +} + +async function bootsPortfolioOverview({ page }) { + const errors = collectPageErrors(page); + await openApp(page); + await expectPortfolioOverview(page); + await expectHealthyBridge(page, errors); +} + +async function supportsNavigation({ page }) { + await expectActivityDeepLinkAndFilters(page); + await expectBrowserHistory(page); + await expectSecurityPage(page); +} + +async function opensAccountModal({ page, request }) { + await openApp(page); + await page.locator('.top-open').click(); + await expect(page.getByRole('dialog')).toBeVisible(); + await expect(page.locator('#new-owner')).toBeFocused(); + await page.locator('#new-owner').fill('Nora Okafor'); + await page.locator('#submit-open-account button[type="submit"]').click(); + await expect(page.locator('.toast.success')).toContainText('Account opened'); + const accounts = await (await request.get('/api/accounts')).json(); + const created = accounts.find((account) => account.owner === 'Nora Okafor'); + expect(created).toMatchObject({ cents: 0, balance: '$0.00' }); + await page.locator('#nav-accounts').click(); + await expect(page.locator(`#account-${created.id}`)).toContainText('Nora Okafor'); +} + +async function movesFundsAtomically({ page, request }) { + await openApp(page); + const accountOneBefore = await accountById(request, 1); + const accountTwoBefore = await accountById(request, 2); + await depositThroughForm(page); + await transferThroughForm(page); + await expectAtomicTransfer(request, accountOneBefore, accountTwoBefore); +} + +async function showsDomainRefusals({ page }) { + await openApp(page); + await page.locator('#nav-move').click(); + await page.locator('#move-withdraw').click(); + await page.locator('#withdraw-account').selectOption('3'); + await page.locator('#withdraw-amount').fill('999999.00'); + await page.locator('#withdraw-note').fill('Wasm protected refusal'); + await page.locator('#submit-withdraw button[type="submit"]').click(); + await expect(page.locator('.toast.error')).toContainText('Operation refused'); + await expect(page.locator('.toast.error')).toContainText('insufficient funds'); + await page.locator('#nav-activity').click(); + await page.locator('#filter-refused').click(); + await expect(page.locator('.activity-page')).toContainText('Wasm protected refusal'); +} + +async function rendersHostileTextSafely({ page, request }) { + const hostile = ' \\ Co.'; + const created = await request.post('/api/accounts', { data: { name: hostile } }); + expect(created.status()).toBe(201); + const account = await created.json(); + expect(account.owner).toBe(hostile); + await openApp(page, '#/accounts'); + await expect(page.locator(`#account-${account.id}`)).toContainText(hostile); + await expect(page.locator('img[src="x"]')).toHaveCount(0); + expect(await page.evaluate(() => window.__talonXss)).toBeUndefined(); +} + +async function supportsMobileLayout({ page }) { + await page.setViewportSize({ width: 390, height: 844 }); + await openApp(page); + const dimensions = await page.evaluate(() => ({ + viewport: document.documentElement.clientWidth, + content: document.documentElement.scrollWidth, + })); + expect(dimensions.content).toBeLessThanOrEqual(dimensions.viewport); + await page.locator('#toggle-menu').click(); + await expect(page.locator('.sidebar')).toHaveClass(/open/); + await page.locator('#nav-activity').click(); + await expect(page.locator('.activity-page h1')).toHaveText('Activity'); + await expect(page.locator('.sidebar')).not.toHaveClass(/open/); +} + +async function rendersStyled404({ page }) { + const reply = await page.goto('/nowhere'); + expect(reply.status()).toBe(404); + await expect(page.locator('h1')).toHaveText('That route has flown the coop.'); + await expect(page.locator('a')).toHaveAttribute('href', '/'); +} + +function protectedJsonApiSuite() { + test('lists seeded accounts with exact machine and display money', listsSeededAccounts); + test('serves a newest-first, double-entry activity journal', servesActivityJournal); + test('refuses overdrafts and journals the attempt', refusesOverdrafts); + test('rejects malformed mutations without changing balances', rejectsMalformedMutations); + test('serves real app assets and proper 404 statuses', servesAssetsAnd404s); +} + +function ospreyWebAssemblySuite() { + test('boots cleanly and renders the complete portfolio overview', bootsPortfolioOverview); + test('supports deep links, filtering, and browser history', supportsNavigation); + test('opens an account through an accessible focused modal', opensAccountModal); + test('deposits and atomically transfers funds through Osprey forms', movesFundsAtomically); + test('shows domain refusals and refreshes the audit view', showsDomainRefusals); + test('renders hostile account text without creating executable DOM', rendersHostileTextSafely); + test('collapses to a usable mobile app without horizontal overflow', supportsMobileLayout); + test('renders a styled 404 document for unknown native paths', rendersStyled404); +} + +test.describe('protected JSON API', protectedJsonApiSuite); +test.describe('Osprey WebAssembly application', ospreyWebAssemblySuite); diff --git a/examples/projects/modules/expectedoutput b/examples/projects/modules/expectedoutput index 0ed7b038..b76dda61 100644 --- a/examples/projects/modules/expectedoutput +++ b/examples/projects/modules/expectedoutput @@ -14,9 +14,9 @@ --- GET /api/accounts --- [{"id":1,"owner":"Amelia Chen","cents":246240,"balance":"$2,462.40"},{"id":2,"owner":"Marcus Webb","cents":191785,"balance":"$1,917.85"},{"id":3,"owner":"Priya Sharma","cents":360000,"balance":"$3,600.00"}] --- GET /api/activity --- -[{"kind":"refused","cents":999900,"note":"vintage synthesizer","owner":"Marcus Webb"},{"kind":"credit","cents":6240,"note":"dinner split","owner":"Amelia Chen"},{"kind":"debit","cents":6240,"note":"dinner split","owner":"Marcus Webb"},{"kind":"debit","cents":185000,"note":"rent — 12 Fern St","owner":"Amelia Chen"},{"kind":"credit","cents":360000,"note":"research grant Q1","owner":"Priya Sharma"},{"kind":"credit","cents":198025,"note":"freelance invoice #4021","owner":"Marcus Webb"},{"kind":"credit","cents":425000,"note":"March salary — Nimble Robotics","owner":"Amelia Chen"}] ---- GET / (server-driven ui) --- -html=true title=true vault=true feedRefusal=true +[{"id":7,"account":2,"kind":"refused","cents":999900,"note":"vintage synthesizer","owner":"Marcus Webb"},{"id":6,"account":1,"kind":"credit","cents":6240,"note":"dinner split","owner":"Amelia Chen"},{"id":5,"account":2,"kind":"debit","cents":6240,"note":"dinner split","owner":"Marcus Webb"},{"id":4,"account":1,"kind":"debit","cents":185000,"note":"rent — 12 Fern St","owner":"Amelia Chen"},{"id":3,"account":3,"kind":"credit","cents":360000,"note":"research grant Q1","owner":"Priya Sharma"},{"id":2,"account":2,"kind":"credit","cents":198025,"note":"freelance invoice #4021","owner":"Marcus Webb"},{"id":1,"account":1,"kind":"credit","cents":425000,"note":"March salary — Nimble Robotics","owner":"Amelia Chen"}] +--- GET / (Osprey wasm + React app) --- +html=true title=true appRoot=true client=true ┌────┬──────────────┬───────────┐ │ 1 │ Amelia Chen │ $2,462.40 │ │ 2 │ Marcus Webb │ $1,917.85 │ diff --git a/examples/projects/modules/src/api/routes.ospml b/examples/projects/modules/src/api/routes.ospml index d954cc96..5c6771ab 100644 --- a/examples/projects/modules/src/api/routes.ospml +++ b/examples/projects/modules/src/api/routes.ospml @@ -50,6 +50,9 @@ module Api load : int -> Account ! Ledger::Store load id = Account(id = id, owner = perform Ledger::Store.owner id, balance = perform Ledger::Store.balance id) + validAccount : int -> bool ! Ledger::Store + validAccount id = id > 0 && id <= perform Ledger::Store.count () + // Render accounts 1..count as a JSON array, recursively — no loops, no state. rows : int -> int -> string ! Ledger::Store rows id count = match id > count @@ -62,7 +65,7 @@ module Api onOpen : string -> HttpResponse ! [Ledger::Store, Audit] onOpen body = - name = field body "name" + name = trim (field body "name") match Accounts::namable name false => refuse "owner name required" true => @@ -77,42 +80,58 @@ module Api note = field body "note" match Accounts::movable cents false => refuse "amount must be positive" - true => - balance = perform Ledger::Store.credit id cents note - perform Audit.log "deposit ${Money::show cents} -> account #${id} (${note})" - json 200 (Accounts::json (load id)) + true => match validAccount id + false => refuse "account not found" + true => + balance = perform Ledger::Store.credit id cents note + perform Audit.log "deposit ${Money::show cents} -> account #${id} (${note})" + json 200 (Accounts::json (load id)) onWithdraw : string -> HttpResponse ! [Ledger::Store, Audit] onWithdraw body = id = num body "account" cents = num body "cents" note = field body "note" - attempt = perform Ledger::Store.debit id cents note - match attempt - Landed balance => - perform Audit.log "withdraw ${Money::show cents} from account #${id} (${note})" - json 200 (Accounts::json (load id)) - Refused why => - perform Audit.log "withdraw ${Money::show cents} from account #${id} REFUSED (${why})" - refuse why - - // A transfer COMPOSES the capability: debit then credit, atomically - // refused when funds are missing. Business flow lives here, not in SQL. + match Accounts::movable cents + false => refuse "amount must be positive" + true => match validAccount id + false => refuse "account not found" + true => + attempt = perform Ledger::Store.debit id cents note + match attempt + Landed balance => + perform Audit.log "withdraw ${Money::show cents} from account #${id} (${note})" + json 200 (Accounts::json (load id)) + Refused why => + perform Audit.log "withdraw ${Money::show cents} from account #${id} REFUSED (${why})" + refuse why + + // A transfer delegates one atomic domain operation to the storage + // capability after validating the public request at the API boundary. + transferReply : int -> int -> int -> string -> Outcome -> HttpResponse ! [Ledger::Store, Audit] + transferReply from to cents note attempt = match attempt + Refused why => + perform Audit.log "transfer ${Money::show cents} account #${from} -> account #${to} REFUSED (${why})" + refuse why + Landed balance => + perform Audit.log "transfer ${Money::show cents} account #${from} -> account #${to} (${note})" + json 200 (Json::arr (Accounts::json (load from) + "," + Accounts::json (load to))) + onTransfer : string -> HttpResponse ! [Ledger::Store, Audit] onTransfer body = from = num body "from" to = num body "to" cents = num body "cents" note = field body "note" - attempt = perform Ledger::Store.debit from cents note - match attempt - Refused why => - perform Audit.log "transfer ${Money::show cents} account #${from} -> account #${to} REFUSED (${why})" - refuse why - Landed balance => - landed = perform Ledger::Store.credit to cents note - perform Audit.log "transfer ${Money::show cents} account #${from} -> account #${to} (${note})" - json 200 (Json::arr (Accounts::json (load from) + "," + Accounts::json (load to))) + match Accounts::movable cents + false => refuse "amount must be positive" + true => match validAccount from && validAccount to + false => refuse "account not found" + true => match from == to + true => refuse "accounts must be different" + false => + attempt = perform Ledger::Store.transfer from to cents note + transferReply from to cents note attempt // The canonical JSON views, exported on their own so the web layer can // consume the API in-process without unwrapping HTTP envelopes. diff --git a/examples/projects/modules/src/domain/accounts.ospml b/examples/projects/modules/src/domain/accounts.ospml index aa196542..9a158bcb 100644 --- a/examples/projects/modules/src/domain/accounts.ospml +++ b/examples/projects/modules/src/domain/accounts.ospml @@ -26,7 +26,7 @@ type Outcome = module Accounts // Domain rule: an account must be opened with a non-empty owner name. export namable : string -> bool - namable owner = length owner > 0 + namable owner = length (trim owner) > 0 // Domain rule: money can only move in positive whole-cent amounts. export movable : int -> bool diff --git a/examples/projects/modules/src/domain/json.ospml b/examples/projects/modules/src/domain/json.ospml index 139aab86..f6ae91c3 100644 --- a/examples/projects/modules/src/domain/json.ospml +++ b/examples/projects/modules/src/domain/json.ospml @@ -13,11 +13,14 @@ namespace bank signature JsonApi + quote : string -> string strField : string -> string -> string numField : string -> int -> string + rawField : string -> string -> string obj : string -> string arr : string -> string error : string -> string + getOr : string -> string -> string -> string module Json : JsonApi // JSON string escaping: backslash first (so we never double-escape the @@ -35,18 +38,23 @@ module Json : JsonApi step = unwrap (replace s bslash (bslash + bslash)) unwrap (replace step quote (bslash + quote)) - quoted : string -> string - quoted s = + quote : string -> string + quote s = quote = "\"" quote + escape s + quote // `"key":"escaped value"` — a string-valued object member. strField : string -> string -> string - strField key value = quoted key + ":" + quoted value + strField key value = quote key + ":" + quote value // `"key":123` — a number-valued object member (integers need no escaping). numField : string -> int -> string - numField key value = quoted key + ":" + toString value + numField key value = quote key + ":" + toString value + + // An already-encoded JSON value. Kept explicit so callers cannot confuse + // protocol trees with ordinary escaped application strings. + rawField : string -> string -> string + rawField key value = quote key + ":" + value // Wrap a comma-joined member list into an object / array. Callers join the // members with `,`; these only add the braces so nesting stays composable. @@ -59,3 +67,14 @@ module Json : JsonApi // The one canonical error body shape, so every 4xx path is identical. error : string -> string error why = obj (strField "error" why) + + // Scalar-only projection used by the browser model boundary. Documents + // are always freed here, so consumers cannot accidentally retain handles. + getOr : string -> string -> string -> string + getOr source path fallback = + doc = jsonParse source + value = match jsonGet doc path + Success found => found + Error message => fallback + freed = jsonFree doc + value diff --git a/examples/projects/modules/src/main.ospml b/examples/projects/modules/src/main.ospml index cdec9bd5..73a3df6e 100644 --- a/examples/projects/modules/src/main.ospml +++ b/examples/projects/modules/src/main.ospml @@ -17,7 +17,7 @@ import "bank/web" as web // One deterministic tour of the whole stack, driven over REAL HTTP by the // in-process client: JSON mutations, a refused overdraft, the JSON listing, -// and the server-driven HTML dashboard. +// and the Osprey-WASM application shell. fetch : int -> string -> string fetch client path = reply = httpGetResponse client path "" @@ -45,7 +45,9 @@ drive client = print "--- GET /api/accounts ---\n${fetch client "/api/accounts"}" print "--- GET /api/activity ---\n${fetch client "/api/activity"}" page = fetch client "/" - print "--- GET / (server-driven ui) ---\nhtml=${startsWith page ""} title=${contains page "Talon Bank"} vault=${contains page "$7,980.25"} feedRefusal=${contains page "vintage synthesizer"}" + hasRoot = contains page "id=\"app\"" + hasClient = contains page "src=\"/app.js\"" + print "--- GET / (Osprey wasm + React app) ---\nhtml=${startsWith page ""} title=${contains page "Talon Bank"} appRoot=${hasRoot} client=${hasClient}" // Playwright hold: while /tmp/talon_bank.hold exists the server keeps serving // and the demo pauses right here — remove the file (or never create it) and @@ -69,6 +71,20 @@ table id count = match id > count print (Accounts::row account) table (id + 1) count +serve : Ptr -> int ! [Ledger::Store, Metrics::MetricsFx] +serve db = + server = httpCreateServer 18790 "127.0.0.1" + listening = httpListen server handleRequest + client = httpCreateClient "http://127.0.0.1:18790" 5000 + print "[boot] api + web listening on http://127.0.0.1:18790" + drive client + print "┌────┬──────────────┬───────────┐" + table 1 (perform Ledger::Store.count ()) + held = hold () + stopped = httpStopServer server + closed = Sqlite::shutdown db + perform Metrics::MetricsFx.total () + // Everything below runs inside the Metrics installer's handler region, so // the request counter cell exists exactly as long as the bank is serving. boot : Unit -> int ! Metrics::MetricsFx @@ -80,27 +96,17 @@ boot () = open name => Ledger::openSql db name credit id cents note => Ledger::creditSql db id cents note debit id cents note => Ledger::debitSql db id cents note + transfer fromId toId cents note => Ledger::transferSql db fromId toId cents note balance id => Ledger::balanceSql db id owner id => Ledger::ownerSql db id count => Ledger::countSql db activity => Ledger::activitySql db in handle Api::Audit log line => print "[audit] ${line}" - in - server = httpCreateServer 18790 "127.0.0.1" - listening = httpListen server handleRequest - client = httpCreateClient "http://127.0.0.1:18790" 5000 - print "[boot] api + web listening on http://127.0.0.1:18790" - drive client - print "┌────┬──────────────┬───────────┐" - table 1 (perform Ledger::Store.count ()) - held = hold () - stopped = httpStopServer server - closed = Sqlite::shutdown db - perform Metrics::MetricsFx.total () + in serve db // The router: every request is counted by the state module, then dispatched — -// `/api/*` to the JSON API, everything else to the server-driven web UI. +// `/api/*` to the JSON API, everything else to the browser-app host. handleRequest : string -> string -> string -> string -> HttpResponse handleRequest (method, path, headers, body) = seen = perform Metrics::MetricsFx.hit path diff --git a/examples/projects/modules/src/store/ledger.ospml b/examples/projects/modules/src/store/ledger.ospml index 1bb93660..f4c4db9c 100644 --- a/examples/projects/modules/src/store/ledger.ospml +++ b/examples/projects/modules/src/store/ledger.ospml @@ -28,6 +28,7 @@ module Ledger open : string => int credit : (int, int, string) => int debit : (int, int, string) => Outcome + transfer : (int, int, int, string) => Outcome balance : int => int owner : int => string count : Unit => int @@ -80,6 +81,26 @@ module Ledger done = Sqlite::run db "COMMIT" Landed(balance = balanceSql db id) + // Both sides of a transfer and their journal rows commit as one SQLite + // transaction. The API validates both account ids before invoking this + // capability, so a successful debit can never disappear into a missing + // destination account. [MODULES-TRANSFER-ATOMIC] + export transferSql : Ptr -> int -> int -> int -> string -> Outcome + transferSql db fromId toId cents note = + before = balanceSql db fromId + match before < cents + true => + entry = journal db fromId "refused" cents note + Refused(why = "insufficient funds") + false => + begun = Sqlite::run db "BEGIN IMMEDIATE" + debited = Sqlite::updateIntInt db "UPDATE accounts SET balance = balance - ? WHERE id = ?" cents fromId + credited = Sqlite::updateIntInt db "UPDATE accounts SET balance = balance + ? WHERE id = ?" cents toId + sent = journal db fromId "debit" cents note + received = journal db toId "credit" cents note + done = Sqlite::run db "COMMIT" + Landed(balance = balanceSql db fromId) + export balanceSql : Ptr -> int -> int balanceSql db id = Sqlite::queryInt db "SELECT balance FROM accounts WHERE id = ?" id @@ -97,16 +118,18 @@ module Ledger match stepped == 100 false => "" true => - kind = Sqlite::textAt cursor 0 - cents = Sqlite::intAt cursor 1 - note = Sqlite::textAt cursor 2 - who = Sqlite::textAt cursor 3 - entry = Json::obj (Json::strField "kind" kind + "," + Json::numField "cents" cents + "," + Json::strField "note" note + "," + Json::strField "owner" who) + id = Sqlite::intAt cursor 0 + account = Sqlite::intAt cursor 1 + kind = Sqlite::textAt cursor 2 + cents = Sqlite::intAt cursor 3 + note = Sqlite::textAt cursor 4 + who = Sqlite::textAt cursor 5 + entry = Json::obj (Json::numField "id" id + "," + Json::numField "account" account + "," + Json::strField "kind" kind + "," + Json::numField "cents" cents + "," + Json::strField "note" note + "," + Json::strField "owner" who) "${sep}${entry}${feedRows cursor ","}" export activitySql : Ptr -> string activitySql db = - cursor = Sqlite::query db "SELECT e.kind, e.cents, e.note, a.owner FROM entries e JOIN accounts a ON a.id = e.account ORDER BY e.id DESC LIMIT 8" + cursor = Sqlite::query db "SELECT e.id, e.account, e.kind, e.cents, e.note, a.owner FROM entries e JOIN accounts a ON a.id = e.account ORDER BY e.id DESC LIMIT 50" listing = feedRows cursor "" closed = Sqlite::closeQuery cursor "[${listing}]" diff --git a/examples/projects/modules/src/web/bundle.ospml b/examples/projects/modules/src/web/bundle.ospml new file mode 100644 index 00000000..26de519f --- /dev/null +++ b/examples/projects/modules/src/web/bundle.ospml @@ -0,0 +1,10 @@ +// Generated by examples/projects/modules/web/scripts/embed.mjs. Do not edit. +// React is the renderer; Osprey wasm owns model/update/view and emits one JSON tree per render. +namespace "bank/web" + +module Bundle + export style : Unit -> string + style () = "@layer reset,tokens,base,layout,components,utilities,responsive;@layer reset{*,*:before,*:after{box-sizing:border-box}html,body,#app{min-height:100%}html{background:#f5f6f2;color-scheme:light;font-synthesis:none;text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased}body,h1,h2,h3,h4,p,figure,blockquote,dl,dd{margin:0}body{min-width:320px}button,input,select,textarea{color:inherit;font:inherit}button,[role=button]{cursor:pointer}img,svg{display:block;max-width:100%}ul,ol{margin:0;padding:0;list-style:none}table{border-collapse:collapse;border-spacing:0}}@layer tokens{:root{--ink-950: #071a1c;--ink-900: #0a2426;--ink-850: #102e30;--ink-800: #17383a;--ink-700: #2d5051;--ink-600: #4f6d6c;--ink-500: #718987;--ink-400: #9aa9a5;--ink-300: #c5ceca;--ink-200: #dde3df;--ink-150: #e9ece8;--ink-100: #f2f4f0;--paper: #f7f7f2;--white: #ffffff;--coral: #ff6b4a;--coral-dark: #d94d31;--coral-soft: #fff0e9;--mint: #9ee2c3;--mint-dark: #1e795a;--mint-soft: #e5f8ef;--gold: #e4b654;--gold-soft: #fff7df;--red: #c83852;--red-soft: #fff0f2;--blue: #3d71a9;--blue-soft: #edf5ff;--sidebar-width: 252px;--topbar-height: 82px;--page-gutter: clamp(24px, 3.4vw, 58px);--radius-xs: 8px;--radius-sm: 12px;--radius: 18px;--radius-lg: 26px;--radius-xl: 34px;--shadow-sm: 0 1px 2px rgb(7 26 28 / 5%), 0 8px 24px rgb(7 26 28 / 5%);--shadow: 0 2px 4px rgb(7 26 28 / 4%), 0 20px 54px rgb(7 26 28 / 9%);--shadow-float: 0 28px 80px rgb(7 26 28 / 20%);--ease-out: cubic-bezier(.16, 1, .3, 1);--font-sans: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, \"Segoe UI\", sans-serif;--font-display: \"Avenir Next\", Avenir, var(--font-sans)}}@layer base{body{background:radial-gradient(circle at 76% 0%,rgb(158 226 195 / 19%),transparent 25rem),var(--paper);color:var(--ink-900);font-family:var(--font-sans);font-size:15px;line-height:1.5}::selection{background:var(--mint);color:var(--ink-950)}:focus-visible{outline:3px solid rgb(255 107 74 / 30%);outline-offset:2px}a{color:inherit;text-decoration:none}h1,h2,h3,h4{color:var(--ink-950);font-family:var(--font-display);font-weight:700;letter-spacing:-.035em;line-height:1.1}h1{font-size:clamp(2rem,4vw,3.65rem)}h2{font-size:clamp(1.35rem,2vw,1.9rem)}h3{font-size:1.08rem}button{border:0}}@layer utilities{.sr-only{position:absolute;width:1px;height:1px;overflow:hidden;clip:rect(0,0,0,0);clip-path:inset(50%);white-space:nowrap}.tone-positive,.positive{color:var(--mint-dark)}.tone-negative,.negative{color:var(--red)}.text-right{text-align:right}.nowrap{white-space:nowrap}.mobile-only{display:none}}@layer layout{.app-shell{display:grid;grid-template-columns:var(--sidebar-width) minmax(0,1fr);min-height:100vh}.sidebar{position:fixed;z-index:40;inset:0 auto 0 0;display:flex;width:var(--sidebar-width);flex-direction:column;overflow:hidden;padding:28px 20px 22px;background:radial-gradient(circle at 30% 110%,rgb(158 226 195 / 13%),transparent 22rem),linear-gradient(152deg,var(--ink-850),var(--ink-950) 76%);color:#ffffffb8}.sidebar:after{position:absolute;right:-68px;bottom:12%;width:150px;height:150px;border:1px solid rgb(255 255 255 / 6%);border-radius:50%;box-shadow:0 0 0 28px #ffffff06,0 0 0 62px #ffffff04;content:\"\";pointer-events:none}.brand{position:relative;z-index:1;display:flex;align-items:center;gap:12px;min-height:46px;padding:0 10px;color:var(--white)}.brand-mark,.logo-mark{display:grid;width:38px;height:38px;flex:0 0 auto;place-items:center;border-radius:12px;background:var(--coral);box-shadow:0 9px 24px #ff6b4a47;color:var(--white);font-family:var(--font-display);font-size:1.1rem;font-weight:800}.brand-copy,.brand-name{display:grid;font-family:var(--font-display);font-size:1rem;font-weight:700;letter-spacing:-.02em;line-height:1.15}.brand-copy small,.brand-subtitle{margin-top:4px;color:#ffffff6b;font-family:var(--font-sans);font-size:.66rem;font-weight:600;letter-spacing:.11em;text-transform:uppercase}.sidebar-nav,.nav{position:relative;z-index:1;display:grid;gap:6px;margin-top:54px}.nav-label{padding:0 13px 9px;color:#ffffff57;font-size:.66rem;font-weight:700;letter-spacing:.14em;text-transform:uppercase}.nav-item{position:relative;display:flex;width:100%;min-height:47px;align-items:center;gap:12px;border-radius:13px;padding:0 13px;background:transparent;color:#ffffff91;font-size:.88rem;font-weight:600;text-align:left;transition:color .18s ease,background .18s ease,transform .18s ease}.nav-item:hover{background:#ffffff0d;color:var(--white);transform:translate(2px)}.nav-item.active{background:#ffffff17;box-shadow:inset 0 0 0 1px #ffffff0d;color:var(--white)}.nav-item.active:before{position:absolute;left:-20px;width:4px;height:24px;border-radius:0 6px 6px 0;background:var(--coral);box-shadow:0 0 16px #ff6b4a99;content:\"\"}.nav-icon,.button-icon{display:grid;width:22px;flex:0 0 22px;place-items:center;font-size:1.03rem;line-height:1}.sidebar-footer,.profile-card{position:relative;z-index:1;display:flex;align-items:center;gap:10px;margin-top:auto;border:1px solid rgb(255 255 255 / 7%);border-radius:15px;padding:11px;background:#ffffff0a}.avatar{display:grid;width:36px;height:36px;flex:0 0 auto;place-items:center;border-radius:12px;background:var(--mint);color:var(--ink-950);font-size:.76rem;font-weight:800}.profile-copy{display:grid;min-width:0;color:var(--white);font-size:.78rem;font-weight:650}.profile-copy small{overflow:hidden;color:#ffffff61;font-size:.67rem;font-weight:500;text-overflow:ellipsis;white-space:nowrap}.page{grid-column:2;min-width:0;min-height:100vh}.topbar{position:sticky;z-index:30;top:0;display:flex;height:var(--topbar-height);align-items:center;justify-content:space-between;gap:22px;border-bottom:1px solid rgb(7 26 28 / 6%);padding:0 var(--page-gutter);background:#f7f7f2d6;backdrop-filter:blur(20px) saturate(130%)}.topbar-title{display:grid;gap:2px}.topbar-title strong{font-family:var(--font-display);font-size:1rem;letter-spacing:-.02em}.topbar-title span,.topbar-subtitle{color:var(--ink-500);font-size:.74rem}.topbar-actions{display:flex;align-items:center;gap:9px}.page-content,.content{width:min(100%,1560px);margin-inline:auto;padding:34px var(--page-gutter) 64px}.page-header{display:flex;align-items:end;justify-content:space-between;gap:24px;margin-bottom:28px}.page-header-copy{display:grid;gap:8px}.page-header p,.lede,.muted{color:var(--ink-500)}.section-grid,.dashboard-grid{display:grid;grid-template-columns:minmax(0,1.45fr) minmax(300px,.72fr);gap:20px;align-items:start}}@layer components{.eyebrow{color:var(--coral-dark);font-size:.68rem;font-weight:800;letter-spacing:.14em;text-transform:uppercase}.hero-card{position:relative;isolation:isolate;display:grid;min-height:220px;overflow:hidden;align-content:space-between;border-radius:var(--radius-xl);padding:clamp(26px,4vw,44px);background:radial-gradient(circle at 78% 32%,rgb(158 226 195 / 28%),transparent 13rem),linear-gradient(130deg,var(--ink-900),var(--ink-950));box-shadow:var(--shadow);color:var(--white)}.hero-card:before,.hero-card:after{position:absolute;z-index:-1;border:1px solid rgb(255 255 255 / 7%);border-radius:50%;content:\"\"}.hero-card:before{top:-110px;right:-50px;width:310px;height:310px}.hero-card:after{right:48px;bottom:-190px;width:370px;height:370px;box-shadow:0 0 0 42px #ffffff05}.hero-card h1,.hero-card h2,.hero-card h3{color:var(--white)}.hero-label{margin-bottom:9px;color:#ffffff7f;font-size:.7rem;font-weight:700;letter-spacing:.11em;text-transform:uppercase}.hero-value{font-family:var(--font-display);font-size:clamp(2.5rem,6vw,4.9rem);font-weight:700;letter-spacing:-.065em;line-height:.95}.hero-meta{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:18px;margin-top:34px;color:#fff9}.hero-actions,.card-actions,.button-row{display:flex;flex-wrap:wrap;align-items:center;gap:10px}.stat-grid,.tiles{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:16px;margin-block:20px}.stat,.stat-card,.tile{position:relative;overflow:hidden;border:1px solid rgb(7 26 28 / 7%);border-radius:var(--radius);padding:21px;background:#ffffffdb;box-shadow:var(--shadow-sm)}.stat:after,.stat-card:after,.tile:after{position:absolute;top:-24px;right:-24px;width:70px;height:70px;border-radius:50%;background:var(--mint-soft);content:\"\";opacity:.7}.stat-label,.tile span{position:relative;z-index:1;display:block;color:var(--ink-500);font-size:.68rem;font-weight:750;letter-spacing:.09em;text-transform:uppercase}.stat-value,.tile b{position:relative;z-index:1;display:block;margin-top:9px;color:var(--ink-950);font-family:var(--font-display);font-size:clamp(1.35rem,2.5vw,2rem);font-weight:720;letter-spacing:-.045em;line-height:1}.stat-detail{position:relative;z-index:1;margin-top:10px;color:var(--ink-500);font-size:.74rem}.card{border:1px solid rgb(7 26 28 / 7%);border-radius:var(--radius-lg);background:#ffffffe0;box-shadow:var(--shadow-sm)}.card-header{display:flex;min-height:76px;align-items:center;justify-content:space-between;gap:18px;border-bottom:1px solid var(--ink-150);padding:20px 24px}.card-header-copy{display:grid;gap:4px}.card-title{font-family:var(--font-display);font-size:1.05rem;font-weight:700;letter-spacing:-.025em}.card-subtitle{color:var(--ink-500);font-size:.74rem}.card-body{padding:24px}.account-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:16px}.account-card{position:relative;display:grid;min-height:190px;overflow:hidden;align-content:space-between;border:1px solid rgb(7 26 28 / 8%);border-radius:23px;padding:22px;background:var(--white);box-shadow:var(--shadow-sm);text-align:left;transition:transform .22s var(--ease-out),border-color .18s ease,box-shadow .22s ease}.account-card:after{position:absolute;top:-52px;right:-52px;width:130px;height:130px;border:18px solid var(--mint-soft);border-radius:50%;content:\"\";opacity:.8}.account-card:hover,.account-card.active,.account-card.selected{border-color:#1e795a47;box-shadow:0 20px 55px #071a1c1f;transform:translateY(-4px)}.account-card.active,.account-card.selected{background:linear-gradient(145deg,var(--white),var(--mint-soft))}.account-card-top{position:relative;z-index:1;display:flex;align-items:center;justify-content:space-between;gap:12px}.account-number,.account-type{color:var(--ink-500);font-size:.68rem;font-weight:750;letter-spacing:.08em;text-transform:uppercase}.account-balance{position:relative;z-index:1;font-family:var(--font-display);font-size:clamp(1.6rem,3vw,2.25rem);font-weight:700;letter-spacing:-.05em}.account-owner{position:relative;z-index:1;margin-top:5px;color:var(--ink-600);font-size:.8rem;font-weight:600}.activity-list,.feed{display:grid}.activity-item,.feed li{display:grid;grid-template-columns:42px minmax(0,1fr) auto;align-items:center;gap:14px;min-height:73px;border-bottom:1px solid var(--ink-150);padding:12px 0}.activity-item:last-child,.feed li:last-child{border-bottom:0}.activity-icon,.kind{display:grid;width:40px;height:40px;place-items:center;border-radius:13px;background:var(--mint-soft);color:var(--mint-dark);font-size:.86rem;font-weight:800}.debit .activity-icon,.debit .kind{background:var(--gold-soft);color:#96701e}.refused .activity-icon,.refused .kind{background:var(--red-soft);color:var(--red)}.activity-copy,.what{min-width:0}.activity-title,.what{overflow:hidden;color:var(--ink-900);font-size:.84rem;font-weight:650;text-overflow:ellipsis;white-space:nowrap}.activity-meta,.what small{display:block;margin-top:3px;overflow:hidden;color:var(--ink-500);font-size:.72rem;font-weight:500;text-overflow:ellipsis;white-space:nowrap}.activity-amount,.amt,.money{font-variant-numeric:tabular-nums;font-weight:720;letter-spacing:-.02em}.credit .activity-amount,.credit .amt,.money{color:var(--mint-dark)}.refused .activity-amount,.refused .amt{color:var(--red);text-decoration:line-through;text-decoration-thickness:1.5px}.table-wrap{overflow-x:auto}.data-table,table{width:100%;font-variant-numeric:tabular-nums}.data-table th,.data-table td,th,td{border-bottom:1px solid var(--ink-150);padding:15px 14px;text-align:left}.data-table th,th{color:var(--ink-500);font-size:.66rem;font-weight:750;letter-spacing:.09em;text-transform:uppercase}.data-table tbody tr,tbody tr{transition:background .16s ease}.data-table tbody tr:hover,tbody tr:hover{background:var(--ink-100)}.data-table tr:last-child td,tbody tr:last-child td{border-bottom:0}.num,.align-right{text-align:right}.badge,.status,.pill{display:inline-flex;min-height:25px;align-items:center;border-radius:999px;padding:4px 9px;background:var(--ink-100);color:var(--ink-600);font-size:.66rem;font-weight:750;letter-spacing:.035em}.status.success,.badge.success{background:var(--mint-soft);color:var(--mint-dark)}.status.warning,.badge.warning{background:var(--gold-soft);color:#896512}}@layer components{.btn,.button,.primary-button,.secondary-button,.icon-button{display:inline-flex;min-height:44px;align-items:center;justify-content:center;gap:9px;border:1px solid transparent;border-radius:13px;padding:0 17px;background:var(--ink-900);box-shadow:0 9px 22px #071a1c1f;color:var(--white);font-size:.78rem;font-weight:700;transition:transform .18s var(--ease-out),box-shadow .18s ease,background .18s ease,border-color .18s ease}.btn:hover,.button:hover,.primary-button:hover,.secondary-button:hover,.icon-button:hover{box-shadow:0 13px 28px #071a1c2e;transform:translateY(-2px)}.btn:active,.button:active,.primary-button:active,.secondary-button:active,.icon-button:active{transform:translateY(0)}.btn.primary,.button.primary,.primary-button{background:var(--coral);box-shadow:0 11px 24px #ff6b4a3b}.btn.primary:hover,.button.primary:hover,.primary-button:hover{background:#ff7657}.btn.secondary,.button.secondary,.secondary-button{border-color:var(--ink-200);background:var(--white);box-shadow:none;color:var(--ink-900)}.btn.ghost,.button.ghost,.icon-button{border-color:transparent;background:transparent;box-shadow:none;color:var(--ink-600)}.btn.danger,.button.danger{background:var(--red)}.btn:disabled,.button:disabled,button:disabled{cursor:not-allowed;opacity:.45;transform:none}.icon-button{width:43px;min-height:43px;padding:0;border-color:var(--ink-200);border-radius:13px;background:#ffffffc2}.menu-button{display:none}.chip-row,.filter-row,.tabs{display:flex;flex-wrap:wrap;align-items:center;gap:7px}.chip,.tab{display:inline-flex;min-height:35px;align-items:center;justify-content:center;gap:7px;border:1px solid var(--ink-200);border-radius:999px;padding:0 13px;background:transparent;color:var(--ink-600);font-size:.72rem;font-weight:700;transition:.16s ease}.chip:hover,.tab:hover,.chip.active,.tab.active{border-color:var(--ink-900);background:var(--ink-900);color:var(--white)}.search-box{position:relative;min-width:min(100%,260px)}.search-box .field-control{padding-left:42px}.search-icon{position:absolute;z-index:1;top:50%;left:15px;color:var(--ink-400);transform:translateY(-50%);pointer-events:none}.form-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:18px}.form-grid .full,.field.full,.form-actions{grid-column:1 / -1}.field{display:grid;gap:8px}.field-label{color:var(--ink-700);font-size:.71rem;font-weight:720;letter-spacing:.015em}.field-control{width:100%;height:48px;border:1px solid var(--ink-200);border-radius:13px;padding:0 14px;outline:none;background:var(--white);color:var(--ink-900);font-size:.83rem;transition:border-color .16s ease,box-shadow .16s ease,background .16s ease}textarea.field-control{min-height:104px;resize:vertical;padding-block:13px}.field-control::placeholder{color:var(--ink-400)}.field-control:hover{border-color:var(--ink-300)}.field-control:focus{border-color:var(--mint-dark);box-shadow:0 0 0 4px #1e795a1a}.form-actions{display:flex;align-items:center;justify-content:flex-end;gap:10px;margin-top:5px}.segmented{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:4px;border-radius:14px;padding:4px;background:var(--ink-100)}.segmented .chip{min-height:38px;border:0;border-radius:10px}.segmented .chip.active{background:var(--white);box-shadow:0 5px 15px #071a1c17;color:var(--ink-900)}.modal-backdrop{position:fixed;z-index:100;inset:0;display:grid;overflow-y:auto;place-items:center;padding:24px;background:#071a1c91;backdrop-filter:blur(10px);animation:fade-in .18s ease both}.modal{width:min(100%,590px);overflow:hidden;border:1px solid rgb(255 255 255 / 50%);border-radius:var(--radius-xl);background:var(--paper);box-shadow:var(--shadow-float);animation:modal-in .32s var(--ease-out) both}.modal-header{display:flex;align-items:start;justify-content:space-between;gap:20px;padding:28px 30px 22px}.modal-header-copy{display:grid;gap:7px}.modal-body{padding:0 30px 30px}.toast{position:fixed;z-index:120;right:24px;bottom:24px;display:grid;grid-template-columns:40px minmax(0,1fr) auto;width:min(calc(100vw - 32px),430px);align-items:center;gap:13px;border:1px solid rgb(255 255 255 / 11%);border-radius:18px;padding:15px;background:var(--ink-900);box-shadow:var(--shadow-float);color:var(--white);animation:toast-in .42s var(--ease-out) both}.toast.success{background:#155d48}.toast.error{background:#88273b}.toast-icon{display:grid;width:40px;height:40px;place-items:center;border-radius:12px;background:#ffffff1c;font-weight:800}.toast-copy{display:grid;gap:2px}.toast-copy strong{font-size:.8rem}.toast-copy span{color:#ffffffa1;font-size:.72rem}.empty-state{display:grid;min-height:250px;place-items:center;align-content:center;padding:40px;text-align:center}.empty-icon{display:grid;width:58px;height:58px;margin-bottom:17px;place-items:center;border-radius:19px;background:var(--mint-soft);color:var(--mint-dark);font-size:1.35rem}.empty-state p{max-width:390px;margin-top:8px;color:var(--ink-500);font-size:.79rem}.skeleton{overflow:hidden;border-radius:9px;background:var(--ink-150);color:transparent}.skeleton:after{display:block;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgb(255 255 255 / 65%),transparent);content:\"\";animation:shimmer 1.4s infinite;transform:translate(-100%)}.spinner{width:18px;height:18px;border:2px solid currentColor;border-right-color:transparent;border-radius:50%;animation:spin .65s linear infinite}.host-error{display:grid;width:min(620px,calc(100% - 40px));min-height:100vh;margin:auto;place-content:center;gap:16px}.host-error-mark{display:grid;width:52px;height:52px;place-items:center;border-radius:17px;background:var(--coral);color:var(--white);font-family:var(--font-display);font-size:1.25rem;font-weight:800}.host-error p:not(.eyebrow){color:var(--ink-500)}.host-error pre{overflow:auto;border-radius:var(--radius);padding:18px;background:var(--ink-950);color:var(--mint);font-size:.75rem;white-space:pre-wrap}.boot-screen,.not-found{display:grid;min-height:100vh;place-content:center;justify-items:center;gap:12px;padding:28px;text-align:center}.boot-mark{display:grid;width:58px;height:58px;margin-bottom:6px;place-items:center;border-radius:19px;background:var(--ink-900);box-shadow:var(--shadow);color:var(--mint);font:800 1.4rem var(--font-display);animation:boot-pulse 1.4s ease-in-out infinite}.boot-screen p{font:700 1.05rem var(--font-display)}.boot-screen>span{color:var(--ink-500);font-size:.7rem}.not-found>span{color:var(--coral);font:800 clamp(4rem,12vw,8rem)/1 var(--font-display);letter-spacing:-.08em}.not-found p{color:var(--ink-500)}.not-found a{margin-top:10px;border-radius:13px;padding:12px 17px;background:var(--ink-900);color:#fff;font-size:.75rem;font-weight:700}footer,.page-footer{color:var(--ink-400);font-size:.7rem}@keyframes modal-in{0%{opacity:0;transform:translateY(20px) scale(.97)}}@keyframes toast-in{0%{opacity:0;transform:translateY(18px) scale(.96)}}@keyframes fade-in{0%{opacity:0}}@keyframes shimmer{to{transform:translate(100%)}}@keyframes spin{to{transform:rotate(360deg)}}@keyframes boot-pulse{50%{box-shadow:0 0 0 10px #9ee2c31a,var(--shadow);transform:translateY(-3px)}}}@layer components{.app-main{grid-column:2;min-width:0}.main-nav{position:relative;z-index:1;display:grid;gap:5px;margin-top:48px}.nav-item .nav-label{padding:0;color:inherit;font-size:inherit;letter-spacing:normal;text-transform:none}.nav-section-label{padding:0 13px 8px;color:#ffffff52;font-size:.61rem;font-weight:800;letter-spacing:.15em}.nav-section-label.secondary{margin-top:25px}.sidebar-bottom{position:relative;z-index:1;display:grid;gap:12px;margin-top:auto}.secure-chip{display:flex;align-items:center;gap:8px;padding:9px 12px;border:1px solid rgb(158 226 195 / 12%);border-radius:11px;background:#9ee2c312;color:var(--mint);font-size:.66rem;font-weight:700}.sidebar-profile{display:grid;grid-template-columns:36px minmax(0,1fr) auto;align-items:center;gap:10px;padding:11px;border:1px solid rgb(255 255 255 / 7%);border-radius:15px;background:#ffffff0a}.sidebar-profile>span:nth-child(2){display:grid;min-width:0;color:#fff;font-size:.75rem}.sidebar-profile small{color:#ffffff61;font-size:.65rem}.profile-more{color:#ffffff4d;letter-spacing:.08em}.page{display:grid;gap:26px;animation:page-enter .36s var(--ease-out) both}.overview-page,.accounts-page,.activity-page,.move-page,.security-page,.loading-page{isolation:isolate}.page-heading,.section-heading{display:flex;align-items:end;justify-content:space-between;gap:20px}.page-heading>div,.section-heading>div{display:grid;gap:7px}.page-heading p{max-width:620px;color:var(--ink-500)}.section-block{display:grid;gap:17px}.section-block.card{gap:0;padding:4px 24px 12px}.section-block.card .section-heading{min-height:78px;border-bottom:1px solid var(--ink-150)}.text-button,.toast-close{display:inline-flex;align-items:center;gap:8px;padding:7px;background:transparent;color:var(--mint-dark);font-size:.73rem;font-weight:750}.icon-button .button-label,.toast-close .button-label{display:none}.ghost-on-dark{border:1px solid rgb(255 255 255 / 15%);background:#ffffff12;box-shadow:none}.notification-button{position:relative}.mobile-menu{display:none}.notification-dot{position:absolute;top:8px;right:8px;width:7px;height:7px;border:2px solid var(--paper);border-radius:50%;background:var(--coral)}.top-progress{position:fixed;z-index:80;top:var(--topbar-height);right:0;left:var(--sidebar-width);height:2px;overflow:hidden;background:#ff6b4a26}.top-progress:after{display:block;width:38%;height:100%;background:var(--coral);content:\"\";animation:progress .9s ease-in-out infinite}.hero-card{grid-template-columns:minmax(0,1fr) minmax(210px,.6fr);align-items:center}.hero-copy{position:relative;z-index:2;display:grid;justify-items:start}.hero-copy h1{margin-top:10px;color:#fff;font-size:clamp(2.7rem,5.4vw,4.8rem);letter-spacing:-.07em}.hero-copy>p{margin-top:10px;color:#ffffff85}.hero-copy .hero-actions{margin-top:28px}.hero-art{position:relative;min-height:165px}.hero-monogram{position:absolute;z-index:2;top:50%;left:50%;display:grid;width:90px;height:90px;place-items:center;border:1px solid rgb(255 255 255 / 20%);border-radius:29px;background:#ffffff1a;box-shadow:0 24px 45px #00000038;color:#fff;font-family:var(--font-display);font-size:2rem;font-weight:800;transform:translate(-50%,-50%) rotate(8deg);backdrop-filter:blur(10px)}.orb{position:absolute;border-radius:50%;filter:blur(.1px)}.orb-one{top:2px;right:4%;width:120px;height:120px;background:#9ee2c324}.orb-two{right:43%;bottom:-5px;width:76px;height:76px;background:#ff6b4a38}.stat-card{display:grid;grid-template-columns:45px minmax(0,1fr);align-items:center;gap:14px}.stat-icon{display:grid;width:44px;height:44px;place-items:center;border-radius:14px;background:var(--mint-soft);color:var(--mint-dark);font-size:1rem;font-weight:800}.stat-copy{position:relative;z-index:1;display:grid}.stat-copy small,.stat-copy em{color:var(--ink-500);font-size:.66rem;font-style:normal}.stat-copy strong{margin-block:3px;font-family:var(--font-display);font-size:1.45rem;letter-spacing:-.04em}.account-mark{display:grid;width:36px;height:36px;place-items:center;border-radius:12px;background:var(--mint-soft);color:var(--mint-dark);font-family:var(--font-display);font-weight:800}.account-mark.violet,.account-card.violet .account-mark{background:#f0edff;color:#6556ae}.account-card.deposit .account-mark{background:var(--mint-soft)}.account-card.withdraw .account-mark{background:var(--gold-soft);color:#92701e}.account-card>small{position:relative;z-index:1;color:var(--ink-500);font-size:.65rem}.account-more{color:var(--ink-400);letter-spacing:.08em}.account-grid-wide{grid-template-columns:repeat(3,minmax(0,1fr))}.account-detail-grid{display:grid;grid-template-columns:minmax(0,1.25fr) minmax(320px,.75fr);gap:20px;align-items:start}.account-detail{overflow:hidden;padding:28px}.detail-heading{display:flex;align-items:center;justify-content:space-between;gap:18px}.detail-heading>div{display:flex;align-items:center;gap:13px}.detail-heading small{color:var(--ink-500);font-size:.63rem}.status-pill{display:inline-flex;align-items:center;border-radius:999px;padding:6px 10px;background:var(--ink-100);color:var(--ink-600);font-size:.64rem;font-weight:750}.status-pill.success{background:var(--mint-soft);color:var(--mint-dark)}.detail-balance{display:grid;gap:4px;margin:32px -28px 24px;padding:28px;background:linear-gradient(110deg,var(--ink-100),transparent)}.detail-balance small,.detail-balance span{color:var(--ink-500);font-size:.71rem}.detail-balance strong{font:700 clamp(2rem,4vw,3.25rem)/1 var(--font-display);letter-spacing:-.06em}.detail-actions{display:flex;flex-wrap:wrap;gap:9px}.detail-facts{display:grid;grid-template-columns:repeat(3,1fr);gap:12px;margin-top:25px}.detail-facts>div{display:grid;gap:3px;padding:13px;border-radius:12px;background:var(--ink-100)}.detail-facts dt{color:var(--ink-500);font-size:.61rem}.detail-facts dd{font-size:.72rem;font-weight:700}.compact-activity{padding:8px 22px 12px}.compact-activity .section-heading{min-height:70px;border-bottom:1px solid var(--ink-150)}.movement-row{display:grid;grid-template-columns:42px minmax(0,1fr) auto;align-items:center;gap:14px;min-height:76px;border-bottom:1px solid var(--ink-150);padding:12px 0}.movement-row:last-child{border-bottom:0}.movement-icon{display:grid;width:40px;height:40px;place-items:center;border-radius:13px;background:var(--mint-soft);color:var(--mint-dark);font-weight:800}.movement-icon.debit{background:var(--gold-soft);color:#96701e}.movement-icon.refused{background:var(--red-soft);color:var(--red)}.movement-copy,.movement-meta{display:grid;min-width:0}.movement-copy strong{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.8rem}.movement-copy small,.movement-meta small{color:var(--ink-500);font-size:.67rem}.movement-meta{justify-items:end}.movement-amount{font-size:.79rem;font-variant-numeric:tabular-nums}.movement-amount.credit{color:var(--mint-dark)}.movement-amount.refused{color:var(--red);text-decoration:line-through}.mini-stat-grid{display:grid;grid-template-columns:repeat(4,1fr);gap:12px}.mini-stat{display:flex;align-items:center;gap:11px;border:1px solid var(--ink-150);border-radius:15px;padding:15px;background:#ffffffa8}.mini-stat>span{font-size:1rem}.mini-stat div{display:grid}.mini-stat small{color:var(--ink-500);font-size:.62rem}.mini-stat strong{font-size:1rem}.ledger-card{overflow:hidden;padding:0 24px 12px}.ledger-toolbar{display:flex;align-items:center;justify-content:space-between;gap:15px;min-height:82px;border-bottom:1px solid var(--ink-150)}.ledger-toolbar .search-box{flex:1;max-width:360px}.search-box>span{position:absolute;z-index:1;top:50%;left:14px;transform:translateY(-50%)}.search-box input{width:100%;height:44px;border:1px solid var(--ink-200);border-radius:13px;outline:none;padding:0 14px 0 39px;background:#fff;font-size:.76rem}.search-box input:focus{border-color:var(--mint-dark);box-shadow:0 0 0 4px #1e795a1a}.activity-list-full .movement-row{min-height:82px}.move-grid,.security-grid{display:grid;grid-template-columns:minmax(0,1.2fr) minmax(300px,.7fr);gap:20px;align-items:start}.move-tabs{width:min(100%,560px)}.form-card{padding:clamp(22px,3vw,34px)}.money-form,.modal-form{display:grid;gap:24px}.form-intro{display:flex;align-items:center;gap:14px}.form-intro>div{display:grid;gap:5px}.form-intro p{color:var(--ink-500);font-size:.75rem}.form-icon{display:grid;width:50px;height:50px;place-items:center;border-radius:16px;background:var(--mint-soft);color:var(--mint-dark);font-size:1.15rem}.form-icon.withdraw{background:var(--gold-soft);color:#8e6b18}.form-icon.transfer{background:#f0edff;color:#6556ae}.money-input{position:relative}.money-input>span{position:absolute;z-index:1;top:50%;left:15px;color:var(--ink-500);transform:translateY(-50%)}.money-input input{padding-left:30px;font-size:1rem;font-weight:700}.amount-field{min-width:0}.paired-fields{grid-column:1/-1;display:grid;grid-template-columns:1fr auto 1fr;align-items:end;gap:12px}.swap-mark{display:grid;width:36px;height:48px;place-items:center;color:var(--ink-400)}.submit-button{grid-column:1/-1;justify-self:end;min-width:160px}.guidance-card{overflow:hidden;padding:28px;background:linear-gradient(150deg,var(--ink-900),var(--ink-950));color:#ffffffad}.guidance-card h2{margin-top:8px;color:#fff}.tip-list{display:grid;gap:17px;margin-top:28px}.tip-list li{display:grid;grid-template-columns:35px 1fr;gap:11px}.tip-list li>span:last-child{display:grid}.tip-list small{color:#ffffff73;font-size:.67rem}.tip-icon{display:grid;width:34px;height:34px;place-items:center;border-radius:11px;background:#9ee2c31a;color:var(--mint)}.shield-seal{display:flex;align-items:center;gap:10px;margin-top:30px;padding-top:20px;border-top:1px solid rgb(255 255 255 / 8%);font-size:.69rem}.shield-seal strong{display:grid;width:30px;height:30px;place-items:center;border-radius:10px;background:var(--coral);color:#fff}.security-hero{display:grid;grid-template-columns:.55fr 1fr;align-items:center;min-height:285px;overflow:hidden;border-radius:var(--radius-xl);padding:32px;background:linear-gradient(135deg,var(--ink-950),var(--ink-850));color:#fff}.security-hero-copy{display:grid;justify-items:start;gap:13px}.security-hero-copy h2{color:#fff;font-size:clamp(1.8rem,3.4vw,3rem)}.security-hero-copy p{color:#ffffff87}.security-orbit{position:relative;min-height:210px}.security-orbit>strong{position:absolute;z-index:2;top:50%;left:50%;display:grid;width:66px;height:66px;place-items:center;border-radius:22px;background:var(--coral);font:800 1.6rem var(--font-display);transform:translate(-50%,-50%)}.orbit-ring{position:absolute;top:50%;left:50%;border:1px solid rgb(158 226 195 / 18%);border-radius:50%;transform:translate(-50%,-50%)}.ring-one{width:140px;height:140px}.ring-two{width:205px;height:205px}.security-card,.architecture-card{padding:26px}.security-list{display:grid;margin-top:18px}.security-control{display:grid;grid-template-columns:40px minmax(0,1fr) auto;align-items:center;gap:12px;border-bottom:1px solid var(--ink-150);padding:15px 0}.security-control:last-child{border:0}.security-icon{display:grid;width:39px;height:39px;place-items:center;border-radius:12px;background:var(--mint-soft);color:var(--mint-dark)}.security-copy{display:grid}.security-copy small{color:var(--ink-500);font-size:.65rem}.architecture-lead{margin-top:10px;color:var(--ink-500);font-size:.76rem}.architecture-stack{display:grid;gap:11px;margin-top:22px}.architecture-layer{display:grid;grid-template-columns:36px 1fr;gap:12px;padding:15px;border-radius:14px;background:var(--ink-100)}.layer-number{color:var(--coral-dark);font-size:.67rem;font-weight:800}.architecture-layer small{color:var(--ink-500);font-size:.57rem;letter-spacing:.08em}.architecture-layer h3{margin-block:3px;font-size:.85rem}.architecture-layer p{color:var(--ink-500);font-size:.65rem}.modal-form{padding:28px}.modal-heading{display:flex;align-items:start;justify-content:space-between;gap:18px}.modal-heading>div{display:grid;gap:6px}.modal-heading p{color:var(--ink-500);font-size:.74rem}.modal-reassurance{display:flex;gap:10px;border-radius:13px;padding:13px;background:var(--mint-soft);color:var(--mint-dark);font-size:.69rem}.modal-actions{display:flex;justify-content:flex-end;gap:9px}.toast-copy small{color:#ffffffa1;font-size:.7rem}.topbar-title small{color:var(--ink-500);font-size:.63rem;font-weight:700;letter-spacing:.06em}.skeleton-hero{height:230px;border-radius:var(--radius-xl)}.skeleton-grid{display:grid;grid-template-columns:repeat(3,1fr);gap:15px}.skeleton-grid .skeleton{height:105px}.skeleton-table{height:330px;border-radius:var(--radius-lg)}@keyframes page-enter{0%{opacity:0;transform:translateY(7px)}}@keyframes progress{0%{transform:translate(-110%)}to{transform:translate(280%)}}}@layer responsive{@media(max-width:860px){.app-main{grid-column:auto}.mobile-menu{display:inline-flex}.top-progress{left:0}.hero-card{grid-template-columns:1fr}.hero-art{position:absolute;right:15px;width:42%;opacity:.8}.account-detail-grid,.move-grid,.security-grid{grid-template-columns:1fr}.mini-stat-grid{grid-template-columns:repeat(2,1fr)}.ledger-toolbar{align-items:stretch;flex-direction:column;padding-block:16px}.ledger-toolbar .search-box{width:100%;max-width:none}}@media(max-width:620px){.page-heading,.section-heading{align-items:stretch;flex-direction:column}.account-grid-wide,.mini-stat-grid,.skeleton-grid,.detail-facts,.paired-fields{grid-template-columns:1fr}.swap-mark{width:100%;height:20px;transform:rotate(90deg)}.security-hero{grid-template-columns:1fr}.security-orbit{min-height:165px}.movement-row{grid-template-columns:38px minmax(0,1fr) auto;gap:9px}.modal-actions{align-items:stretch;flex-direction:column-reverse}.modal-actions .button{width:100%}}}@layer responsive{@media(max-width:1180px){:root{--sidebar-width: 222px}.account-grid{grid-template-columns:repeat(2,minmax(0,1fr))}.section-grid,.dashboard-grid{grid-template-columns:1fr}}@media(max-width:860px){:root{--topbar-height: 70px}.app-shell{display:block}.sidebar{width:min(82vw,300px);box-shadow:var(--shadow-float);transform:translate(-105%);transition:transform .28s var(--ease-out)}.app-shell.menu-open .sidebar,.sidebar.open{transform:translate(0)}.page{min-height:100vh}.menu-button,.mobile-only{display:inline-flex}.topbar{padding-inline:20px}.page-content,.content{padding:24px 20px 50px}.page-header{align-items:start}.hero-card{min-height:200px}.stat-grid,.tiles{grid-template-columns:repeat(2,minmax(0,1fr))}.stat-grid>:first-child:last-child,.stat-grid>:last-child:nth-child(odd),.tiles>:last-child:nth-child(odd){grid-column:1 / -1}}@media(max-width:620px){body{font-size:14px}.topbar-title span,.topbar-subtitle,.topbar-actions .button-label{display:none}.topbar-actions .btn,.topbar-actions .button{width:43px;padding:0}.page-header{display:grid;gap:18px}.page-header>.button,.page-header>.btn,.page-header-actions{width:100%}.page-header-actions .button,.page-header-actions .btn{flex:1}.hero-card{border-radius:25px;padding:26px 22px}.hero-value{font-size:2.7rem}.hero-meta{align-items:start;flex-direction:column}.stat-grid,.tiles,.account-grid,.form-grid{grid-template-columns:1fr}.stat-grid>:last-child:nth-child(odd),.tiles>:last-child:nth-child(odd){grid-column:auto}.card{border-radius:20px}.card-header,.card-body{padding-inline:18px}.card-header{align-items:start;flex-direction:column}.account-card{min-height:165px}.activity-item,.feed li{grid-template-columns:38px minmax(0,1fr) auto;gap:10px}.activity-icon,.kind{width:36px;height:36px}.modal-backdrop{align-items:end;padding:0}.modal{max-height:94vh;overflow-y:auto;border-radius:26px 26px 0 0}.modal-header,.modal-body{padding-inline:22px}.form-actions{align-items:stretch;flex-direction:column-reverse}.form-actions .btn,.form-actions .button{width:100%}.toast{right:16px;bottom:16px}.hide-mobile{display:none!important}}@media(prefers-reduced-motion:reduce){*,*:before,*:after{scroll-behavior:auto!important;animation-duration:.01ms!important;animation-iteration-count:1!important;transition-duration:.01ms!important}}}\n" + + export script : Unit -> string + script () = "(()=>{var Qs=Object.create;var Rf=Object.defineProperty;var js=Object.getOwnPropertyDescriptor;var Zs=Object.getOwnPropertyNames;var xs=Object.getPrototypeOf,Vs=Object.prototype.hasOwnProperty;var Tt=(l,t)=>()=>{try{return t||l((t={exports:{}}).exports,t),t.exports}catch(u){throw t=0,u}};var Ls=(l,t,u,a)=>{if(t&&typeof t==\"object\"||typeof t==\"function\")for(let e of Zs(t))!Vs.call(l,e)&&e!==u&&Rf(l,e,{get:()=>t[e],enumerable:!(a=js(t,e))||a.enumerable});return l};var Vn=(l,t,u)=>(u=l!=null?Qs(xs(l)):{},Ls(t||!l||!l.__esModule?Rf(u,\"default\",{value:l,enumerable:!0}):u,l));var Jf=Tt(p=>{\"use strict\";var Jn=Symbol.for(\"react.transitional.element\"),Ks=Symbol.for(\"react.portal\"),Js=Symbol.for(\"react.fragment\"),ws=Symbol.for(\"react.strict_mode\"),Ws=Symbol.for(\"react.profiler\"),$s=Symbol.for(\"react.consumer\"),Fs=Symbol.for(\"react.context\"),ks=Symbol.for(\"react.forward_ref\"),Is=Symbol.for(\"react.suspense\"),Ps=Symbol.for(\"react.memo\"),jf=Symbol.for(\"react.lazy\"),lm=Symbol.for(\"react.activity\"),Yf=Symbol.iterator;function tm(l){return l===null||typeof l!=\"object\"?null:(l=Yf&&l[Yf]||l[\"@@iterator\"],typeof l==\"function\"?l:null)}var Zf={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},xf=Object.assign,Vf={};function ru(l,t,u){this.props=l,this.context=t,this.refs=Vf,this.updater=u||Zf}ru.prototype.isReactComponent={};ru.prototype.setState=function(l,t){if(typeof l!=\"object\"&&typeof l!=\"function\"&&l!=null)throw Error(\"takes an object of state variables to update or a function which returns an object of state variables.\");this.updater.enqueueSetState(this,l,t,\"setState\")};ru.prototype.forceUpdate=function(l){this.updater.enqueueForceUpdate(this,l,\"forceUpdate\")};function Lf(){}Lf.prototype=ru.prototype;function wn(l,t,u){this.props=l,this.context=t,this.refs=Vf,this.updater=u||Zf}var Wn=wn.prototype=new Lf;Wn.constructor=wn;xf(Wn,ru.prototype);Wn.isPureReactComponent=!0;var Gf=Array.isArray;function Kn(){}var V={H:null,A:null,T:null,S:null},Kf=Object.prototype.hasOwnProperty;function $n(l,t,u){var a=u.ref;return{$$typeof:Jn,type:l,key:t,ref:a!==void 0?a:null,props:u}}function um(l,t){return $n(l.type,t,l.props)}function Fn(l){return typeof l==\"object\"&&l!==null&&l.$$typeof===Jn}function am(l){var t={\"=\":\"=0\",\":\":\"=2\"};return\"$\"+l.replace(/[=:]/g,function(u){return t[u]})}var Xf=/\\/+/g;function Ln(l,t){return typeof l==\"object\"&&l!==null&&l.key!=null?am(\"\"+l.key):t.toString(36)}function em(l){switch(l.status){case\"fulfilled\":return l.value;case\"rejected\":throw l.reason;default:switch(typeof l.status==\"string\"?l.then(Kn,Kn):(l.status=\"pending\",l.then(function(t){l.status===\"pending\"&&(l.status=\"fulfilled\",l.value=t)},function(t){l.status===\"pending\"&&(l.status=\"rejected\",l.reason=t)})),l.status){case\"fulfilled\":return l.value;case\"rejected\":throw l.reason}}throw l}function bu(l,t,u,a,e){var n=typeof l;(n===\"undefined\"||n===\"boolean\")&&(l=null);var i=!1;if(l===null)i=!0;else switch(n){case\"bigint\":case\"string\":case\"number\":i=!0;break;case\"object\":switch(l.$$typeof){case Jn:case Ks:i=!0;break;case jf:return i=l._init,bu(i(l._payload),t,u,a,e)}}if(i)return e=e(l),i=a===\"\"?\".\"+Ln(l,0):a,Gf(e)?(u=\"\",i!=null&&(u=i.replace(Xf,\"$&/\")+\"/\"),bu(e,t,u,\"\",function(s){return s})):e!=null&&(Fn(e)&&(e=um(e,u+(e.key==null||l&&l.key===e.key?\"\":(\"\"+e.key).replace(Xf,\"$&/\")+\"/\")+i)),t.push(e)),1;i=0;var c=a===\"\"?\".\":a+\":\";if(Gf(l))for(var f=0;f{\"use strict\";wf.exports=Jf()});var a0=Tt(w=>{\"use strict\";function li(l,t){var u=l.length;l.push(t);l:for(;0>>1,e=l[a];if(0>>1;ade(c,u))fde(s,c)?(l[a]=s,l[f]=u,a=f):(l[a]=c,l[i]=u,a=i);else if(fde(s,u))l[a]=s,l[f]=u,a=f;else break l}}return t}function de(l,t){var u=l.sortIndex-t.sortIndex;return u!==0?u:l.id-t.id}w.unstable_now=void 0;typeof performance==\"object\"&&typeof performance.now==\"function\"?(Wf=performance,w.unstable_now=function(){return Wf.now()}):(kn=Date,$f=kn.now(),w.unstable_now=function(){return kn.now()-$f});var Wf,kn,$f,tt=[],At=[],cm=1,ql=null,dl=3,ti=!1,sa=!1,ma=!1,ui=!1,If=typeof setTimeout==\"function\"?setTimeout:null,Pf=typeof clearTimeout==\"function\"?clearTimeout:null,Ff=typeof setImmediate<\"u\"?setImmediate:null;function ve(l){for(var t=Wl(At);t!==null;){if(t.callback===null)he(At);else if(t.startTime<=l)he(At),t.sortIndex=t.expirationTime,li(tt,t);else break;t=Wl(At)}}function ai(l){if(ma=!1,ve(l),!sa)if(Wl(tt)!==null)sa=!0,zu||(zu=!0,Eu());else{var t=Wl(At);t!==null&&ei(ai,t.startTime-l)}}var zu=!1,da=-1,l0=5,t0=-1;function u0(){return ui?!0:!(w.unstable_now()-t0l&&u0());){var a=ql.callback;if(typeof a==\"function\"){ql.callback=null,dl=ql.priorityLevel;var e=a(ql.expirationTime<=l);if(l=w.unstable_now(),typeof e==\"function\"){ql.callback=e,ve(l),t=!0;break t}ql===Wl(tt)&&he(tt),ve(l)}else he(tt);ql=Wl(tt)}if(ql!==null)t=!0;else{var n=Wl(At);n!==null&&ei(ai,n.startTime-l),t=!1}}break l}finally{ql=null,dl=u,ti=!1}t=void 0}}finally{t?Eu():zu=!1}}}var Eu;typeof Ff==\"function\"?Eu=function(){Ff(In)}:typeof MessageChannel<\"u\"?(Pn=new MessageChannel,kf=Pn.port2,Pn.port1.onmessage=In,Eu=function(){kf.postMessage(null)}):Eu=function(){If(In,0)};var Pn,kf;function ei(l,t){da=If(function(){l(w.unstable_now())},t)}w.unstable_IdlePriority=5;w.unstable_ImmediatePriority=1;w.unstable_LowPriority=4;w.unstable_NormalPriority=3;w.unstable_Profiling=null;w.unstable_UserBlockingPriority=2;w.unstable_cancelCallback=function(l){l.callback=null};w.unstable_forceFrameRate=function(l){0>l||125a?(l.sortIndex=u,li(At,l),Wl(tt)===null&&l===Wl(At)&&(ma?(Pf(da),da=-1):ma=!0,ei(ai,u-a))):(l.sortIndex=e,li(tt,l),sa||ti||(sa=!0,zu||(zu=!0,Eu()))),l};w.unstable_shouldYield=u0;w.unstable_wrapCallback=function(l){var t=dl;return function(){var u=dl;dl=t;try{return l.apply(this,arguments)}finally{dl=u}}}});var n0=Tt((zh,e0)=>{\"use strict\";e0.exports=a0()});var c0=Tt(hl=>{\"use strict\";var fm=oa();function i0(l){var t=\"https://react.dev/errors/\"+l;if(1{\"use strict\";function f0(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>\"u\"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!=\"function\"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(f0)}catch(l){console.error(l)}}f0(),y0.exports=c0()});var As=Tt(xn=>{\"use strict\";var el=n0(),Yy=oa(),sm=o0();function b(l){var t=\"https://react.dev/errors/\"+l;if(1Du||(l.current=Vi[Du],Vi[Du]=null,Du--)}function x(l,t){Du++,Vi[Du]=l.current,l.current=t}var Il=Pl(null),ja=Pl(null),Yt=Pl(null),Fe=Pl(null);function ke(l,t){switch(x(Yt,t),x(ja,l),x(Il,null),t.nodeType){case 9:case 11:l=(l=t.documentElement)&&(l=l.namespaceURI)?ry(l):0;break;default:if(l=t.tagName,t=t.namespaceURI)t=ry(t),l=ys(t,l);else switch(l){case\"svg\":l=1;break;case\"math\":l=2;break;default:l=0}}cl(Il),x(Il,l)}function Ju(){cl(Il),cl(ja),cl(Yt)}function Li(l){l.memoizedState!==null&&x(Fe,l);var t=Il.current,u=ys(t,l.type);t!==u&&(x(ja,l),x(Il,u))}function Ie(l){ja.current===l&&(cl(Il),cl(ja)),Fe.current===l&&(cl(Fe),ka._currentValue=au)}var ni,d0;function Pt(l){if(ni===void 0)try{throw Error()}catch(u){var t=u.stack.trim().match(/\\n( *(at )?)/);ni=t&&t[1]||\"\",d0=-1)\":-1e||f[a]!==s[e]){var h=\"\\n\"+f[a].replace(\" at new \",\" at \");return l.displayName&&h.includes(\"\")&&(h=h.replace(\"\",l.displayName)),h}while(1<=a&&0<=e);break}}}finally{ii=!1,Error.prepareStackTrace=u}return(u=l?l.displayName||l.name:\"\")?Pt(u):\"\"}function Sm(l,t){switch(l.tag){case 26:case 27:case 5:return Pt(l.type);case 16:return Pt(\"Lazy\");case 13:return l.child!==t&&t!==null?Pt(\"Suspense Fallback\"):Pt(\"Suspense\");case 19:return Pt(\"SuspenseList\");case 0:case 15:return ci(l.type,!1);case 11:return ci(l.type.render,!1);case 1:return ci(l.type,!0);case 31:return Pt(\"Activity\");default:return\"\"}}function v0(l){try{var t=\"\",u=null;do t+=Sm(l,u),u=l,l=l.return;while(l);return t}catch(a){return\"\\nError generating stack: \"+a.message+\"\\n\"+a.stack}}var Ki=Object.prototype.hasOwnProperty,Rc=el.unstable_scheduleCallback,fi=el.unstable_cancelCallback,gm=el.unstable_shouldYield,bm=el.unstable_requestPaint,Dl=el.unstable_now,rm=el.unstable_getCurrentPriorityLevel,Vy=el.unstable_ImmediatePriority,Ly=el.unstable_UserBlockingPriority,Pe=el.unstable_NormalPriority,Em=el.unstable_LowPriority,Ky=el.unstable_IdlePriority,zm=el.log,Tm=el.unstable_setDisableYieldValue,te=null,Ul=null;function Ht(l){if(typeof zm==\"function\"&&Tm(l),Ul&&typeof Ul.setStrictMode==\"function\")try{Ul.setStrictMode(te,l)}catch{}}var Nl=Math.clz32?Math.clz32:_m,Am=Math.log,pm=Math.LN2;function _m(l){return l>>>=0,l===0?32:31-(Am(l)/pm|0)|0}var be=256,re=262144,Ee=4194304;function lu(l){var t=l&42;if(t!==0)return t;switch(l&-l){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:return 64;case 128:return 128;case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:return l&261888;case 262144:case 524288:case 1048576:case 2097152:return l&3932160;case 4194304:case 8388608:case 16777216:case 33554432:return l&62914560;case 67108864:return 67108864;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 0;default:return l}}function On(l,t,u){var a=l.pendingLanes;if(a===0)return 0;var e=0,n=l.suspendedLanes,i=l.pingedLanes;l=l.warmLanes;var c=a&134217727;return c!==0?(a=c&~n,a!==0?e=lu(a):(i&=c,i!==0?e=lu(i):u||(u=c&~l,u!==0&&(e=lu(u))))):(c=a&~n,c!==0?e=lu(c):i!==0?e=lu(i):u||(u=a&~l,u!==0&&(e=lu(u)))),e===0?0:t!==0&&t!==e&&(t&n)===0&&(n=e&-e,u=t&-t,n>=u||n===32&&(u&4194048)!==0)?t:e}function ue(l,t){return(l.pendingLanes&~(l.suspendedLanes&~l.pingedLanes)&t)===0}function Om(l,t){switch(l){case 1:case 2:case 4:case 8:case 64:return t+250;case 16:case 32:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:return-1;case 67108864:case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function Jy(){var l=Ee;return Ee<<=1,(Ee&62914560)===0&&(Ee=4194304),l}function yi(l){for(var t=[],u=0;31>u;u++)t.push(l);return t}function ae(l,t){l.pendingLanes|=t,t!==268435456&&(l.suspendedLanes=0,l.pingedLanes=0,l.warmLanes=0)}function Mm(l,t,u,a,e,n){var i=l.pendingLanes;l.pendingLanes=u,l.suspendedLanes=0,l.pingedLanes=0,l.warmLanes=0,l.expiredLanes&=u,l.entangledLanes&=u,l.errorRecoveryDisabledLanes&=u,l.shellSuspendCounter=0;var c=l.entanglements,f=l.expirationTimes,s=l.hiddenUpdates;for(u=i&~u;0\"u\")return null;try{return l.activeElement||l.body}catch{return l.body}}var Bm=/[\\n\"\\\\]/g;function Ql(l){return l.replace(Bm,function(t){return\"\\\\\"+t.charCodeAt(0).toString(16)+\" \"})}function Wi(l,t,u,a,e,n,i,c){l.name=\"\",i!=null&&typeof i!=\"function\"&&typeof i!=\"symbol\"&&typeof i!=\"boolean\"?l.type=i:l.removeAttribute(\"type\"),t!=null?i===\"number\"?(t===0&&l.value===\"\"||l.value!=t)&&(l.value=\"\"+Yl(t)):l.value!==\"\"+Yl(t)&&(l.value=\"\"+Yl(t)):i!==\"submit\"&&i!==\"reset\"||l.removeAttribute(\"value\"),t!=null?$i(l,i,Yl(t)):u!=null?$i(l,i,Yl(u)):a!=null&&l.removeAttribute(\"value\"),e==null&&n!=null&&(l.defaultChecked=!!n),e!=null&&(l.checked=e&&typeof e!=\"function\"&&typeof e!=\"symbol\"),c!=null&&typeof c!=\"function\"&&typeof c!=\"symbol\"&&typeof c!=\"boolean\"?l.name=\"\"+Yl(c):l.removeAttribute(\"name\")}function to(l,t,u,a,e,n,i,c){if(n!=null&&typeof n!=\"function\"&&typeof n!=\"symbol\"&&typeof n!=\"boolean\"&&(l.type=n),t!=null||u!=null){if(!(n!==\"submit\"&&n!==\"reset\"||t!=null)){wi(l);return}u=u!=null?\"\"+Yl(u):\"\",t=t!=null?\"\"+Yl(t):u,c||t===l.value||(l.value=t),l.defaultValue=t}a=a??e,a=typeof a!=\"function\"&&typeof a!=\"symbol\"&&!!a,l.checked=c?l.checked:!!a,l.defaultChecked=!!a,i!=null&&typeof i!=\"function\"&&typeof i!=\"symbol\"&&typeof i!=\"boolean\"&&(l.name=i),wi(l)}function $i(l,t,u){t===\"number\"&&ln(l.ownerDocument)===l||l.defaultValue===\"\"+u||(l.defaultValue=\"\"+u)}function ju(l,t,u,a){if(l=l.options,t){t={};for(var e=0;e\"u\"||typeof window.document>\"u\"||typeof window.document.createElement>\"u\"),ki=!1;if(ht)try{Tu={},Object.defineProperty(Tu,\"passive\",{get:function(){ki=!0}}),window.addEventListener(\"test\",Tu,Tu),window.removeEventListener(\"test\",Tu,Tu)}catch{ki=!1}var Tu,Ct=null,Zc=null,Ge=null;function io(){if(Ge)return Ge;var l,t=Zc,u=t.length,a,e=\"value\"in Ct?Ct.value:Ct.textContent,n=e.length;for(l=0;l=Ma),_0=\" \",O0=!1;function fo(l,t){switch(l){case\"keyup\":return cd.indexOf(t.keyCode)!==-1;case\"keydown\":return t.keyCode!==229;case\"keypress\":case\"mousedown\":case\"focusout\":return!0;default:return!1}}function yo(l){return l=l.detail,typeof l==\"object\"&&\"data\"in l?l.data:null}var Hu=!1;function yd(l,t){switch(l){case\"compositionend\":return yo(t);case\"keypress\":return t.which!==32?null:(O0=!0,_0);case\"textInput\":return l=t.data,l===_0&&O0?null:l;default:return null}}function od(l,t){if(Hu)return l===\"compositionend\"||!Vc&&fo(l,t)?(l=io(),Ge=Zc=Ct=null,Hu=!1,l):null;switch(l){case\"paste\":return null;case\"keypress\":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1=t)return{node:u,offset:t-l};l=a}l:{for(;u;){if(u.nextSibling){u=u.nextSibling;break l}u=u.parentNode}u=void 0}u=N0(u)}}function vo(l,t){return l&&t?l===t?!0:l&&l.nodeType===3?!1:t&&t.nodeType===3?vo(l,t.parentNode):\"contains\"in l?l.contains(t):l.compareDocumentPosition?!!(l.compareDocumentPosition(t)&16):!1:!1}function ho(l){l=l!=null&&l.ownerDocument!=null&&l.ownerDocument.defaultView!=null?l.ownerDocument.defaultView:window;for(var t=ln(l.document);t instanceof l.HTMLIFrameElement;){try{var u=typeof t.contentWindow.location.href==\"string\"}catch{u=!1}if(u)l=t.contentWindow;else break;t=ln(l.document)}return t}function Lc(l){var t=l&&l.nodeName&&l.nodeName.toLowerCase();return t&&(t===\"input\"&&(l.type===\"text\"||l.type===\"search\"||l.type===\"tel\"||l.type===\"url\"||l.type===\"password\")||t===\"textarea\"||l.contentEditable===\"true\")}var bd=ht&&\"documentMode\"in document&&11>=document.documentMode,Cu=null,Ii=null,Ua=null,Pi=!1;function C0(l,t,u){var a=u.window===u?u.document:u.nodeType===9?u:u.ownerDocument;Pi||Cu==null||Cu!==ln(a)||(a=Cu,\"selectionStart\"in a&&Lc(a)?a={start:a.selectionStart,end:a.selectionEnd}:(a=(a.ownerDocument&&a.ownerDocument.defaultView||window).getSelection(),a={anchorNode:a.anchorNode,anchorOffset:a.anchorOffset,focusNode:a.focusNode,focusOffset:a.focusOffset}),Ua&&Va(Ua,a)||(Ua=a,a=rn(Ii,\"onSelect\"),0>=i,e-=i,$l=1<<32-Nl(t)+e|u<O?(U=E,E=null):U=E.sibling;var B=d(o,E,m[O],S);if(B===null){E===null&&(E=U);break}l&&E&&B.alternate===null&&t(o,E),y=n(B,y,O),C===null?z=B:C.sibling=B,C=B,E=U}if(O===m.length)return u(o,E),H&&ct(o,O),z;if(E===null){for(;OO?(U=E,E=null):U=E.sibling;var zt=d(o,E,B.value,S);if(zt===null){E===null&&(E=U);break}l&&E&&zt.alternate===null&&t(o,E),y=n(zt,y,O),C===null?z=zt:C.sibling=zt,C=zt,E=U}if(B.done)return u(o,E),H&&ct(o,O),z;if(E===null){for(;!B.done;O++,B=m.next())B=g(o,B.value,S),B!==null&&(y=n(B,y,O),C===null?z=B:C.sibling=B,C=B);return H&&ct(o,O),z}for(E=a(E);!B.done;O++,B=m.next())B=v(E,o,O,B.value,S),B!==null&&(l&&B.alternate!==null&&E.delete(B.key===null?O:B.key),y=n(B,y,O),C===null?z=B:C.sibling=B,C=B);return l&&E.forEach(function(Xs){return t(o,Xs)}),H&&ct(o,O),z}function X(o,y,m,S){if(typeof m==\"object\"&&m!==null&&m.type===Mu&&m.key===null&&(m=m.props.children),typeof m==\"object\"&&m!==null){switch(m.$$typeof){case ge:l:{for(var z=m.key;y!==null;){if(y.key===z){if(z=m.type,z===Mu){if(y.tag===7){u(o,y.sibling),S=e(y,m.props.children),S.return=o,o=S;break l}}else if(y.elementType===z||typeof z==\"object\"&&z!==null&&z.$$typeof===_t&&tu(z)===y.type){u(o,y.sibling),S=e(y,m.props),ga(S,m),S.return=o,o=S;break l}u(o,y);break}else t(o,y);y=y.sibling}m.type===Mu?(S=eu(m.props.children,o.mode,S,m.key),S.return=o,o=S):(S=Qe(m.type,m.key,m.props,null,o.mode,S),ga(S,m),S.return=o,o=S)}return i(o);case Ta:l:{for(z=m.key;y!==null;){if(y.key===z)if(y.tag===4&&y.stateNode.containerInfo===m.containerInfo&&y.stateNode.implementation===m.implementation){u(o,y.sibling),S=e(y,m.children||[]),S.return=o,o=S;break l}else{u(o,y);break}else t(o,y);y=y.sibling}S=gi(m,o.mode,S),S.return=o,o=S}return i(o);case _t:return m=tu(m),X(o,y,m,S)}if(Aa(m))return r(o,y,m,S);if(ha(m)){if(z=ha(m),typeof z!=\"function\")throw Error(b(150));return m=z.call(m),T(o,y,m,S)}if(typeof m.then==\"function\")return X(o,y,Oe(m),S);if(m.$$typeof===yt)return X(o,y,_e(o,m),S);Me(o,m)}return typeof m==\"string\"&&m!==\"\"||typeof m==\"number\"||typeof m==\"bigint\"?(m=\"\"+m,y!==null&&y.tag===6?(u(o,y.sibling),S=e(y,m),S.return=o,o=S):(u(o,y),S=Si(m,o.mode,S),S.return=o,o=S),i(o)):u(o,y)}return function(o,y,m,S){try{Ja=0;var z=X(o,y,m,S);return Vu=null,z}catch(E){if(E===ia||E===Cn)throw E;var C=Ol(29,E,null,o.mode);return C.lanes=S,C.return=o,C}}}var ou=No(!0),Ho=No(!1),Ot=!1;function Pc(l){l.updateQueue={baseState:l.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,lanes:0,hiddenCallbacks:null},callbacks:null}}function ic(l,t){l=l.updateQueue,t.updateQueue===l&&(t.updateQueue={baseState:l.baseState,firstBaseUpdate:l.firstBaseUpdate,lastBaseUpdate:l.lastBaseUpdate,shared:l.shared,callbacks:null})}function Xt(l){return{lane:l,tag:0,payload:null,callback:null,next:null}}function Qt(l,t,u){var a=l.updateQueue;if(a===null)return null;if(a=a.shared,(q&2)!==0){var e=a.pending;return e===null?t.next=t:(t.next=e.next,e.next=t),a.pending=t,t=un(l),To(l,null,u),t}return Hn(l,a,t,u),un(l)}function Ha(l,t,u){if(t=t.updateQueue,t!==null&&(t=t.shared,(u&4194048)!==0)){var a=t.lanes;a&=l.pendingLanes,u|=a,t.lanes=u,Wy(l,u)}}function ri(l,t){var u=l.updateQueue,a=l.alternate;if(a!==null&&(a=a.updateQueue,u===a)){var e=null,n=null;if(u=u.firstBaseUpdate,u!==null){do{var i={lane:u.lane,tag:u.tag,payload:u.payload,callback:null,next:null};n===null?e=n=i:n=n.next=i,u=u.next}while(u!==null);n===null?e=n=t:n=n.next=t}else e=n=t;u={baseState:a.baseState,firstBaseUpdate:e,lastBaseUpdate:n,shared:a.shared,callbacks:a.callbacks},l.updateQueue=u;return}l=u.lastBaseUpdate,l===null?u.firstBaseUpdate=t:l.next=t,u.lastBaseUpdate=t}var cc=!1;function Ca(){if(cc){var l=xu;if(l!==null)throw l}}function Ba(l,t,u,a){cc=!1;var e=l.updateQueue;Ot=!1;var n=e.firstBaseUpdate,i=e.lastBaseUpdate,c=e.shared.pending;if(c!==null){e.shared.pending=null;var f=c,s=f.next;f.next=null,i===null?n=s:i.next=s,i=f;var h=l.alternate;h!==null&&(h=h.updateQueue,c=h.lastBaseUpdate,c!==i&&(c===null?h.firstBaseUpdate=s:c.next=s,h.lastBaseUpdate=f))}if(n!==null){var g=e.baseState;i=0,h=s=f=null,c=n;do{var d=c.lane&-536870913,v=d!==c.lane;if(v?(N&d)===d:(a&d)===d){d!==0&&d===$u&&(cc=!0),h!==null&&(h=h.next={lane:0,tag:c.tag,payload:c.payload,callback:null,next:null});l:{var r=l,T=c;d=t;var X=u;switch(T.tag){case 1:if(r=T.payload,typeof r==\"function\"){g=r.call(X,g,d);break l}g=r;break l;case 3:r.flags=r.flags&-65537|128;case 0:if(r=T.payload,d=typeof r==\"function\"?r.call(X,g,d):r,d==null)break l;g=J({},g,d);break l;case 2:Ot=!0}}d=c.callback,d!==null&&(l.flags|=64,v&&(l.flags|=8192),v=e.callbacks,v===null?e.callbacks=[d]:v.push(d))}else v={lane:d,tag:c.tag,payload:c.payload,callback:c.callback,next:null},h===null?(s=h=v,f=g):h=h.next=v,i|=d;if(c=c.next,c===null){if(c=e.shared.pending,c===null)break;v=c,c=v.next,v.next=null,e.lastBaseUpdate=v,e.shared.pending=null}}while(!0);h===null&&(f=g),e.baseState=f,e.firstBaseUpdate=s,e.lastBaseUpdate=h,n===null&&(e.shared.lanes=0),Wt|=i,l.lanes=i,l.memoizedState=g}}function Co(l,t){if(typeof l!=\"function\")throw Error(b(191,l));l.call(t)}function Bo(l,t){var u=l.callbacks;if(u!==null)for(l.callbacks=null,l=0;ln?n:8;var i=A.T,c={};A.T=c,df(l,!1,t,u);try{var f=e(),s=A.S;if(s!==null&&s(c,f),f!==null&&typeof f==\"object\"&&typeof f.then==\"function\"){var h=Md(f,a);qa(l,t,h,Hl(l))}else qa(l,t,a,Hl(l))}catch(g){qa(l,t,{then:function(){},status:\"rejected\",reason:g},Hl())}finally{R.p=n,i!==null&&c.types!==null&&(i.types=c.types),A.T=i}}function Bd(){}function mc(l,t,u,a){if(l.tag!==5)throw Error(b(476));var e=e1(l).queue;a1(l,e,t,au,u===null?Bd:function(){return n1(l),u(a)})}function e1(l){var t=l.memoizedState;if(t!==null)return t;t={memoizedState:au,baseState:au,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:gt,lastRenderedState:au},next:null};var u={};return t.next={memoizedState:u,baseState:u,baseQueue:null,queue:{pending:null,lanes:0,dispatch:null,lastRenderedReducer:gt,lastRenderedState:u},next:null},l.memoizedState=t,l=l.alternate,l!==null&&(l.memoizedState=t),t}function n1(l){var t=e1(l);t.next===null&&(t=l.alternate.memoizedState),qa(l,t.next.queue,{},Hl())}function mf(){return sl(ka)}function i1(){return I().memoizedState}function c1(){return I().memoizedState}function qd(l){for(var t=l.return;t!==null;){switch(t.tag){case 24:case 3:var u=Hl();l=Xt(u);var a=Qt(t,l,u);a!==null&&(zl(a,t,u),Ha(a,t,u)),t={cache:Fc()},l.payload=t;return}t=t.return}}function Rd(l,t,u){var a=Hl();u={lane:a,revertLane:0,gesture:null,action:u,hasEagerState:!1,eagerState:null,next:null},Yn(l)?y1(t,u):(u=Jc(l,t,u,a),u!==null&&(zl(u,l,a),o1(u,t,a)))}function f1(l,t,u){var a=Hl();qa(l,t,u,a)}function qa(l,t,u,a){var e={lane:a,revertLane:0,gesture:null,action:u,hasEagerState:!1,eagerState:null,next:null};if(Yn(l))y1(t,e);else{var n=l.alternate;if(l.lanes===0&&(n===null||n.lanes===0)&&(n=t.lastRenderedReducer,n!==null))try{var i=t.lastRenderedState,c=n(i,u);if(e.hasEagerState=!0,e.eagerState=c,Cl(c,i))return Hn(l,t,e,0),Z===null&&Nn(),!1}catch{}if(u=Jc(l,t,e,a),u!==null)return zl(u,l,a),o1(u,t,a),!0}return!1}function df(l,t,u,a){if(a={lane:2,revertLane:Tf(),gesture:null,action:a,hasEagerState:!1,eagerState:null,next:null},Yn(l)){if(t)throw Error(b(479))}else t=Jc(l,u,a,2),t!==null&&zl(t,l,2)}function Yn(l){var t=l.alternate;return l===_||t!==null&&t===_}function y1(l,t){Lu=yn=!0;var u=l.pending;u===null?t.next=t:(t.next=u.next,u.next=t),l.pending=t}function o1(l,t,u){if((u&4194048)!==0){var a=t.lanes;a&=l.pendingLanes,u|=a,t.lanes=u,Wy(l,u)}}var Wa={readContext:sl,use:qn,useCallback:$,useContext:$,useEffect:$,useImperativeHandle:$,useLayoutEffect:$,useInsertionEffect:$,useMemo:$,useReducer:$,useRef:$,useState:$,useDebugValue:$,useDeferredValue:$,useTransition:$,useSyncExternalStore:$,useId:$,useHostTransitionStatus:$,useFormState:$,useActionState:$,useOptimistic:$,useMemoCache:$,useCacheRefresh:$};Wa.useEffectEvent=$;var s1={readContext:sl,use:qn,useCallback:function(l,t){return Sl().memoizedState=[l,t===void 0?null:t],l},useContext:sl,useEffect:w0,useImperativeHandle:function(l,t,u){u=u!=null?u.concat([l]):null,xe(4194308,4,Io.bind(null,t,l),u)},useLayoutEffect:function(l,t){return xe(4194308,4,l,t)},useInsertionEffect:function(l,t){xe(4,2,l,t)},useMemo:function(l,t){var u=Sl();t=t===void 0?null:t;var a=l();if(su){Ht(!0);try{l()}finally{Ht(!1)}}return u.memoizedState=[a,t],a},useReducer:function(l,t,u){var a=Sl();if(u!==void 0){var e=u(t);if(su){Ht(!0);try{u(t)}finally{Ht(!1)}}}else e=t;return a.memoizedState=a.baseState=e,l={pending:null,lanes:0,dispatch:null,lastRenderedReducer:l,lastRenderedState:e},a.queue=l,l=l.dispatch=Rd.bind(null,_,l),[a.memoizedState,l]},useRef:function(l){var t=Sl();return l={current:l},t.memoizedState=l},useState:function(l){l=oc(l);var t=l.queue,u=f1.bind(null,_,t);return t.dispatch=u,[l.memoizedState,u]},useDebugValue:of,useDeferredValue:function(l,t){var u=Sl();return sf(u,l,t)},useTransition:function(){var l=oc(!1);return l=a1.bind(null,_,l.queue,!0,!1),Sl().memoizedState=l,[!1,l]},useSyncExternalStore:function(l,t,u){var a=_,e=Sl();if(H){if(u===void 0)throw Error(b(407));u=u()}else{if(u=t(),Z===null)throw Error(b(349));(N&127)!==0||Xo(a,t,u)}e.memoizedState=u;var n={value:u,getSnapshot:t};return e.queue=n,w0(jo.bind(null,a,n,l),[l]),a.flags|=2048,ku(9,{destroy:void 0},Qo.bind(null,a,n,u,t),null),u},useId:function(){var l=Sl(),t=Z.identifierPrefix;if(H){var u=Fl,a=$l;u=(a&~(1<<32-Nl(a)-1)).toString(32)+u,t=\"_\"+t+\"R_\"+u,u=on++,0<\\/script>\",n=n.removeChild(n.firstChild);break;case\"select\":n=typeof a.is==\"string\"?i.createElement(\"select\",{is:a.is}):i.createElement(\"select\"),a.multiple?n.multiple=!0:a.size&&(n.size=a.size);break;default:n=typeof a.is==\"string\"?i.createElement(e,{is:a.is}):i.createElement(e)}}n[yl]=t,n[Tl]=a;l:for(i=t.child;i!==null;){if(i.tag===5||i.tag===6)n.appendChild(i.stateNode);else if(i.tag!==4&&i.tag!==27&&i.child!==null){i.child.return=i,i=i.child;continue}if(i===t)break l;for(;i.sibling===null;){if(i.return===null||i.return===t)break l;i=i.return}i.sibling.return=i.return,i=i.sibling}t.stateNode=n;l:switch(ml(n,e,a),e){case\"button\":case\"input\":case\"select\":case\"textarea\":a=!!a.autoFocus;break l;case\"img\":a=!0;break l;default:a=!1}a&&at(t)}}return L(t),Mi(t,t.type,l===null?null:l.memoizedProps,t.pendingProps,u),null;case 6:if(l&&t.stateNode!=null)l.memoizedProps!==a&&at(t);else{if(typeof a!=\"string\"&&t.stateNode===null)throw Error(b(166));if(l=Yt.current,Au(t)){if(l=t.stateNode,u=t.memoizedProps,a=null,e=ol,e!==null)switch(e.tag){case 27:case 5:a=e.memoizedProps}l[yl]=t,l=!!(l.nodeValue===u||a!==null&&a.suppressHydrationWarning===!0||fs(l.nodeValue,u)),l||Jt(t,!0)}else l=En(l).createTextNode(a),l[yl]=t,t.stateNode=l}return L(t),null;case 31:if(u=t.memoizedState,l===null||l.memoizedState!==null){if(a=Au(t),u!==null){if(l===null){if(!a)throw Error(b(318));if(l=t.memoizedState,l=l!==null?l.dehydrated:null,!l)throw Error(b(557));l[yl]=t}else fu(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;L(t),l=!1}else u=bi(),l!==null&&l.memoizedState!==null&&(l.memoizedState.hydrationErrors=u),l=!0;if(!l)return t.flags&256?(_l(t),t):(_l(t),null);if((t.flags&128)!==0)throw Error(b(558))}return L(t),null;case 13:if(a=t.memoizedState,l===null||l.memoizedState!==null&&l.memoizedState.dehydrated!==null){if(e=Au(t),a!==null&&a.dehydrated!==null){if(l===null){if(!e)throw Error(b(318));if(e=t.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(b(317));e[yl]=t}else fu(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;L(t),e=!1}else e=bi(),l!==null&&l.memoizedState!==null&&(l.memoizedState.hydrationErrors=e),e=!0;if(!e)return t.flags&256?(_l(t),t):(_l(t),null)}return _l(t),(t.flags&128)!==0?(t.lanes=u,t):(u=a!==null,l=l!==null&&l.memoizedState!==null,u&&(a=t.child,e=null,a.alternate!==null&&a.alternate.memoizedState!==null&&a.alternate.memoizedState.cachePool!==null&&(e=a.alternate.memoizedState.cachePool.pool),n=null,a.memoizedState!==null&&a.memoizedState.cachePool!==null&&(n=a.memoizedState.cachePool.pool),n!==e&&(a.flags|=2048)),u!==l&&u&&(t.child.flags|=8192),De(t,t.updateQueue),L(t),null);case 4:return Ju(),l===null&&Af(t.stateNode.containerInfo),L(t),null;case 10:return dt(t.type),L(t),null;case 19:if(cl(k),a=t.memoizedState,a===null)return L(t),null;if(e=(t.flags&128)!==0,n=a.rendering,n===null)if(e)ba(a,!1);else{if(F!==0||l!==null&&(l.flags&128)!==0)for(l=t.child;l!==null;){if(n=fn(l),n!==null){for(t.flags|=128,ba(a,!1),l=n.updateQueue,t.updateQueue=l,De(t,l),t.subtreeFlags=0,l=u,u=t.child;u!==null;)Ao(u,l),u=u.sibling;return x(k,k.current&1|2),H&&ct(t,a.treeForkCount),t.child}l=l.sibling}a.tail!==null&&Dl()>vn&&(t.flags|=128,e=!0,ba(a,!1),t.lanes=4194304)}else{if(!e)if(l=fn(n),l!==null){if(t.flags|=128,e=!0,l=l.updateQueue,t.updateQueue=l,De(t,l),ba(a,!0),a.tail===null&&a.tailMode===\"hidden\"&&!n.alternate&&!H)return L(t),null}else 2*Dl()-a.renderingStartTime>vn&&u!==536870912&&(t.flags|=128,e=!0,ba(a,!1),t.lanes=4194304);a.isBackwards?(n.sibling=t.child,t.child=n):(l=a.last,l!==null?l.sibling=n:t.child=n,a.last=n)}return a.tail!==null?(l=a.tail,a.rendering=l,a.tail=l.sibling,a.renderingStartTime=Dl(),l.sibling=null,u=k.current,x(k,e?u&1|2:u&1),H&&ct(t,a.treeForkCount),l):(L(t),null);case 22:case 23:return _l(t),lf(),a=t.memoizedState!==null,l!==null?l.memoizedState!==null!==a&&(t.flags|=8192):a&&(t.flags|=8192),a?(u&536870912)!==0&&(t.flags&128)===0&&(L(t),t.subtreeFlags&6&&(t.flags|=8192)):L(t),u=t.updateQueue,u!==null&&De(t,u.retryQueue),u=null,l!==null&&l.memoizedState!==null&&l.memoizedState.cachePool!==null&&(u=l.memoizedState.cachePool.pool),a=null,t.memoizedState!==null&&t.memoizedState.cachePool!==null&&(a=t.memoizedState.cachePool.pool),a!==u&&(t.flags|=2048),l!==null&&cl(nu),null;case 24:return u=null,l!==null&&(u=l.memoizedState.cache),t.memoizedState.cache!==u&&(t.flags|=2048),dt(tl),L(t),null;case 25:return null;case 30:return null}throw Error(b(156,t.tag))}function jd(l,t){switch($c(t),t.tag){case 1:return l=t.flags,l&65536?(t.flags=l&-65537|128,t):null;case 3:return dt(tl),Ju(),l=t.flags,(l&65536)!==0&&(l&128)===0?(t.flags=l&-65537|128,t):null;case 26:case 27:case 5:return Ie(t),null;case 31:if(t.memoizedState!==null){if(_l(t),t.alternate===null)throw Error(b(340));fu()}return l=t.flags,l&65536?(t.flags=l&-65537|128,t):null;case 13:if(_l(t),l=t.memoizedState,l!==null&&l.dehydrated!==null){if(t.alternate===null)throw Error(b(340));fu()}return l=t.flags,l&65536?(t.flags=l&-65537|128,t):null;case 19:return cl(k),null;case 4:return Ju(),null;case 10:return dt(t.type),null;case 22:case 23:return _l(t),lf(),l!==null&&cl(nu),l=t.flags,l&65536?(t.flags=l&-65537|128,t):null;case 24:return dt(tl),null;case 25:return null;default:return null}}function A1(l,t){switch($c(t),t.tag){case 3:dt(tl),Ju();break;case 26:case 27:case 5:Ie(t);break;case 4:Ju();break;case 31:t.memoizedState!==null&&_l(t);break;case 13:_l(t);break;case 19:cl(k);break;case 10:dt(t.type);break;case 22:case 23:_l(t),lf(),l!==null&&cl(nu);break;case 24:dt(tl)}}function fe(l,t){try{var u=t.updateQueue,a=u!==null?u.lastEffect:null;if(a!==null){var e=a.next;u=e;do{if((u.tag&l)===l){a=void 0;var n=u.create,i=u.inst;a=n(),i.destroy=a}u=u.next}while(u!==e)}}catch(c){G(t,t.return,c)}}function wt(l,t,u){try{var a=t.updateQueue,e=a!==null?a.lastEffect:null;if(e!==null){var n=e.next;a=n;do{if((a.tag&l)===l){var i=a.inst,c=i.destroy;if(c!==void 0){i.destroy=void 0,e=t;var f=u,s=c;try{s()}catch(h){G(e,f,h)}}}a=a.next}while(a!==n)}}catch(h){G(t,t.return,h)}}function p1(l){var t=l.updateQueue;if(t!==null){var u=l.stateNode;try{Bo(t,u)}catch(a){G(l,l.return,a)}}}function _1(l,t,u){u.props=mu(l.type,l.memoizedProps),u.state=l.memoizedState;try{u.componentWillUnmount()}catch(a){G(l,t,a)}}function Ra(l,t){try{var u=l.ref;if(u!==null){switch(l.tag){case 26:case 27:case 5:var a=l.stateNode;break;case 30:a=l.stateNode;break;default:a=l.stateNode}typeof u==\"function\"?l.refCleanup=u(a):u.current=a}}catch(e){G(l,t,e)}}function kl(l,t){var u=l.ref,a=l.refCleanup;if(u!==null)if(typeof a==\"function\")try{a()}catch(e){G(l,t,e)}finally{l.refCleanup=null,l=l.alternate,l!=null&&(l.refCleanup=null)}else if(typeof u==\"function\")try{u(null)}catch(e){G(l,t,e)}else u.current=null}function O1(l){var t=l.type,u=l.memoizedProps,a=l.stateNode;try{l:switch(t){case\"button\":case\"input\":case\"select\":case\"textarea\":u.autoFocus&&a.focus();break l;case\"img\":u.src?a.src=u.src:u.srcSet&&(a.srcset=u.srcSet)}}catch(e){G(l,l.return,e)}}function Di(l,t,u){try{var a=l.stateNode;iv(a,l.type,u,t),a[Tl]=t}catch(e){G(l,l.return,e)}}function M1(l){return l.tag===5||l.tag===3||l.tag===26||l.tag===27&&Ft(l.type)||l.tag===4}function Ui(l){l:for(;;){for(;l.sibling===null;){if(l.return===null||M1(l.return))return null;l=l.return}for(l.sibling.return=l.return,l=l.sibling;l.tag!==5&&l.tag!==6&&l.tag!==18;){if(l.tag===27&&Ft(l.type)||l.flags&2||l.child===null||l.tag===4)continue l;l.child.return=l,l=l.child}if(!(l.flags&2))return l.stateNode}}function gc(l,t,u){var a=l.tag;if(a===5||a===6)l=l.stateNode,t?(u.nodeType===9?u.body:u.nodeName===\"HTML\"?u.ownerDocument.body:u).insertBefore(l,t):(t=u.nodeType===9?u.body:u.nodeName===\"HTML\"?u.ownerDocument.body:u,t.appendChild(l),u=u._reactRootContainer,u!=null||t.onclick!==null||(t.onclick=ot));else if(a!==4&&(a===27&&Ft(l.type)&&(u=l.stateNode,t=null),l=l.child,l!==null))for(gc(l,t,u),l=l.sibling;l!==null;)gc(l,t,u),l=l.sibling}function dn(l,t,u){var a=l.tag;if(a===5||a===6)l=l.stateNode,t?u.insertBefore(l,t):u.appendChild(l);else if(a!==4&&(a===27&&Ft(l.type)&&(u=l.stateNode),l=l.child,l!==null))for(dn(l,t,u),l=l.sibling;l!==null;)dn(l,t,u),l=l.sibling}function D1(l){var t=l.stateNode,u=l.memoizedProps;try{for(var a=l.type,e=t.attributes;e.length;)t.removeAttributeNode(e[0]);ml(t,a,u),t[yl]=l,t[Tl]=u}catch(n){G(l,l.return,n)}}var ft=!1,ll=!1,Ni=!1,iy=typeof WeakSet==\"function\"?WeakSet:Set,nl=null;function Zd(l,t){if(l=l.containerInfo,pc=pn,l=ho(l),Lc(l)){if(\"selectionStart\"in l)var u={start:l.selectionStart,end:l.selectionEnd};else l:{u=(u=l.ownerDocument)&&u.defaultView||window;var a=u.getSelection&&u.getSelection();if(a&&a.rangeCount!==0){u=a.anchorNode;var e=a.anchorOffset,n=a.focusNode;a=a.focusOffset;try{u.nodeType,n.nodeType}catch{u=null;break l}var i=0,c=-1,f=-1,s=0,h=0,g=l,d=null;t:for(;;){for(var v;g!==u||e!==0&&g.nodeType!==3||(c=i+e),g!==n||a!==0&&g.nodeType!==3||(f=i+a),g.nodeType===3&&(i+=g.nodeValue.length),(v=g.firstChild)!==null;)d=g,g=v;for(;;){if(g===l)break t;if(d===u&&++s===e&&(c=i),d===n&&++h===a&&(f=i),(v=g.nextSibling)!==null)break;g=d,d=g.parentNode}g=v}u=c===-1||f===-1?null:{start:c,end:f}}else u=null}u=u||{start:0,end:0}}else u=null;for(_c={focusedElem:l,selectionRange:u},pn=!1,nl=t;nl!==null;)if(t=nl,l=t.child,(t.subtreeFlags&1028)!==0&&l!==null)l.return=t,nl=l;else for(;nl!==null;){switch(t=nl,n=t.alternate,l=t.flags,t.tag){case 0:if((l&4)!==0&&(l=t.updateQueue,l=l!==null?l.events:null,l!==null))for(u=0;u title\"))),ml(n,a,u),n[yl]=l,il(n),a=n;break l;case\"link\":var i=Dy(\"link\",\"href\",e).get(a+(u.href||\"\"));if(i){for(var c=0;cX&&(i=X,X=T,T=i);var o=H0(c,T),y=H0(c,X);if(o&&y&&(v.rangeCount!==1||v.anchorNode!==o.node||v.anchorOffset!==o.offset||v.focusNode!==y.node||v.focusOffset!==y.offset)){var m=g.createRange();m.setStart(o.node,o.offset),v.removeAllRanges(),T>X?(v.addRange(m),v.extend(y.node,y.offset)):(m.setEnd(y.node,y.offset),v.addRange(m))}}}}for(g=[],v=c;v=v.parentNode;)v.nodeType===1&&g.push({element:v,left:v.scrollLeft,top:v.scrollTop});for(typeof c.focus==\"function\"&&c.focus(),c=0;cu?32:u,A.T=null,u=Ec,Ec=null;var n=Zt,i=vt;if(al=0,Pu=Zt=null,vt=0,(q&6)!==0)throw Error(b(331));var c=q;if(q|=4,Q1(n.current),Y1(n,n.current,i,u),q=c,ye(0,!1),Ul&&typeof Ul.onPostCommitFiberRoot==\"function\")try{Ul.onPostCommitFiberRoot(te,n)}catch{}return!0}finally{R.p=e,A.T=a,ls(l,t)}}function oy(l,t,u){t=jl(u,t),t=vc(l.stateNode,t,2),l=Qt(l,t,2),l!==null&&(ae(l,2),lt(l))}function G(l,t,u){if(l.tag===3)oy(l,l,u);else for(;t!==null;){if(t.tag===3){oy(t,l,u);break}else if(t.tag===1){var a=t.stateNode;if(typeof t.type.getDerivedStateFromError==\"function\"||typeof a.componentDidCatch==\"function\"&&(jt===null||!jt.has(a))){l=jl(u,l),u=S1(2),a=Qt(t,u,2),a!==null&&(g1(u,a,t,l),ae(a,2),lt(a));break}}t=t.return}}function Ci(l,t,u){var a=l.pingCache;if(a===null){a=l.pingCache=new Ld;var e=new Set;a.set(t,e)}else e=a.get(t),e===void 0&&(e=new Set,a.set(t,e));e.has(u)||(rf=!0,e.add(u),l=$d.bind(null,l,t,u),t.then(l,l))}function $d(l,t,u){var a=l.pingCache;a!==null&&a.delete(t),l.pingedLanes|=l.suspendedLanes&u,l.warmLanes&=~u,Z===l&&(N&u)===u&&(F===4||F===3&&(N&62914560)===N&&300>Dl()-Gn?(q&2)===0&&la(l,0):Ef|=u,Iu===N&&(Iu=0)),lt(l)}function us(l,t){t===0&&(t=Jy()),l=Su(l,t),l!==null&&(ae(l,t),lt(l))}function Fd(l){var t=l.memoizedState,u=0;t!==null&&(u=t.retryLane),us(l,u)}function kd(l,t){var u=0;switch(l.tag){case 31:case 13:var a=l.stateNode,e=l.memoizedState;e!==null&&(u=e.retryLane);break;case 19:a=l.stateNode;break;case 22:a=l.stateNode._retryCache;break;default:throw Error(b(314))}a!==null&&a.delete(t),us(l,u)}function Id(l,t){return Rc(l,t)}var gn=null,Ou=null,Tc=!1,bn=!1,Bi=!1,Rt=0;function lt(l){l!==Ou&&l.next===null&&(Ou===null?gn=Ou=l:Ou=Ou.next=l),bn=!0,Tc||(Tc=!0,lv())}function ye(l,t){if(!Bi&&bn){Bi=!0;do for(var u=!1,a=gn;a!==null;){if(!t)if(l!==0){var e=a.pendingLanes;if(e===0)var n=0;else{var i=a.suspendedLanes,c=a.pingedLanes;n=(1<<31-Nl(42|l)+1)-1,n&=e&~(i&~c),n=n&201326741?n&201326741|1:n?n|2:0}n!==0&&(u=!0,sy(a,n))}else n=N,n=On(a,a===Z?n:0,a.cancelPendingCommit!==null||a.timeoutHandle!==-1),(n&3)===0||ue(a,n)||(u=!0,sy(a,n));a=a.next}while(u);Bi=!1}}function Pd(){as()}function as(){bn=Tc=!1;var l=0;Rt!==0&&fv()&&(l=Rt);for(var t=Dl(),u=null,a=gn;a!==null;){var e=a.next,n=es(a,t);n===0?(a.next=null,u===null?gn=e:u.next=e,e===null&&(Ou=u)):(u=a,(l!==0||(n&3)!==0)&&(bn=!0)),a=e}al!==0&&al!==5||ye(l,!1),Rt!==0&&(Rt=0)}function es(l,t){for(var u=l.suspendedLanes,a=l.pingedLanes,e=l.expirationTimes,n=l.pendingLanes&-62914561;0c)break;var h=f.transferSize,g=f.initiatorType;h&&by(g)&&(f=f.responseEnd,i+=h*(f\"u\"?null:document;function ds(l,t,u){var a=fa;if(a&&typeof t==\"string\"&&t){var e=Ql(t);e='link[rel=\"'+l+'\"][href=\"'+e+'\"]',typeof u==\"string\"&&(e+='[crossorigin=\"'+u+'\"]'),_y.has(e)||(_y.add(e),l={rel:l,crossOrigin:u,href:t},a.querySelector(e)===null&&(t=a.createElement(\"link\"),ml(t,\"link\",l),il(t),a.head.appendChild(t)))}}function gv(l){Et.D(l),ds(\"dns-prefetch\",l,null)}function bv(l,t){Et.C(l,t),ds(\"preconnect\",l,t)}function rv(l,t,u){Et.L(l,t,u);var a=fa;if(a&&l&&t){var e='link[rel=\"preload\"][as=\"'+Ql(t)+'\"]';t===\"image\"&&u&&u.imageSrcSet?(e+='[imagesrcset=\"'+Ql(u.imageSrcSet)+'\"]',typeof u.imageSizes==\"string\"&&(e+='[imagesizes=\"'+Ql(u.imageSizes)+'\"]')):e+='[href=\"'+Ql(l)+'\"]';var n=e;switch(t){case\"style\":n=ta(l);break;case\"script\":n=ya(l)}Ll.has(n)||(l=J({rel:\"preload\",href:t===\"image\"&&u&&u.imageSrcSet?void 0:l,as:t},u),Ll.set(n,l),a.querySelector(e)!==null||t===\"style\"&&a.querySelector(oe(n))||t===\"script\"&&a.querySelector(se(n))||(t=a.createElement(\"link\"),ml(t,\"link\",l),il(t),a.head.appendChild(t)))}}function Ev(l,t){Et.m(l,t);var u=fa;if(u&&l){var a=t&&typeof t.as==\"string\"?t.as:\"script\",e='link[rel=\"modulepreload\"][as=\"'+Ql(a)+'\"][href=\"'+Ql(l)+'\"]',n=e;switch(a){case\"audioworklet\":case\"paintworklet\":case\"serviceworker\":case\"sharedworker\":case\"worker\":case\"script\":n=ya(l)}if(!Ll.has(n)&&(l=J({rel:\"modulepreload\",href:l},t),Ll.set(n,l),u.querySelector(e)===null)){switch(a){case\"audioworklet\":case\"paintworklet\":case\"serviceworker\":case\"sharedworker\":case\"worker\":case\"script\":if(u.querySelector(se(n)))return}a=u.createElement(\"link\"),ml(a,\"link\",l),il(a),u.head.appendChild(a)}}}function zv(l,t,u){Et.S(l,t,u);var a=fa;if(a&&l){var e=Qu(a).hoistableStyles,n=ta(l);t=t||\"default\";var i=e.get(n);if(!i){var c={loading:0,preload:null};if(i=a.querySelector(oe(n)))c.loading=5;else{l=J({rel:\"stylesheet\",href:l,\"data-precedence\":t},u),(u=Ll.get(n))&&pf(l,u);var f=i=a.createElement(\"link\");il(f),ml(f,\"link\",l),f._p=new Promise(function(s,h){f.onload=s,f.onerror=h}),f.addEventListener(\"load\",function(){c.loading|=1}),f.addEventListener(\"error\",function(){c.loading|=2}),c.loading|=4,Je(i,t,a)}i={type:\"stylesheet\",instance:i,count:1,state:c},e.set(n,i)}}}function Tv(l,t){Et.X(l,t);var u=fa;if(u&&l){var a=Qu(u).hoistableScripts,e=ya(l),n=a.get(e);n||(n=u.querySelector(se(e)),n||(l=J({src:l,async:!0},t),(t=Ll.get(e))&&_f(l,t),n=u.createElement(\"script\"),il(n),ml(n,\"link\",l),u.head.appendChild(n)),n={type:\"script\",instance:n,count:1,state:null},a.set(e,n))}}function Av(l,t){Et.M(l,t);var u=fa;if(u&&l){var a=Qu(u).hoistableScripts,e=ya(l),n=a.get(e);n||(n=u.querySelector(se(e)),n||(l=J({src:l,async:!0,type:\"module\"},t),(t=Ll.get(e))&&_f(l,t),n=u.createElement(\"script\"),il(n),ml(n,\"link\",l),u.head.appendChild(n)),n={type:\"script\",instance:n,count:1,state:null},a.set(e,n))}}function Oy(l,t,u,a){var e=(e=Yt.current)?zn(e):null;if(!e)throw Error(b(446));switch(l){case\"meta\":case\"title\":return null;case\"style\":return typeof u.precedence==\"string\"&&typeof u.href==\"string\"?(t=ta(u.href),u=Qu(e).hoistableStyles,a=u.get(t),a||(a={type:\"style\",instance:null,count:0,state:null},u.set(t,a)),a):{type:\"void\",instance:null,count:0,state:null};case\"link\":if(u.rel===\"stylesheet\"&&typeof u.href==\"string\"&&typeof u.precedence==\"string\"){l=ta(u.href);var n=Qu(e).hoistableStyles,i=n.get(l);if(i||(e=e.ownerDocument||e,i={type:\"stylesheet\",instance:null,count:0,state:{loading:0,preload:null}},n.set(l,i),(n=e.querySelector(oe(l)))&&!n._p&&(i.instance=n,i.state.loading=5),Ll.has(l)||(u={rel:\"preload\",as:\"style\",href:u.href,crossOrigin:u.crossOrigin,integrity:u.integrity,media:u.media,hrefLang:u.hrefLang,referrerPolicy:u.referrerPolicy},Ll.set(l,u),n||pv(e,l,u,i.state))),t&&a===null)throw Error(b(528,\"\"));return i}if(t&&a!==null)throw Error(b(529,\"\"));return null;case\"script\":return t=u.async,u=u.src,typeof u==\"string\"&&t&&typeof t!=\"function\"&&typeof t!=\"symbol\"?(t=ya(u),u=Qu(e).hoistableScripts,a=u.get(t),a||(a={type:\"script\",instance:null,count:0,state:null},u.set(t,a)),a):{type:\"void\",instance:null,count:0,state:null};default:throw Error(b(444,l))}}function ta(l){return'href=\"'+Ql(l)+'\"'}function oe(l){return'link[rel=\"stylesheet\"]['+l+\"]\"}function vs(l){return J({},l,{\"data-precedence\":l.precedence,precedence:null})}function pv(l,t,u,a){l.querySelector('link[rel=\"preload\"][as=\"style\"]['+t+\"]\")?a.loading=1:(t=l.createElement(\"link\"),a.preload=t,t.addEventListener(\"load\",function(){return a.loading|=1}),t.addEventListener(\"error\",function(){return a.loading|=2}),ml(t,\"link\",u),il(t),l.head.appendChild(t))}function ya(l){return'[src=\"'+Ql(l)+'\"]'}function se(l){return\"script[async]\"+l}function My(l,t,u){if(t.count++,t.instance===null)switch(t.type){case\"style\":var a=l.querySelector('style[data-href~=\"'+Ql(u.href)+'\"]');if(a)return t.instance=a,il(a),a;var e=J({},u,{\"data-href\":u.href,\"data-precedence\":u.precedence,href:null,precedence:null});return a=(l.ownerDocument||l).createElement(\"style\"),il(a),ml(a,\"style\",e),Je(a,u.precedence,l),t.instance=a;case\"stylesheet\":e=ta(u.href);var n=l.querySelector(oe(e));if(n)return t.state.loading|=4,t.instance=n,il(n),n;a=vs(u),(e=Ll.get(e))&&pf(a,e),n=(l.ownerDocument||l).createElement(\"link\"),il(n);var i=n;return i._p=new Promise(function(c,f){i.onload=c,i.onerror=f}),ml(n,\"link\",a),t.state.loading|=4,Je(n,u.precedence,l),t.instance=n;case\"script\":return n=ya(u.src),(e=l.querySelector(se(n)))?(t.instance=e,il(e),e):(a=u,(e=Ll.get(n))&&(a=J({},u),_f(a,e)),l=l.ownerDocument||l,e=l.createElement(\"script\"),il(e),ml(e,\"link\",a),l.head.appendChild(e),t.instance=e);case\"void\":return null;default:throw Error(b(443,t.type))}else t.type===\"stylesheet\"&&(t.state.loading&4)===0&&(a=t.instance,t.state.loading|=4,Je(a,u.precedence,l));return t.instance}function Je(l,t,u){for(var a=u.querySelectorAll('link[rel=\"stylesheet\"][data-precedence],style[data-precedence]'),e=a.length?a[a.length-1]:null,n=e,i=0;i title\"):null)}function _v(l,t,u){if(u===1||t.itemProp!=null)return!1;switch(l){case\"meta\":case\"title\":return!0;case\"style\":if(typeof t.precedence!=\"string\"||typeof t.href!=\"string\"||t.href===\"\")break;return!0;case\"link\":if(typeof t.rel!=\"string\"||typeof t.href!=\"string\"||t.href===\"\"||t.onLoad||t.onError)break;return t.rel===\"stylesheet\"?(l=t.disabled,typeof t.precedence==\"string\"&&l==null):!0;case\"script\":if(t.async&&typeof t.async!=\"function\"&&typeof t.async!=\"symbol\"&&!t.onLoad&&!t.onError&&t.src&&typeof t.src==\"string\")return!0}return!1}function hs(l){return!(l.type===\"stylesheet\"&&(l.state.loading&3)===0)}function Ov(l,t,u,a){if(u.type===\"stylesheet\"&&(typeof a.media!=\"string\"||matchMedia(a.media).matches!==!1)&&(u.state.loading&4)===0){if(u.instance===null){var e=ta(a.href),n=t.querySelector(oe(e));if(n){t=n._p,t!==null&&typeof t==\"object\"&&typeof t.then==\"function\"&&(l.count++,l=Tn.bind(l),t.then(l,l)),u.state.loading|=4,u.instance=n,il(n);return}n=t.ownerDocument||t,a=vs(a),(e=Ll.get(e))&&pf(a,e),n=n.createElement(\"link\"),il(n);var i=n;i._p=new Promise(function(c,f){i.onload=c,i.onerror=f}),ml(n,\"link\",a),u.instance=n}l.stylesheets===null&&(l.stylesheets=new Map),l.stylesheets.set(u,t),(t=u.state.preload)&&(u.state.loading&3)===0&&(l.count++,u=Tn.bind(l),t.addEventListener(\"load\",u),t.addEventListener(\"error\",u))}}var Gi=0;function Mv(l,t){return l.stylesheets&&l.count===0&&We(l,l.stylesheets),0Gi?50:800)+t);return l.unsuspend=u,function(){l.unsuspend=null,clearTimeout(a),clearTimeout(e)}}:null}function Tn(){if(this.count--,this.count===0&&(this.imgCount===0||!this.waitingForImages)){if(this.stylesheets)We(this,this.stylesheets);else if(this.unsuspend){var l=this.unsuspend;this.unsuspend=null,l()}}}var An=null;function We(l,t){l.stylesheets=null,l.unsuspend!==null&&(l.count++,An=new Map,t.forEach(Dv,l),An=null,Tn.call(l))}function Dv(l,t){if(!(t.state.loading&4)){var u=An.get(l);if(u)var a=u.get(null);else{u=new Map,An.set(l,u);for(var e=l.querySelectorAll(\"link[data-precedence],style[data-precedence]\"),n=0;n{\"use strict\";function ps(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>\"u\"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!=\"function\"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(ps)}catch(l){console.error(l)}}ps(),_s.exports=As()});var kt=Vn(oa(),1),Gs=Vn(Os(),1);var Nf=Vn(oa(),1),Ms=new Set([\"blur\",\"change\",\"click\",\"doubleClick\",\"focus\",\"input\",\"keyDown\",\"keyUp\",\"pointerDown\",\"pointerUp\",\"submit\"]),Yv=new Set([\"area\",\"base\",\"br\",\"col\",\"embed\",\"hr\",\"img\",\"input\",\"link\",\"meta\",\"param\",\"source\",\"track\",\"wbr\"]),Gv=new Set([\"autoFocus\",\"checked\",\"disabled\",\"hidden\",\"multiple\",\"readOnly\",\"required\",\"selected\"]),Xv={class:\"className\",for:\"htmlFor\",tabindex:\"tabIndex\",readonly:\"readOnly\",maxlength:\"maxLength\",autocomplete:\"autoComplete\"};function Ds(l){return l===\"input\"?\"onChange\":l===\"doubleClick\"?\"onDoubleClick\":\"on\".concat(l.charAt(0).toUpperCase()).concat(l.slice(1))}function Qv(l,t){return l===\"style\"?Lv(t):Gv.has(l)&&(t===\"true\"||t===\"false\")?t===\"true\":t}function jv(l){let t={};for(let[u,a]of new FormData(l).entries()){let e=typeof File<\"u\"&&a instanceof File?a.name:a;Object.hasOwn(t,u)?t[u]=Array.isArray(t[u])?[...t[u],e]:[t[u],e]:t[u]=e}return JSON.stringify(t)}function Zv(l,t,u,a){return l===\"input\"||l===\"change\"?t?.type===\"checkbox\"||t?.type===\"radio\"?t.checked?\"true\":\"false\":t&&\"value\"in t?String(t.value):void 0:(l===\"keyDown\"||l===\"keyUp\")&&a.key?a.key:u.value===void 0?void 0:String(u.value)}function xv(l,t,u){let a=typeof HTMLAnchorElement<\"u\"&&t instanceof HTMLAnchorElement;l===\"click\"&&a&&u.preventDefault()}function Us(l,t,u,a){let e=a.currentTarget,n={kind:l};if(t&&(n.id=String(t)),l===\"submit\")return a.preventDefault(),n.data=jv(e),n;xv(l,e,a);let i=e?.name||u.name,c=Zv(l,e,u,a);return i&&(n.name=String(i)),c!==void 0&&(n.value=c),n}function Vv(l,t,u,a){l===\"click\"&&t.id===\"modal-backdrop\"&&u.target!==u.currentTarget||(u.stopPropagation?.(),a(Us(l,t.id,t,u)))}function Lv(l){return!l||typeof l!=\"string\"?l:Object.fromEntries(l.split(\";\").map(t=>t.split(\":\")).filter(([t,u])=>t?.trim()&&u!==void 0).map(([t,...u])=>[t.trim().replace(/-([a-z])/g,(a,e)=>e.toUpperCase()),u.join(\":\").trim()]))}function Kv(l){let t={};for(let[u,a]of Object.entries(l)){if(u===\"event\"||u===\"events\"||u===\"dangerouslySetInnerHTML\")continue;let n=Xv[u.toLowerCase()]??u;/^on[A-Z]/.test(n)||(t[n]=Qv(n,a))}return t}function Jv(l,t,u){let a=t.event;typeof a==\"string\"&&Ms.has(a)&&(l[Ds(a)]=e=>Vv(a,t,e,u))}function wv(l,t,u,a){return e=>{let n=Us(l,u.id,u,e);typeof t==\"string\"?n.id=t:t&&typeof t==\"object\"&&Object.assign(n,t),a(n)}}function Wv(l,t,u){if(t.events&&typeof t.events==\"object\")for(let[a,e]of Object.entries(t.events))Ms.has(a)&&(l[Ds(a)]=wv(a,e,t,u))}function $v(l,t){let u=Kv(l);return Jv(u,l,t),Wv(u,l,t),u}function Fv(l,t,u){let a=[];return l.text!==void 0&&l.text!==null&&l.text!==\"\"&&a.push(String(l.text)),Array.isArray(l.children)&&l.children.forEach((e,n)=>{a.push(Hf(e,t,\"\".concat(u,\".\").concat(n)))}),a}function Hf(l,t,u){if(l==null||l===!1)return null;if(typeof l==\"string\"||typeof l==\"number\")return String(l);if(Array.isArray(l))return l.map((i,c)=>Hf(i,t,\"\".concat(u,\".\").concat(c)));if(typeof l!=\"object\")return null;let a=typeof l.tag==\"string\"&&l.tag?l.tag:\"div\",e=l.props&&typeof l.props==\"object\"?l.props:{},n=$v(e,t);return n.key=l.key??e.key??u,Yv.has(a.toLowerCase())?Nf.default.createElement(a,n):Nf.default.createElement(a,n,...Fv(l,t,u))}function Ns(l,t){return Hf(l,t,\"root\")}function Hs(l){if(!l||typeof l!=\"object\"||Array.isArray(l))throw new Error(\"Osprey render message must be a JSON object\");return{model:typeof l.model==\"string\"?l.model:JSON.stringify(l.model??{}),view:l.view??null,commands:Array.isArray(l.commands)?l.commands:[]}}function Cs(l){return l?.kind??l?.type??\"\"}var kv=new TextDecoder(\"utf-8\");function Cf(l){if(!l.memory)throw new Error(\"WASI memory is not attached\");return new DataView(l.memory.buffer)}function qs(l){if(!l.memory)throw new Error(\"WASI memory is not attached\");return new Uint8Array(l.memory.buffer)}function Iv(l,t){l.pending&&(t(l.pending),l.pending=\"\")}function Pv(l,t,u,a,e,n){let i=Cf(l),c=0,f=\"\";for(let s=0;sPv(l,t,...u),proc_exit:()=>(t(),0),fd_close:()=>0,fd_seek:()=>0,fd_fdstat_get:()=>0,fd_fdstat_set_flags:()=>0}}function th(l){return{environ_sizes_get:(...t)=>Bs(l,...t),environ_get:()=>0,args_sizes_get:(...t)=>Bs(l,...t),args_get:()=>0,clock_time_get:(t,u,a)=>(Cf(l).setBigUint64(a,BigInt(Date.now())*1000000n,!0),0),random_get:(t,u)=>(globalThis.crypto.getRandomValues(qs(l).subarray(t,t+u)),0),sched_yield:()=>0,poll_oneoff:()=>52}}function uh(l){return new Proxy(l,{get(t,u){return t[u]??(()=>52)}})}function Rs(l=t=>console.debug(t.trimEnd())){let t={memory:null,pending:\"\"},u=()=>Iv(t,l),a={...lh(t,u),...th(t)};return{imports:uh(a),setMemory(e){t.memory=e},flush:u}}var ah=\"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\",eh=new TextDecoder(\"utf-8\"),nh=new TextEncoder;function ih(l){let t=l?.osprey_web_dispatch??l?.dispatch??l?.osprey_dispatch;if(typeof t!=\"function\")throw new Error(\"Osprey wasm must export osprey_web_dispatch\");return t}function ch(l,t){let u={...l,model:t};for(let[a,e]of Object.entries(u))e==null?delete u[a]:typeof e==\"object\"?u[a]=JSON.stringify(e):[\"string\",\"number\",\"boolean\"].includes(typeof e)||(u[a]=String(e));return u}function fh(l){let t=String(l.method||\"GET\").toUpperCase(),u={...l.headers??{}},a={method:t,headers:u};return!(l.body!==void 0&&l.body!==\"\")||t===\"GET\"||t===\"HEAD\"||(a.body=typeof l.body==\"string\"?l.body:JSON.stringify(l.body),Object.keys(u).some(i=>i.toLowerCase()===\"content-type\")||(u[\"Content-Type\"]=\"application/json\")),a}function Ys(l,t,u){return{kind:\"http\",id:String(l.id??\"\"),status:t,data:u}}function yh(l,t){return{wasi_snapshot_preview1:t.imports,osprey_web:{render:u=>l.renderPointer(u),command:u=>l.commandPointer(u)}}}function oh(l){if(typeof l._start==\"function\")l._start();else if(typeof l.main==\"function\")l.main();else throw new Error(\"Osprey wasm must export _start\")}function sh(){return{ready:!1,renders:0,events:0,lastPayloadBytes:0,lastDecodeMs:0}}function mh(l){if(!l||l.startsWith(\"__OSPREY_WASM_\"))throw new Error(\"The Osprey WebAssembly payload was not embedded\");let t=atob(l),u=new Uint8Array(t.length);for(let a=0;a{this.exports&&this.dispatch({kind:\"location\",value:window.location.hash})},window.addEventListener(\"popstate\",this.onPopState)}readCString(t){let u=Number(t);if(!this.memory||!Number.isSafeInteger(u)||u<=0)throw new Error(\"Invalid Osprey string pointer: \".concat(String(t)));let a=new Uint8Array(this.memory.buffer),e=u;for(;ethis.runCommands(a)),0}commitEnvelope(t){let u=Hs(t);this.model=u.model;let a=++this.renderSequence;this.root.render(Ns(u.view,e=>this.dispatch(e))),u.commands.length&&queueMicrotask(()=>{a<=this.renderSequence&&this.runCommands(u.commands)})}allocate(t){let u=this.exports?.osp_alloc??this.exports?.osprey_web_alloc??this.exports?.malloc??this.exports?.alloc;if(typeof u!=\"function\")throw new Error(\"Osprey wasm must export osp_alloc\");try{return Number(u(BigInt(t)))}catch(a){if(!(a instanceof TypeError))throw a;return Number(u(t))}}dispatch(t){if(!this.exports)return;let u=ih(this.exports),a=this.writeDispatch(t);this.acceptDispatchResult(u(a))}writeDispatch(t){let u=nh.encode(\"\".concat(JSON.stringify(ch(t,this.model)),\"\\0\"));this.bridge.events+=1,this.bridge.lastPayloadBytes=u.byteLength-1;let a=this.allocate(u.byteLength);return new Uint8Array(this.memory.buffer,a,u.byteLength).set(u),a}acceptDispatchResult(t){let u=Number(t??0);Number.isSafeInteger(u)&&u>0&&this.commitEnvelope(this.readJson(u))}async runHttp(t){try{let u=await fetch(t.url,fh(t)),a=await u.text();this.dispatch(Ys(t,u.status,a))}catch(u){this.dispatch(Ys(t,0,String(u?.message??u)))}}runFocus(t){requestAnimationFrame(()=>{document.getElementById(String(t.id??\"\"))?.focus({preventScroll:!1})})}runNavigate(t){let u=String(t.url??\"\");u&&(t.replace===!0||t.replace===\"true\"?window.history.replaceState(null,\"\",u):window.history.pushState(null,\"\",u))}runCommands(t){for(let u of t)if(!(!u||typeof u!=\"object\"))switch(Cs(u)){case\"http\":this.runHttp(u);break;case\"focus\":this.runFocus(u);break;case\"navigate\":this.runNavigate(u);break;default:console.warn(\"Unknown Osprey web command\",u)}}async start(t){let u=Rs(e=>console.debug(\"[osprey]\",e.trimEnd())),{instance:a}=await WebAssembly.instantiate(t,yh(this,u));return this.attachInstance(a,u),oh(a.exports),u.flush(),this.bridge.ready=!0,window.location.hash&&this.dispatch({kind:\"location\",value:window.location.hash}),this}attachInstance(t,u){if(this.exports=t.exports,this.memory=t.exports.memory,!(this.memory instanceof WebAssembly.Memory))throw new Error(\"Osprey wasm must export memory\");u.setMemory(this.memory)}};async function qf(){let l=new Bf(dh());window.__OSPREY_WEB__=l;try{await l.start(mh(ah)),document.documentElement.dataset.ospreyReady=\"true\"}catch(t){console.error(\"Osprey web host failed\",t),document.documentElement.dataset.ospreyReady=\"false\",l.root.render(kt.default.createElement(vh,{error:t}))}}document.readyState===\"loading\"?document.addEventListener(\"DOMContentLoaded\",()=>{qf()},{once:!0}):qf();})();\n" diff --git a/examples/projects/modules/src/web/pages.ospml b/examples/projects/modules/src/web/pages.ospml index 8750ff86..2dbfdec1 100644 --- a/examples/projects/modules/src/web/pages.ospml +++ b/examples/projects/modules/src/web/pages.ospml @@ -1,104 +1,34 @@ -// web/pages — the SERVER-DRIVEN UI. [MODULES-NAMESPACE] [MODULES-IMPORT] +// web/pages — the native Osprey host for the browser application. +// [MODULES-NAMESPACE] [MODULES-IMPORT] [WASM-REACT-HOST] // -// This layer lives in its own quoted namespace, `"bank/web"`, and its imports -// are the whole architecture story: it can see `bank::Api` (plus the pure -// `bank::Money` domain formatter) and nothing else. There is no Ledger -// import, no Sqlite import, no Store capability in scope — the UI CANNOT -// talk to the database, because the module system won't resolve a path to -// it. Every byte it renders comes from the same JSON the API serves to -// external clients, consumed in-process via `Api::accountsJson` / -// `Api::activityJson`. +// The browser app is written in Osprey and compiled to WebAssembly. React is +// its rendering capability: the wasm program emits a typed JSON element tree, +// the tiny JavaScript adapter reconciles it, and browser events return to the +// exported Osprey dispatcher. `Bundle` is generated by `web/npm run build` and +// embeds the minified adapter, React, stylesheet, and client wasm as text. +// +// This module deliberately imports no bank module. It can serve the compiled +// application but cannot resolve Ledger, Sqlite, or Store; browser data crosses +// the same `/api/*` boundary as every external client. namespace "bank/web" -import bank::Api -import bank::Money - module Pages - // The `headers` string is spliced verbatim into the wire response, so - // each header line must carry its own CRLF terminator. - html : string -> HttpResponse - html body = HttpResponse(status = 200, headers = "Content-Type: text/html; charset=utf-8\r\n", contentType = "text/html", streamFd = -1, isComplete = true, partialBody = body) - - // The design system, inlined: dark ledger-paper navy, osprey-gold accents, - // tabular numerals for money. One request, zero external assets. - style : Unit -> string - style () = "" - - // One per account, straight off the API's JSON — recursion over the - // parsed document, no mutation anywhere. - accountRows : int -> int -> string - accountRows doc i = - owner = jsonGet doc "[${i}].owner" - match owner - Error message => "" - Success value => - id = match jsonGet doc "[${i}].id" - Success n => n - Error nope => "?" - cash = match jsonGet doc "[${i}].balance" - Success money => money - Error nope => "?" - "#${id}${value}${cash}${accountRows doc (i + 1)}" - - // Accumulator recursion: the running sum rides the argument list, so the - // checked `+` auto-unwraps at the call site. - vault : int -> int -> int -> int - vault doc i acc = - cents = jsonGet doc "[${i}].cents" - match cents - Error message => acc - Success value => - held = match parseInt value - Success n => n - Error nope => 0 - vault doc (i + 1) (acc + held) - - mark : string -> string - mark kind = match kind - "credit" => "+" - "debit" => "–" - _ => "✕" + response status contentType body = + headers = "Content-Type: ${contentType}\r\nCache-Control: no-store\r\nX-Content-Type-Options: nosniff\r\n" + HttpResponse(status = status, headers = headers, contentType = contentType, streamFd = -1, isComplete = true, partialBody = body) - // One feed line per journal entry, newest first, styled by kind. - feedItems : int -> int -> string - feedItems doc i = - kind = jsonGet doc "[${i}].kind" - match kind - Error message => "" - Success value => - note = match jsonGet doc "[${i}].note" - Success text => text - Error nope => "?" - who = match jsonGet doc "[${i}].owner" - Success name => name - Error nope => "?" - cents = match jsonGet doc "[${i}].cents" - Success raw => match parseInt raw - Success n => n - Error bad => 0 - Error nope => 0 - "
  • ${mark value}${note}${who}${Money::show cents}
    • ${feedItems doc (i + 1)}" + html body = response 200 "text/html; charset=utf-8" body - tiles : int -> int -> string - tiles accountsDoc activityDoc = - held = vault accountsDoc 0 0 - "
    ${Money::show held}total on deposit
    ${jsonLength accountsDoc ""}accounts
    ${jsonLength activityDoc ""}journalled movements
    " + shell () = + "Talon Bank
    T

    Launching Talon Bank

    Osprey WebAssembly · React renderer
    " - // No effect row is spelled here: the checker infers that rendering needs - // whatever the Api views need. This file never names the storage - // capability — it genuinely does not know it exists. - dashboard () = - accounts = Api::accountsJson () - activity = Api::activityJson () - accountsDoc = jsonParse accounts - activityDoc = jsonParse activity - page = "Talon Bank${style ()}

    ◭ Talon Bank

    capability-checked banking, compiled by Osprey

    ${tiles accountsDoc activityDoc}

    Accounts

    ${accountRows accountsDoc 0}
    No.OwnerBalance

    Activity

      ${feedItems activityDoc 0}
    server-driven — rendered from /api/accounts + /api/activity, the UI holds no database capability
    " - freedAccounts = jsonFree accountsDoc - freedActivity = jsonFree activityDoc - html page + notFound () = + body = "Not found · Talon Bank
    404

    That route has flown the coop.

    The banking app is waiting back at the dashboard.

    Return to Talon Bank
    " + response 404 "text/html; charset=utf-8" body - export render : string -> HttpResponse - render path = match path - "/" => dashboard () - _ => html "

    404

    " + export render path = match path + "/" => html (shell ()) + "/app.css" => response 200 "text/css; charset=utf-8" (Bundle::style ()) + "/app.js" => response 200 "application/javascript; charset=utf-8" (Bundle::script ()) + _ => notFound () diff --git a/examples/projects/modules/web/.gitignore b/examples/projects/modules/web/.gitignore new file mode 100644 index 00000000..d93463d4 --- /dev/null +++ b/examples/projects/modules/web/.gitignore @@ -0,0 +1,3 @@ +node_modules/ +dist/ +build/ diff --git a/examples/projects/modules/web/README.md b/examples/projects/modules/web/README.md new file mode 100644 index 00000000..bda15959 --- /dev/null +++ b/examples/projects/modules/web/README.md @@ -0,0 +1,50 @@ +# Osprey React host + +This package is the deliberately small browser runtime for the Talon Bank +example. Osprey owns the application model, update function, view document and +effects. React only reconciles the JSON view document with the DOM; no React +component tree is hand-authored for the bank. + +`npm run build` performs the complete pipeline: + +1. bundles and minifies React, the host, and the design system with esbuild; +2. compiles `../client` to `build/talon-client.wasm` with the repository's + release Osprey compiler (override with `OSPREY_BIN`); +3. embeds the wasm bytes into the browser bundle as base64; and +4. generates `../src/web/bundle.ospml`, exporting zero-argument + `bank/web::Bundle::style()` and `bank/web::Bundle::script()` functions. They + return raw CSS and JavaScript for the server's `/app.css` and `/app.js` + routes; the assets contain no HTML wrapper tags. + +The esbuild target explicitly lowers JavaScript template literals because +`${...}` is Osprey's own interpolation syntax. The embed step rejects that +sequence as a guard against generating an ambiguous Osprey source file. + +Use `npm run build:host` while changing only JavaScript or CSS. Use +`OSPREY_WEB_WASM=/absolute/client.wasm npm run build -- --no-compile` to embed an +already compiled module. + +## Bridge protocol + +The wasm module exports `memory`, `_start`, `osp_alloc(i64)`, and +`osprey_web_dispatch(ptr)`. The host supplies WASI Preview 1 and these imports: + +- `osprey_web.render(ptr)` reads one UTF-8, NUL-terminated envelope; +- `osprey_web.command(ptr)` reads one command or an array of commands. + +An envelope is `{model, view, commands}`. `model` is an opaque JSON string and +is returned unchanged as the scalar `model` field on every dispatch. A view +node is `{tag, text?, props?, children?}`. `props.event` may be `click`, `input`, +`change`, or `submit`; the node's `id`, `name`, and current value become a flat +event object. Submit data is a JSON string in the scalar `data` field. + +Commands are `{kind:"http",id,method,url,body}`, `{kind:"focus",id}`, and +`{kind:"navigate",url}` (`type` is accepted as an alias for `kind`). Browser +back/forward and deep-link startup dispatch `{kind:"location",value:hash}`. +HTTP completion dispatches +`{kind:"http",id,status,data,model}`, where `data` is the unmodified response +text. All Osprey/JavaScript crossings are whole-document messages, never +per-node calls. + +For diagnostics and end-to-end assertions the host exposes +`window.__TALON_BRIDGE__ = {ready,renders,events,lastPayloadBytes,lastDecodeMs}`. diff --git a/examples/projects/modules/web/package-lock.json b/examples/projects/modules/web/package-lock.json new file mode 100644 index 00000000..f02e6178 --- /dev/null +++ b/examples/projects/modules/web/package-lock.json @@ -0,0 +1,533 @@ +{ + "name": "@osprey/talon-web-host", + "version": "0.0.0-dev", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@osprey/talon-web-host", + "version": "0.0.0-dev", + "dependencies": { + "react": "^19.2.7", + "react-dom": "^19.2.7" + }, + "devDependencies": { + "esbuild": "^0.28.1" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz", + "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz", + "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz", + "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz", + "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz", + "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz", + "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz", + "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz", + "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz", + "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz", + "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz", + "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz", + "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz", + "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz", + "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz", + "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz", + "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz", + "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz", + "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz", + "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz", + "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz", + "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz", + "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz", + "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz", + "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz", + "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz", + "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/esbuild": { + "version": "0.28.1", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz", + "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.1", + "@esbuild/android-arm": "0.28.1", + "@esbuild/android-arm64": "0.28.1", + "@esbuild/android-x64": "0.28.1", + "@esbuild/darwin-arm64": "0.28.1", + "@esbuild/darwin-x64": "0.28.1", + "@esbuild/freebsd-arm64": "0.28.1", + "@esbuild/freebsd-x64": "0.28.1", + "@esbuild/linux-arm": "0.28.1", + "@esbuild/linux-arm64": "0.28.1", + "@esbuild/linux-ia32": "0.28.1", + "@esbuild/linux-loong64": "0.28.1", + "@esbuild/linux-mips64el": "0.28.1", + "@esbuild/linux-ppc64": "0.28.1", + "@esbuild/linux-riscv64": "0.28.1", + "@esbuild/linux-s390x": "0.28.1", + "@esbuild/linux-x64": "0.28.1", + "@esbuild/netbsd-arm64": "0.28.1", + "@esbuild/netbsd-x64": "0.28.1", + "@esbuild/openbsd-arm64": "0.28.1", + "@esbuild/openbsd-x64": "0.28.1", + "@esbuild/openharmony-arm64": "0.28.1", + "@esbuild/sunos-x64": "0.28.1", + "@esbuild/win32-arm64": "0.28.1", + "@esbuild/win32-ia32": "0.28.1", + "@esbuild/win32-x64": "0.28.1" + } + }, + "node_modules/react": { + "version": "19.2.7", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.7.tgz", + "integrity": "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.7", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.7.tgz", + "integrity": "sha512-t0BRVXvbiE/o20Hfw669rLbMCDWtYZLvmJigy2f0MxsXF+71pxhR3xOkspmsO8h3ZlNzyibAmtCa3l4lYKk6gQ==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.7" + } + }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "license": "MIT" + } + } +} diff --git a/examples/projects/modules/web/package.json b/examples/projects/modules/web/package.json new file mode 100644 index 00000000..4e996f4d --- /dev/null +++ b/examples/projects/modules/web/package.json @@ -0,0 +1,23 @@ +{ + "name": "@osprey/talon-web-host", + "version": "0.0.0-dev", + "private": true, + "type": "module", + "description": "React host for an Osprey WebAssembly application", + "scripts": { + "build": "node scripts/build.mjs", + "build:host": "node scripts/build.mjs --host-only", + "test": "node --test", + "check": "npm run test && npm run build:host" + }, + "dependencies": { + "react": "^19.2.7", + "react-dom": "^19.2.7" + }, + "devDependencies": { + "esbuild": "^0.28.1" + }, + "engines": { + "node": ">=20" + } +} diff --git a/examples/projects/modules/web/scripts/build.mjs b/examples/projects/modules/web/scripts/build.mjs new file mode 100644 index 00000000..9a3c204c --- /dev/null +++ b/examples/projects/modules/web/scripts/build.mjs @@ -0,0 +1,139 @@ +import { access, mkdir, stat } from "node:fs/promises"; +import { constants } from "node:fs"; +import { spawnSync } from "node:child_process"; +import { fileURLToPath } from "node:url"; +import path from "node:path"; +import { build } from "esbuild"; +import { embed } from "./embed.mjs"; + +const scriptDirectory = path.dirname(fileURLToPath(import.meta.url)); +const packageRoot = path.resolve(scriptDirectory, ".."); +const repoRoot = path.resolve(packageRoot, "../../../.."); +const clientRoot = path.resolve(packageRoot, "../client"); +const defaultWasm = path.join(packageRoot, "build/talon-client.wasm"); +const outputModule = path.resolve(packageRoot, "../src/web/bundle.ospml"); +const hostOnly = process.argv.includes("--host-only"); +const noCompile = process.argv.includes("--no-compile"); + +function argumentValue(name, fallback) { + const index = process.argv.indexOf(name); + return index >= 0 && process.argv[index + 1] ? process.argv[index + 1] : fallback; +} + +async function exists(filename) { + try { + await access(filename, constants.F_OK); + return true; + } catch { + return false; + } +} + +async function findCompiler() { + const candidates = [ + process.env.OSPREY_BIN, + path.join(repoRoot, "target/release/osprey"), + path.join(repoRoot, "bin/osprey"), + ].filter(Boolean); + for (const candidate of candidates) { + if (await exists(candidate)) return candidate; + } + return null; +} + +async function firstTool(candidates) { + for (const candidate of candidates.filter(Boolean)) { + if (await exists(candidate)) return candidate; + } + return null; +} + +async function wasmEnvironment() { + const env = { ...process.env }; + env.OSPREY_WASM_CC ??= await firstTool([ + "/opt/homebrew/opt/llvm/bin/clang", + "/usr/local/opt/llvm/bin/clang", + ]); + env.OSPREY_WASM_LD ??= await firstTool([ + "/opt/homebrew/opt/lld/bin/wasm-ld", + "/usr/local/opt/lld/bin/wasm-ld", + "/opt/homebrew/opt/llvm/bin/wasm-ld", + ]); + return Object.fromEntries(Object.entries(env).filter(([, value]) => value != null)); +} + +async function shouldReuseWasm(wasmPath) { + if (!noCompile && !process.env.OSPREY_WEB_WASM) return false; + if (!(await exists(wasmPath))) { + throw new Error(`WebAssembly input does not exist: ${wasmPath}`); + } + return true; +} + +async function clientCompiler(wasmPath) { + const compiler = await findCompiler(); + const entry = path.join(clientRoot, "src/main.ospml"); + if (compiler && (await exists(entry))) return compiler; + if (await exists(wasmPath)) { + console.warn("Osprey compiler/client entry unavailable; embedding the existing wasm build"); + return null; + } + throw new Error( + `Cannot compile ${clientRoot}. Build target/release/osprey and ensure client/src/main.ospml exists.`, + ); +} + +async function runClientCompiler(compiler, wasmPath) { + await mkdir(path.dirname(wasmPath), { recursive: true }); + const options = { + cwd: repoRoot, encoding: "utf8", stdio: "pipe", env: await wasmEnvironment(), + }; + return spawnSync(compiler, [clientRoot, "--target=wasm32", "--compile", "-o", wasmPath], options); +} + +function reportCompilation(result) { + if (result.status !== 0) { + process.stderr.write(result.stdout ?? ""); + process.stderr.write(result.stderr ?? ""); + throw new Error(`Osprey client compilation failed with exit code ${result.status}`); + } + process.stdout.write(result.stdout ?? ""); +} + +async function compileClient(wasmPath) { + if (await shouldReuseWasm(wasmPath)) return; + const compiler = await clientCompiler(wasmPath); + if (!compiler) return; + reportCompilation(await runClientCompiler(compiler, wasmPath)); +} + +await mkdir(path.join(packageRoot, "dist"), { recursive: true }); +await build({ + entryPoints: [path.join(packageRoot, "src/index.jsx")], + outfile: path.join(packageRoot, "dist/host.js"), + bundle: true, + minify: true, + sourcemap: false, + legalComments: "none", + platform: "browser", + target: ["es2022"], + // Generated JavaScript is embedded in an Osprey string literal. Osprey also + // spells interpolation `${...}`, so lower JS template literals to ordinary + // concatenation and keep the generated module unambiguous. + supported: { "template-literal": false }, + jsx: "automatic", + logLevel: "info", +}); + +if (!hostOnly) { + const wasmPath = path.resolve( + argumentValue("--wasm", process.env.OSPREY_WEB_WASM || defaultWasm), + ); + await compileClient(wasmPath); + const result = await embed({ wasmPath, outputPath: outputModule }); + const outputSize = (await stat(result.outputPath)).size; + console.log( + `generated ${path.relative(repoRoot, result.outputPath)} (${outputSize} B; ` + + `${result.wasmBytes} B wasm embedded)`, + ); +} diff --git a/examples/projects/modules/web/scripts/embed.mjs b/examples/projects/modules/web/scripts/embed.mjs new file mode 100644 index 00000000..9ccc62da --- /dev/null +++ b/examples/projects/modules/web/scripts/embed.mjs @@ -0,0 +1,91 @@ +import { readFile, writeFile, mkdir } from "node:fs/promises"; +import { fileURLToPath } from "node:url"; +import path from "node:path"; + +const scriptDirectory = path.dirname(fileURLToPath(import.meta.url)); +const packageRoot = path.resolve(scriptDirectory, ".."); +const SENTINEL = "__OSPREY_WASM_BASE64__"; + +function ospreyString(source) { + return source + .replaceAll("\\", "\\\\") + .replaceAll('"', '\\"') + .replaceAll("\r", "\\r") + .replaceAll("\n", "\\n") + .replaceAll("\t", "\\t"); +} + +function argumentValue(name, fallback) { + const index = process.argv.indexOf(name); + return index >= 0 && process.argv[index + 1] ? process.argv[index + 1] : fallback; +} + +function embedPaths(options) { + return { + javascriptPath: options.javascriptPath ?? path.join(packageRoot, "dist/host.js"), + cssPath: options.cssPath ?? path.join(packageRoot, "dist/host.css"), + wasmPath: options.wasmPath ?? path.join(packageRoot, "build/talon-client.wasm"), + outputPath: options.outputPath ?? path.resolve(packageRoot, "../src/web/bundle.ospml"), + }; +} + +async function readAssets(paths) { + return Promise.all([ + readFile(paths.javascriptPath, "utf8"), + readFile(paths.cssPath, "utf8"), + readFile(paths.wasmPath), + ]); +} + +function validateAssets(javascriptSource, cssSource) { + const occurrences = javascriptSource.split(SENTINEL).length - 1; + if (occurrences !== 1) { + throw new Error(`Expected one wasm embed sentinel in host.js; found ${occurrences}`); + } + if (javascriptSource.includes("${") || cssSource.includes("${")) { + throw new Error("Generated assets must not contain Osprey interpolation syntax"); + } +} + +function moduleSource(css, javascript) { + return `// Generated by examples/projects/modules/web/scripts/embed.mjs. Do not edit.\n` + + `// React is the renderer; Osprey wasm owns model/update/view and emits one JSON tree per render.\n` + + `namespace "bank/web"\n\n` + + `module Bundle\n` + + ` export style : Unit -> string\n` + + ` style () = "${ospreyString(css)}"\n\n` + + ` export script : Unit -> string\n` + + ` script () = "${ospreyString(javascript)}"\n`; +} + +function assetStats(paths, javascript, css, wasm) { + return { + outputPath: paths.outputPath, + javascriptBytes: Buffer.byteLength(javascript), + cssBytes: Buffer.byteLength(css), + wasmBytes: wasm.byteLength, + }; +} + +export async function embed(options = {}) { + const paths = embedPaths(options); + const [javascriptSource, css, wasm] = await readAssets(paths); + validateAssets(javascriptSource, css); + const javascript = javascriptSource.replace(SENTINEL, wasm.toString("base64")); + await mkdir(path.dirname(paths.outputPath), { recursive: true }); + await writeFile(paths.outputPath, moduleSource(css, javascript), "utf8"); + return assetStats(paths, javascript, css, wasm); +} + +if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) { + const result = await embed({ + javascriptPath: path.resolve(argumentValue("--javascript", path.join(packageRoot, "dist/host.js"))), + cssPath: path.resolve(argumentValue("--css", path.join(packageRoot, "dist/host.css"))), + wasmPath: path.resolve(argumentValue("--wasm", path.join(packageRoot, "build/talon-client.wasm"))), + outputPath: path.resolve(argumentValue("--output", path.resolve(packageRoot, "../src/web/bundle.ospml"))), + }); + console.log( + `embedded ${result.wasmBytes} B wasm + ${result.javascriptBytes} B JS + ` + + `${result.cssBytes} B CSS -> ${result.outputPath}`, + ); +} diff --git a/examples/projects/modules/web/src/host.js b/examples/projects/modules/web/src/host.js new file mode 100644 index 00000000..e57162ce --- /dev/null +++ b/examples/projects/modules/web/src/host.js @@ -0,0 +1,304 @@ +import React from "react"; +import { createRoot } from "react-dom/client"; +import { commandKind, nodeToReact, normalizeEnvelope } from "./protocol.js"; +import { createWasi } from "./wasi.js"; + +const EMBEDDED_WASM = "__OSPREY_WASM_BASE64__"; +const decoder = new TextDecoder("utf-8"); +const encoder = new TextEncoder(); + +function runtimeDispatch(exports) { + const dispatch = + exports?.osprey_web_dispatch ?? exports?.dispatch ?? exports?.osprey_dispatch; + if (typeof dispatch !== "function") { + throw new Error("Osprey wasm must export osprey_web_dispatch"); + } + return dispatch; +} + +function scalarMessage(message, model) { + const flat = { ...message, model }; + for (const [name, value] of Object.entries(flat)) { + if (value === undefined || value === null) delete flat[name]; + else if (typeof value === "object") flat[name] = JSON.stringify(value); + else if (!["string", "number", "boolean"].includes(typeof value)) { + flat[name] = String(value); + } + } + return flat; +} + +function requestInit(command) { + const method = String(command.method || "GET").toUpperCase(); + const headers = { ...(command.headers ?? {}) }; + const init = { method, headers }; + const hasBody = command.body !== undefined && command.body !== ""; + if (!hasBody || method === "GET" || method === "HEAD") return init; + init.body = typeof command.body === "string" ? command.body : JSON.stringify(command.body); + const contentType = Object.keys(headers).some((name) => name.toLowerCase() === "content-type"); + if (!contentType) headers["Content-Type"] = "application/json"; + return init; +} + +function httpEvent(command, status, data) { + return { kind: "http", id: String(command.id ?? ""), status, data }; +} + +function wasmImports(host, wasi) { + return { + wasi_snapshot_preview1: wasi.imports, + osprey_web: { + render: (pointer) => host.renderPointer(pointer), + command: (pointer) => host.commandPointer(pointer), + }, + }; +} + +function invokeWasmStart(exports) { + if (typeof exports._start === "function") exports._start(); + else if (typeof exports.main === "function") exports.main(); + else throw new Error("Osprey wasm must export _start"); +} + +function bridgeTelemetry() { + return { + ready: false, + renders: 0, + events: 0, + lastPayloadBytes: 0, + lastDecodeMs: 0, + }; +} + +function decodeBase64(source) { + if (!source || source.startsWith("__OSPREY_WASM_")) { + throw new Error("The Osprey WebAssembly payload was not embedded"); + } + const binary = atob(source); + const bytes = new Uint8Array(binary.length); + for (let index = 0; index < binary.length; index += 1) { + bytes[index] = binary.charCodeAt(index); + } + return bytes; +} + +function ensureRootElement() { + let element = document.getElementById("app"); + if (!element) { + element = document.createElement("div"); + element.id = "app"; + document.body.appendChild(element); + } + return element; +} + +function ErrorScreen({ error }) { + return React.createElement( + "main", + { className: "host-error", role: "alert" }, + React.createElement("span", { className: "host-error-mark" }, "T"), + React.createElement("p", { className: "eyebrow" }, "Talon client did not start"), + React.createElement("h1", null, "The browser engine hit turbulence."), + React.createElement( + "p", + null, + "The server is still safe. Reload the page, then inspect the browser console if this persists.", + ), + React.createElement("pre", null, String(error?.message ?? error)), + ); +} + +export class OspreyReactHost { + constructor(rootElement) { + this.root = createRoot(rootElement); + this.exports = null; + this.memory = null; + this.model = "{}"; + this.renderSequence = 0; + this.pendingRenders = []; + this.bridge = bridgeTelemetry(); + window.__TALON_BRIDGE__ = this.bridge; + this.onPopState = () => { + if (this.exports) this.dispatch({ kind: "location", value: window.location.hash }); + }; + window.addEventListener("popstate", this.onPopState); + } + + readCString(pointer) { + const start = Number(pointer); + if (!this.memory || !Number.isSafeInteger(start) || start <= 0) { + throw new Error(`Invalid Osprey string pointer: ${String(pointer)}`); + } + const bytes = new Uint8Array(this.memory.buffer); + let end = start; + while (end < bytes.length && bytes[end] !== 0) end += 1; + if (end === bytes.length) throw new Error("Unterminated string from Osprey wasm"); + this.bridge.lastPayloadBytes = end - start; + return decoder.decode(bytes.subarray(start, end)); + } + + readJson(pointer) { + const started = performance.now(); + const source = this.readCString(pointer); + try { + const value = JSON.parse(source); + this.bridge.lastDecodeMs = performance.now() - started; + return value; + } catch (error) { + this.bridge.lastDecodeMs = performance.now() - started; + throw new Error(`Invalid JSON from Osprey: ${error.message}`); + } + } + + renderPointer(pointer) { + const value = this.readJson(pointer); + this.bridge.renders += 1; + this.commitEnvelope(value); + return 0; + } + + commandPointer(pointer) { + const value = this.readJson(pointer); + const commands = Array.isArray(value) ? value : [value]; + queueMicrotask(() => this.runCommands(commands)); + return 0; + } + + commitEnvelope(value) { + const envelope = normalizeEnvelope(value); + this.model = envelope.model; + const sequence = ++this.renderSequence; + this.root.render(nodeToReact(envelope.view, (event) => this.dispatch(event))); + if (envelope.commands.length) { + // Let React commit first so focus commands can see newly rendered fields. + queueMicrotask(() => { + if (sequence <= this.renderSequence) this.runCommands(envelope.commands); + }); + } + } + + allocate(length) { + const allocate = + this.exports?.osp_alloc ?? + this.exports?.osprey_web_alloc ?? + this.exports?.malloc ?? + this.exports?.alloc; + if (typeof allocate !== "function") { + throw new Error("Osprey wasm must export osp_alloc"); + } + // osp_alloc is `i64 -> pointer` in Osprey's runtime; aliases used by other + // wasm toolchains often accept i32, so retain a narrow compatibility path. + try { + return Number(allocate(BigInt(length))); + } catch (error) { + if (!(error instanceof TypeError)) throw error; + return Number(allocate(length)); + } + } + + dispatch(message) { + if (!this.exports) return; + const dispatch = runtimeDispatch(this.exports); + const pointer = this.writeDispatch(message); + this.acceptDispatchResult(dispatch(pointer)); + } + + writeDispatch(message) { + const payload = encoder.encode(`${JSON.stringify(scalarMessage(message, this.model))}\0`); + this.bridge.events += 1; + this.bridge.lastPayloadBytes = payload.byteLength - 1; + const pointer = this.allocate(payload.byteLength); + new Uint8Array(this.memory.buffer, pointer, payload.byteLength).set(payload); + return pointer; + } + + acceptDispatchResult(result) { + // The canonical ABI renders through the import callback. A returned C + // string is also accepted, which is convenient for tiny embedders/tests. + const resultPointer = Number(result ?? 0); + if (Number.isSafeInteger(resultPointer) && resultPointer > 0) { + this.commitEnvelope(this.readJson(resultPointer)); + } + } + + async runHttp(command) { + try { + const response = await fetch(command.url, requestInit(command)); + const data = await response.text(); + this.dispatch(httpEvent(command, response.status, data)); + } catch (error) { + this.dispatch(httpEvent(command, 0, String(error?.message ?? error))); + } + } + + runFocus(command) { + requestAnimationFrame(() => { + const element = document.getElementById(String(command.id ?? "")); + element?.focus({ preventScroll: false }); + }); + } + + runNavigate(command) { + const url = String(command.url ?? ""); + if (!url) return; + if (command.replace === true || command.replace === "true") { + window.history.replaceState(null, "", url); + } else { + window.history.pushState(null, "", url); + } + } + + runCommands(commands) { + for (const command of commands) { + if (!command || typeof command !== "object") continue; + switch (commandKind(command)) { + case "http": + void this.runHttp(command); + break; + case "focus": + this.runFocus(command); + break; + case "navigate": + this.runNavigate(command); + break; + default: + console.warn("Unknown Osprey web command", command); + } + } + } + + async start(wasmBytes) { + const wasi = createWasi((text) => console.debug("[osprey]", text.trimEnd())); + const { instance } = await WebAssembly.instantiate(wasmBytes, wasmImports(this, wasi)); + this.attachInstance(instance, wasi); + invokeWasmStart(instance.exports); + wasi.flush(); + this.bridge.ready = true; + if (window.location.hash) { + this.dispatch({ kind: "location", value: window.location.hash }); + } + return this; + } + + attachInstance(instance, wasi) { + this.exports = instance.exports; + this.memory = instance.exports.memory; + if (!(this.memory instanceof WebAssembly.Memory)) { + throw new Error("Osprey wasm must export memory"); + } + wasi.setMemory(this.memory); + } +} + +export async function boot() { + const host = new OspreyReactHost(ensureRootElement()); + window.__OSPREY_WEB__ = host; + try { + await host.start(decodeBase64(EMBEDDED_WASM)); + document.documentElement.dataset.ospreyReady = "true"; + } catch (error) { + console.error("Osprey web host failed", error); + document.documentElement.dataset.ospreyReady = "false"; + host.root.render(React.createElement(ErrorScreen, { error })); + } +} diff --git a/examples/projects/modules/web/src/index.jsx b/examples/projects/modules/web/src/index.jsx new file mode 100644 index 00000000..7690ea8c --- /dev/null +++ b/examples/projects/modules/web/src/index.jsx @@ -0,0 +1,8 @@ +import "./styles.css"; +import { boot } from "./host.js"; + +if (document.readyState === "loading") { + document.addEventListener("DOMContentLoaded", () => void boot(), { once: true }); +} else { + void boot(); +} diff --git a/examples/projects/modules/web/src/protocol.js b/examples/projects/modules/web/src/protocol.js new file mode 100644 index 00000000..9a10cd01 --- /dev/null +++ b/examples/projects/modules/web/src/protocol.js @@ -0,0 +1,242 @@ +import React from "react"; + +const EVENT_NAMES = new Set([ + "blur", + "change", + "click", + "doubleClick", + "focus", + "input", + "keyDown", + "keyUp", + "pointerDown", + "pointerUp", + "submit", +]); + +const VOID_TAGS = new Set([ + "area", + "base", + "br", + "col", + "embed", + "hr", + "img", + "input", + "link", + "meta", + "param", + "source", + "track", + "wbr", +]); + +const BOOLEAN_PROPS = new Set([ + "autoFocus", + "checked", + "disabled", + "hidden", + "multiple", + "readOnly", + "required", + "selected", +]); + +const PROP_ALIASES = { + class: "className", + for: "htmlFor", + tabindex: "tabIndex", + readonly: "readOnly", + maxlength: "maxLength", + autocomplete: "autoComplete", +}; + +function eventPropName(name) { + // React treats a value-bearing input with only `onInput` as read-only. The + // protocol retains kind=input while React receives the canonical onChange. + if (name === "input") return "onChange"; + if (name === "doubleClick") return "onDoubleClick"; + return `on${name.charAt(0).toUpperCase()}${name.slice(1)}`; +} + +function domValue(name, value) { + if (name === "style") return parseStyle(value); + if (BOOLEAN_PROPS.has(name) && (value === "true" || value === "false")) { + return value === "true"; + } + return value; +} + +function formDataJson(form) { + const values = {}; + for (const [name, value] of new FormData(form).entries()) { + const scalar = typeof File !== "undefined" && value instanceof File ? value.name : value; + if (Object.hasOwn(values, name)) { + values[name] = Array.isArray(values[name]) + ? [...values[name], scalar] + : [values[name], scalar]; + } else { + values[name] = scalar; + } + } + return JSON.stringify(values); +} + +function eventValue(kind, target, staticProps, browserEvent) { + if (kind === "input" || kind === "change") { + if (target?.type === "checkbox" || target?.type === "radio") { + return target.checked ? "true" : "false"; + } + if (target && "value" in target) return String(target.value); + return undefined; + } + if ((kind === "keyDown" || kind === "keyUp") && browserEvent.key) { + return browserEvent.key; + } + return staticProps.value === undefined ? undefined : String(staticProps.value); +} + +function preventAnchorClick(kind, target, browserEvent) { + const isAnchor = typeof HTMLAnchorElement !== "undefined" && target instanceof HTMLAnchorElement; + if (kind === "click" && isAnchor) browserEvent.preventDefault(); +} + +function makeEvent(kind, id, staticProps, browserEvent) { + const target = browserEvent.currentTarget; + const message = { kind }; + if (id) message.id = String(id); + if (kind === "submit") { + browserEvent.preventDefault(); + message.data = formDataJson(target); + return message; + } + preventAnchorClick(kind, target, browserEvent); + const name = target?.name || staticProps.name; + const value = eventValue(kind, target, staticProps, browserEvent); + if (name) message.name = String(name); + if (value !== undefined) message.value = value; + return message; +} + +function dispatchBrowserEvent(kind, source, browserEvent, send) { + if ( + kind === "click" && + source.id === "modal-backdrop" && + browserEvent.target !== browserEvent.currentTarget + ) { + return; + } + browserEvent.stopPropagation?.(); + send(makeEvent(kind, source.id, source, browserEvent)); +} + +function parseStyle(value) { + if (!value || typeof value !== "string") return value; + return Object.fromEntries( + value + .split(";") + .map((declaration) => declaration.split(":")) + .filter(([name, part]) => name?.trim() && part !== undefined) + .map(([name, ...parts]) => [ + name.trim().replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase()), + parts.join(":").trim(), + ]), + ); +} + +function safeDomProps(source) { + const props = {}; + for (const [originalName, value] of Object.entries(source)) { + const reserved = originalName === "event" || originalName === "events"; + if (reserved || originalName === "dangerouslySetInnerHTML") continue; + const name = PROP_ALIASES[originalName.toLowerCase()] ?? originalName; + if (/^on[A-Z]/.test(name)) continue; + props[name] = domValue(name, value); + } + return props; +} + +function addPrimaryEvent(props, source, send) { + const event = source.event; + if (typeof event === "string" && EVENT_NAMES.has(event)) { + props[eventPropName(event)] = (browserEvent) => + dispatchBrowserEvent(event, source, browserEvent, send); + } +} + +function extendedHandler(name, descriptor, source, send) { + return (browserEvent) => { + const message = makeEvent(name, source.id, source, browserEvent); + if (typeof descriptor === "string") message.id = descriptor; + else if (descriptor && typeof descriptor === "object") Object.assign(message, descriptor); + send(message); + }; +} + +function addExtendedEvents(props, source, send) { + if (source.events && typeof source.events === "object") { + for (const [name, descriptor] of Object.entries(source.events)) { + if (!EVENT_NAMES.has(name)) continue; + props[eventPropName(name)] = extendedHandler(name, descriptor, source, send); + } + } +} + +function domProps(source, send) { + const props = safeDomProps(source); + addPrimaryEvent(props, source, send); + addExtendedEvents(props, source, send); + return props; +} + +function renderChildren(node, send, keyPath) { + const children = []; + if (node.text !== undefined && node.text !== null && node.text !== "") { + children.push(String(node.text)); + } + if (Array.isArray(node.children)) { + node.children.forEach((child, index) => { + children.push(renderNode(child, send, `${keyPath}.${index}`)); + }); + } + return children; +} + +function renderNode(node, send, keyPath) { + if (node === null || node === undefined || node === false) return null; + if (typeof node === "string" || typeof node === "number") return String(node); + if (Array.isArray(node)) { + return node.map((child, index) => renderNode(child, send, `${keyPath}.${index}`)); + } + if (typeof node !== "object") return null; + + const tag = typeof node.tag === "string" && node.tag ? node.tag : "div"; + const sourceProps = node.props && typeof node.props === "object" ? node.props : {}; + const props = domProps(sourceProps, send); + props.key = node.key ?? sourceProps.key ?? keyPath; + + if (VOID_TAGS.has(tag.toLowerCase())) return React.createElement(tag, props); + return React.createElement(tag, props, ...renderChildren(node, send, keyPath)); +} + +export function nodeToReact(node, send) { + return renderNode(node, send, "root"); +} + +export function normalizeEnvelope(value) { + if (!value || typeof value !== "object" || Array.isArray(value)) { + throw new Error("Osprey render message must be a JSON object"); + } + return { + model: + typeof value.model === "string" + ? value.model + : JSON.stringify(value.model ?? {}), + view: value.view ?? null, + commands: Array.isArray(value.commands) ? value.commands : [], + }; +} + +export function commandKind(command) { + return command?.kind ?? command?.type ?? ""; +} diff --git a/examples/projects/modules/web/src/styles.css b/examples/projects/modules/web/src/styles.css new file mode 100644 index 00000000..281250bc --- /dev/null +++ b/examples/projects/modules/web/src/styles.css @@ -0,0 +1,8 @@ +@layer reset, tokens, base, layout, components, utilities, responsive; + +@import "./styles/foundation.css"; +@import "./styles/layout.css"; +@import "./styles/components.css"; +@import "./styles/forms.css"; +@import "./styles/pages.css"; +@import "./styles/responsive.css"; diff --git a/examples/projects/modules/web/src/styles/components.css b/examples/projects/modules/web/src/styles/components.css new file mode 100644 index 00000000..8881e4e7 --- /dev/null +++ b/examples/projects/modules/web/src/styles/components.css @@ -0,0 +1,451 @@ +@layer components { + .eyebrow { + color: var(--coral-dark); + font-size: 0.68rem; + font-weight: 800; + letter-spacing: 0.14em; + text-transform: uppercase; + } + + .hero-card { + position: relative; + isolation: isolate; + display: grid; + min-height: 220px; + overflow: hidden; + align-content: space-between; + border-radius: var(--radius-xl); + padding: clamp(26px, 4vw, 44px); + background: + radial-gradient(circle at 78% 32%, rgb(158 226 195 / 28%), transparent 13rem), + linear-gradient(130deg, var(--ink-900), var(--ink-950)); + box-shadow: var(--shadow); + color: var(--white); + } + + .hero-card::before, + .hero-card::after { + position: absolute; + z-index: -1; + border: 1px solid rgb(255 255 255 / 7%); + border-radius: 50%; + content: ""; + } + + .hero-card::before { + top: -110px; + right: -50px; + width: 310px; + height: 310px; + } + + .hero-card::after { + right: 48px; + bottom: -190px; + width: 370px; + height: 370px; + box-shadow: 0 0 0 42px rgb(255 255 255 / 2%); + } + + .hero-card h1, + .hero-card h2, + .hero-card h3 { + color: var(--white); + } + + .hero-label { + margin-bottom: 9px; + color: rgb(255 255 255 / 50%); + font-size: 0.7rem; + font-weight: 700; + letter-spacing: 0.11em; + text-transform: uppercase; + } + + .hero-value { + font-family: var(--font-display); + font-size: clamp(2.5rem, 6vw, 4.9rem); + font-weight: 700; + letter-spacing: -0.065em; + line-height: 0.95; + } + + .hero-meta { + display: flex; + flex-wrap: wrap; + align-items: center; + justify-content: space-between; + gap: 18px; + margin-top: 34px; + color: rgb(255 255 255 / 60%); + } + + .hero-actions, + .card-actions, + .button-row { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: 10px; + } + + .stat-grid, + .tiles { + display: grid; + grid-template-columns: repeat(3, minmax(0, 1fr)); + gap: 16px; + margin-block: 20px; + } + + .stat, + .stat-card, + .tile { + position: relative; + overflow: hidden; + border: 1px solid rgb(7 26 28 / 7%); + border-radius: var(--radius); + padding: 21px; + background: rgb(255 255 255 / 86%); + box-shadow: var(--shadow-sm); + } + + .stat::after, + .stat-card::after, + .tile::after { + position: absolute; + top: -24px; + right: -24px; + width: 70px; + height: 70px; + border-radius: 50%; + background: var(--mint-soft); + content: ""; + opacity: 0.7; + } + + .stat-label, + .tile span { + position: relative; + z-index: 1; + display: block; + color: var(--ink-500); + font-size: 0.68rem; + font-weight: 750; + letter-spacing: 0.09em; + text-transform: uppercase; + } + + .stat-value, + .tile b { + position: relative; + z-index: 1; + display: block; + margin-top: 9px; + color: var(--ink-950); + font-family: var(--font-display); + font-size: clamp(1.35rem, 2.5vw, 2rem); + font-weight: 720; + letter-spacing: -0.045em; + line-height: 1; + } + + .stat-detail { + position: relative; + z-index: 1; + margin-top: 10px; + color: var(--ink-500); + font-size: 0.74rem; + } + + .card { + border: 1px solid rgb(7 26 28 / 7%); + border-radius: var(--radius-lg); + background: rgb(255 255 255 / 88%); + box-shadow: var(--shadow-sm); + } + + .card-header { + display: flex; + min-height: 76px; + align-items: center; + justify-content: space-between; + gap: 18px; + border-bottom: 1px solid var(--ink-150); + padding: 20px 24px; + } + + .card-header-copy { + display: grid; + gap: 4px; + } + + .card-title { + font-family: var(--font-display); + font-size: 1.05rem; + font-weight: 700; + letter-spacing: -0.025em; + } + + .card-subtitle { + color: var(--ink-500); + font-size: 0.74rem; + } + + .card-body { + padding: 24px; + } + + .account-grid { + display: grid; + grid-template-columns: repeat(3, minmax(0, 1fr)); + gap: 16px; + } + + .account-card { + position: relative; + display: grid; + min-height: 190px; + overflow: hidden; + align-content: space-between; + border: 1px solid rgb(7 26 28 / 8%); + border-radius: 23px; + padding: 22px; + background: var(--white); + box-shadow: var(--shadow-sm); + text-align: left; + transition: + transform 220ms var(--ease-out), + border-color 180ms ease, + box-shadow 220ms ease; + } + + .account-card::after { + position: absolute; + top: -52px; + right: -52px; + width: 130px; + height: 130px; + border: 18px solid var(--mint-soft); + border-radius: 50%; + content: ""; + opacity: 0.8; + } + + .account-card:hover, + .account-card.active, + .account-card.selected { + border-color: rgb(30 121 90 / 28%); + box-shadow: 0 20px 55px rgb(7 26 28 / 12%); + transform: translateY(-4px); + } + + .account-card.active, + .account-card.selected { + background: linear-gradient(145deg, var(--white), var(--mint-soft)); + } + + .account-card-top { + position: relative; + z-index: 1; + display: flex; + align-items: center; + justify-content: space-between; + gap: 12px; + } + + .account-number, + .account-type { + color: var(--ink-500); + font-size: 0.68rem; + font-weight: 750; + letter-spacing: 0.08em; + text-transform: uppercase; + } + + .account-balance { + position: relative; + z-index: 1; + font-family: var(--font-display); + font-size: clamp(1.6rem, 3vw, 2.25rem); + font-weight: 700; + letter-spacing: -0.05em; + } + + .account-owner { + position: relative; + z-index: 1; + margin-top: 5px; + color: var(--ink-600); + font-size: 0.8rem; + font-weight: 600; + } + + .activity-list, + .feed { + display: grid; + } + + .activity-item, + .feed li { + display: grid; + grid-template-columns: 42px minmax(0, 1fr) auto; + align-items: center; + gap: 14px; + min-height: 73px; + border-bottom: 1px solid var(--ink-150); + padding: 12px 0; + } + + .activity-item:last-child, + .feed li:last-child { + border-bottom: 0; + } + + .activity-icon, + .kind { + display: grid; + width: 40px; + height: 40px; + place-items: center; + border-radius: 13px; + background: var(--mint-soft); + color: var(--mint-dark); + font-size: 0.86rem; + font-weight: 800; + } + + .debit .activity-icon, + .debit .kind { + background: var(--gold-soft); + color: #96701e; + } + + .refused .activity-icon, + .refused .kind { + background: var(--red-soft); + color: var(--red); + } + + .activity-copy, + .what { + min-width: 0; + } + + .activity-title, + .what { + overflow: hidden; + color: var(--ink-900); + font-size: 0.84rem; + font-weight: 650; + text-overflow: ellipsis; + white-space: nowrap; + } + + .activity-meta, + .what small { + display: block; + margin-top: 3px; + overflow: hidden; + color: var(--ink-500); + font-size: 0.72rem; + font-weight: 500; + text-overflow: ellipsis; + white-space: nowrap; + } + + .activity-amount, + .amt, + .money { + font-variant-numeric: tabular-nums; + font-weight: 720; + letter-spacing: -0.02em; + } + + .credit .activity-amount, + .credit .amt, + .money { + color: var(--mint-dark); + } + + .refused .activity-amount, + .refused .amt { + color: var(--red); + text-decoration: line-through; + text-decoration-thickness: 1.5px; + } + + .table-wrap { + overflow-x: auto; + } + + .data-table, + table { + width: 100%; + font-variant-numeric: tabular-nums; + } + + .data-table th, + .data-table td, + th, + td { + border-bottom: 1px solid var(--ink-150); + padding: 15px 14px; + text-align: left; + } + + .data-table th, + th { + color: var(--ink-500); + font-size: 0.66rem; + font-weight: 750; + letter-spacing: 0.09em; + text-transform: uppercase; + } + + .data-table tbody tr, + tbody tr { + transition: background 160ms ease; + } + + .data-table tbody tr:hover, + tbody tr:hover { + background: var(--ink-100); + } + + .data-table tr:last-child td, + tbody tr:last-child td { + border-bottom: 0; + } + + .num, + .align-right { + text-align: right; + } + + .badge, + .status, + .pill { + display: inline-flex; + min-height: 25px; + align-items: center; + border-radius: 999px; + padding: 4px 9px; + background: var(--ink-100); + color: var(--ink-600); + font-size: 0.66rem; + font-weight: 750; + letter-spacing: 0.035em; + } + + .status.success, + .badge.success { + background: var(--mint-soft); + color: var(--mint-dark); + } + + .status.warning, + .badge.warning { + background: var(--gold-soft); + color: #896512; + } +} diff --git a/examples/projects/modules/web/src/styles/forms.css b/examples/projects/modules/web/src/styles/forms.css new file mode 100644 index 00000000..a73380c6 --- /dev/null +++ b/examples/projects/modules/web/src/styles/forms.css @@ -0,0 +1,467 @@ +@layer components { + .btn, + .button, + .primary-button, + .secondary-button, + .icon-button { + display: inline-flex; + min-height: 44px; + align-items: center; + justify-content: center; + gap: 9px; + border: 1px solid transparent; + border-radius: 13px; + padding: 0 17px; + background: var(--ink-900); + box-shadow: 0 9px 22px rgb(7 26 28 / 12%); + color: var(--white); + font-size: 0.78rem; + font-weight: 700; + transition: + transform 180ms var(--ease-out), + box-shadow 180ms ease, + background 180ms ease, + border-color 180ms ease; + } + + .btn:hover, + .button:hover, + .primary-button:hover, + .secondary-button:hover, + .icon-button:hover { + box-shadow: 0 13px 28px rgb(7 26 28 / 18%); + transform: translateY(-2px); + } + + .btn:active, + .button:active, + .primary-button:active, + .secondary-button:active, + .icon-button:active { + transform: translateY(0); + } + + .btn.primary, + .button.primary, + .primary-button { + background: var(--coral); + box-shadow: 0 11px 24px rgb(255 107 74 / 23%); + } + + .btn.primary:hover, + .button.primary:hover, + .primary-button:hover { + background: #ff7657; + } + + .btn.secondary, + .button.secondary, + .secondary-button { + border-color: var(--ink-200); + background: var(--white); + box-shadow: none; + color: var(--ink-900); + } + + .btn.ghost, + .button.ghost, + .icon-button { + border-color: transparent; + background: transparent; + box-shadow: none; + color: var(--ink-600); + } + + .btn.danger, + .button.danger { + background: var(--red); + } + + .btn:disabled, + .button:disabled, + button:disabled { + cursor: not-allowed; + opacity: 0.45; + transform: none; + } + + .icon-button { + width: 43px; + min-height: 43px; + padding: 0; + border-color: var(--ink-200); + border-radius: 13px; + background: rgb(255 255 255 / 76%); + } + + .menu-button { + display: none; + } + + .chip-row, + .filter-row, + .tabs { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: 7px; + } + + .chip, + .tab { + display: inline-flex; + min-height: 35px; + align-items: center; + justify-content: center; + gap: 7px; + border: 1px solid var(--ink-200); + border-radius: 999px; + padding: 0 13px; + background: transparent; + color: var(--ink-600); + font-size: 0.72rem; + font-weight: 700; + transition: 160ms ease; + } + + .chip:hover, + .tab:hover, + .chip.active, + .tab.active { + border-color: var(--ink-900); + background: var(--ink-900); + color: var(--white); + } + + .search-box { + position: relative; + min-width: min(100%, 260px); + } + + .search-box .field-control { + padding-left: 42px; + } + + .search-icon { + position: absolute; + z-index: 1; + top: 50%; + left: 15px; + color: var(--ink-400); + transform: translateY(-50%); + pointer-events: none; + } + + .form-grid { + display: grid; + grid-template-columns: repeat(2, minmax(0, 1fr)); + gap: 18px; + } + + .form-grid .full, + .field.full, + .form-actions { + grid-column: 1 / -1; + } + + .field { + display: grid; + gap: 8px; + } + + .field-label { + color: var(--ink-700); + font-size: 0.71rem; + font-weight: 720; + letter-spacing: 0.015em; + } + + .field-control { + width: 100%; + height: 48px; + border: 1px solid var(--ink-200); + border-radius: 13px; + padding: 0 14px; + outline: none; + background: var(--white); + color: var(--ink-900); + font-size: 0.83rem; + transition: + border-color 160ms ease, + box-shadow 160ms ease, + background 160ms ease; + } + + textarea.field-control { + min-height: 104px; + resize: vertical; + padding-block: 13px; + } + + .field-control::placeholder { + color: var(--ink-400); + } + + .field-control:hover { + border-color: var(--ink-300); + } + + .field-control:focus { + border-color: var(--mint-dark); + box-shadow: 0 0 0 4px rgb(30 121 90 / 10%); + } + + .form-actions { + display: flex; + align-items: center; + justify-content: flex-end; + gap: 10px; + margin-top: 5px; + } + + .segmented { + display: grid; + grid-template-columns: repeat(3, minmax(0, 1fr)); + gap: 4px; + border-radius: 14px; + padding: 4px; + background: var(--ink-100); + } + + .segmented .chip { + min-height: 38px; + border: 0; + border-radius: 10px; + } + + .segmented .chip.active { + background: var(--white); + box-shadow: 0 5px 15px rgb(7 26 28 / 9%); + color: var(--ink-900); + } + + .modal-backdrop { + position: fixed; + z-index: 100; + inset: 0; + display: grid; + overflow-y: auto; + place-items: center; + padding: 24px; + background: rgb(7 26 28 / 57%); + backdrop-filter: blur(10px); + animation: fade-in 180ms ease both; + } + + .modal { + width: min(100%, 590px); + overflow: hidden; + border: 1px solid rgb(255 255 255 / 50%); + border-radius: var(--radius-xl); + background: var(--paper); + box-shadow: var(--shadow-float); + animation: modal-in 320ms var(--ease-out) both; + } + + .modal-header { + display: flex; + align-items: start; + justify-content: space-between; + gap: 20px; + padding: 28px 30px 22px; + } + + .modal-header-copy { + display: grid; + gap: 7px; + } + + .modal-body { + padding: 0 30px 30px; + } + + .toast { + position: fixed; + z-index: 120; + right: 24px; + bottom: 24px; + display: grid; + grid-template-columns: 40px minmax(0, 1fr) auto; + width: min(calc(100vw - 32px), 430px); + align-items: center; + gap: 13px; + border: 1px solid rgb(255 255 255 / 11%); + border-radius: 18px; + padding: 15px; + background: var(--ink-900); + box-shadow: var(--shadow-float); + color: var(--white); + animation: toast-in 420ms var(--ease-out) both; + } + + .toast.success { + background: #155d48; + } + + .toast.error { + background: #88273b; + } + + .toast-icon { + display: grid; + width: 40px; + height: 40px; + place-items: center; + border-radius: 12px; + background: rgb(255 255 255 / 11%); + font-weight: 800; + } + + .toast-copy { + display: grid; + gap: 2px; + } + + .toast-copy strong { + font-size: 0.8rem; + } + + .toast-copy span { + color: rgb(255 255 255 / 63%); + font-size: 0.72rem; + } + + .empty-state { + display: grid; + min-height: 250px; + place-items: center; + align-content: center; + padding: 40px; + text-align: center; + } + + .empty-icon { + display: grid; + width: 58px; + height: 58px; + margin-bottom: 17px; + place-items: center; + border-radius: 19px; + background: var(--mint-soft); + color: var(--mint-dark); + font-size: 1.35rem; + } + + .empty-state p { + max-width: 390px; + margin-top: 8px; + color: var(--ink-500); + font-size: 0.79rem; + } + + .skeleton { + overflow: hidden; + border-radius: 9px; + background: var(--ink-150); + color: transparent; + } + + .skeleton::after { + display: block; + width: 100%; + height: 100%; + background: linear-gradient(90deg, transparent, rgb(255 255 255 / 65%), transparent); + content: ""; + animation: shimmer 1.4s infinite; + transform: translateX(-100%); + } + + .spinner { + width: 18px; + height: 18px; + border: 2px solid currentColor; + border-right-color: transparent; + border-radius: 50%; + animation: spin 650ms linear infinite; + } + + .host-error { + display: grid; + width: min(620px, calc(100% - 40px)); + min-height: 100vh; + margin: auto; + place-content: center; + gap: 16px; + } + + .host-error-mark { + display: grid; + width: 52px; + height: 52px; + place-items: center; + border-radius: 17px; + background: var(--coral); + color: var(--white); + font-family: var(--font-display); + font-size: 1.25rem; + font-weight: 800; + } + + .host-error p:not(.eyebrow) { + color: var(--ink-500); + } + + .host-error pre { + overflow: auto; + border-radius: var(--radius); + padding: 18px; + background: var(--ink-950); + color: var(--mint); + font-size: 0.75rem; + white-space: pre-wrap; + } + + .boot-screen,.not-found { display: grid; min-height: 100vh; place-content: center; justify-items: center; gap: 12px; padding: 28px; text-align: center; } + .boot-mark { display: grid; width: 58px; height: 58px; margin-bottom: 6px; place-items: center; border-radius: 19px; background: var(--ink-900); box-shadow: var(--shadow); color: var(--mint); font: 800 1.4rem var(--font-display); animation: boot-pulse 1.4s ease-in-out infinite; } + .boot-screen p { font: 700 1.05rem var(--font-display); }.boot-screen > span { color: var(--ink-500); font-size: .7rem; } + .not-found > span { color: var(--coral); font: 800 clamp(4rem,12vw,8rem)/1 var(--font-display); letter-spacing: -.08em; }.not-found p { color: var(--ink-500); }.not-found a { margin-top: 10px; border-radius: 13px; padding: 12px 17px; background: var(--ink-900); color: white; font-size: .75rem; font-weight: 700; } + + footer, + .page-footer { + color: var(--ink-400); + font-size: 0.7rem; + } + + @keyframes modal-in { + from { + opacity: 0; + transform: translateY(20px) scale(0.97); + } + } + + @keyframes toast-in { + from { + opacity: 0; + transform: translateY(18px) scale(0.96); + } + } + + @keyframes fade-in { + from { + opacity: 0; + } + } + + @keyframes shimmer { + to { + transform: translateX(100%); + } + } + + @keyframes spin { + to { + transform: rotate(360deg); + } + } + @keyframes boot-pulse { 50% { box-shadow: 0 0 0 10px rgb(158 226 195 / 10%), var(--shadow); transform: translateY(-3px); } } +} diff --git a/examples/projects/modules/web/src/styles/foundation.css b/examples/projects/modules/web/src/styles/foundation.css new file mode 100644 index 00000000..504cae91 --- /dev/null +++ b/examples/projects/modules/web/src/styles/foundation.css @@ -0,0 +1,203 @@ +@layer reset { + *, + *::before, + *::after { + box-sizing: border-box; + } + + html, + body, + #app { + min-height: 100%; + } + + html { + background: #f5f6f2; + color-scheme: light; + font-synthesis: none; + text-rendering: optimizeLegibility; + -webkit-font-smoothing: antialiased; + } + + body, + h1, + h2, + h3, + h4, + p, + figure, + blockquote, + dl, + dd { + margin: 0; + } + + body { + min-width: 320px; + } + + button, + input, + select, + textarea { + color: inherit; + font: inherit; + } + + button, + [role="button"] { + cursor: pointer; + } + + img, + svg { + display: block; + max-width: 100%; + } + + ul, + ol { + margin: 0; + padding: 0; + list-style: none; + } + + table { + border-collapse: collapse; + border-spacing: 0; + } +} + +@layer tokens { + :root { + --ink-950: #071a1c; + --ink-900: #0a2426; + --ink-850: #102e30; + --ink-800: #17383a; + --ink-700: #2d5051; + --ink-600: #4f6d6c; + --ink-500: #718987; + --ink-400: #9aa9a5; + --ink-300: #c5ceca; + --ink-200: #dde3df; + --ink-150: #e9ece8; + --ink-100: #f2f4f0; + --paper: #f7f7f2; + --white: #ffffff; + --coral: #ff6b4a; + --coral-dark: #d94d31; + --coral-soft: #fff0e9; + --mint: #9ee2c3; + --mint-dark: #1e795a; + --mint-soft: #e5f8ef; + --gold: #e4b654; + --gold-soft: #fff7df; + --red: #c83852; + --red-soft: #fff0f2; + --blue: #3d71a9; + --blue-soft: #edf5ff; + --sidebar-width: 252px; + --topbar-height: 82px; + --page-gutter: clamp(24px, 3.4vw, 58px); + --radius-xs: 8px; + --radius-sm: 12px; + --radius: 18px; + --radius-lg: 26px; + --radius-xl: 34px; + --shadow-sm: 0 1px 2px rgb(7 26 28 / 5%), 0 8px 24px rgb(7 26 28 / 5%); + --shadow: 0 2px 4px rgb(7 26 28 / 4%), 0 20px 54px rgb(7 26 28 / 9%); + --shadow-float: 0 28px 80px rgb(7 26 28 / 20%); + --ease-out: cubic-bezier(0.16, 1, 0.3, 1); + --font-sans: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; + --font-display: "Avenir Next", Avenir, var(--font-sans); + } +} + +@layer base { + body { + background: + radial-gradient(circle at 76% 0%, rgb(158 226 195 / 19%), transparent 25rem), + var(--paper); + color: var(--ink-900); + font-family: var(--font-sans); + font-size: 15px; + line-height: 1.5; + } + + ::selection { + background: var(--mint); + color: var(--ink-950); + } + + :focus-visible { + outline: 3px solid rgb(255 107 74 / 30%); + outline-offset: 2px; + } + + a { + color: inherit; + text-decoration: none; + } + + h1, + h2, + h3, + h4 { + color: var(--ink-950); + font-family: var(--font-display); + font-weight: 700; + letter-spacing: -0.035em; + line-height: 1.1; + } + + h1 { + font-size: clamp(2rem, 4vw, 3.65rem); + } + + h2 { + font-size: clamp(1.35rem, 2vw, 1.9rem); + } + + h3 { + font-size: 1.08rem; + } + + button { + border: 0; + } +} + + +@layer utilities { + .sr-only { + position: absolute; + width: 1px; + height: 1px; + overflow: hidden; + clip: rect(0, 0, 0, 0); + clip-path: inset(50%); + white-space: nowrap; + } + + .tone-positive, + .positive { + color: var(--mint-dark); + } + + .tone-negative, + .negative { + color: var(--red); + } + + .text-right { + text-align: right; + } + + .nowrap { + white-space: nowrap; + } + + .mobile-only { + display: none; + } +} diff --git a/examples/projects/modules/web/src/styles/layout.css b/examples/projects/modules/web/src/styles/layout.css new file mode 100644 index 00000000..f1dd83b0 --- /dev/null +++ b/examples/projects/modules/web/src/styles/layout.css @@ -0,0 +1,279 @@ +@layer layout { + .app-shell { + display: grid; + grid-template-columns: var(--sidebar-width) minmax(0, 1fr); + min-height: 100vh; + } + + .sidebar { + position: fixed; + z-index: 40; + inset: 0 auto 0 0; + display: flex; + width: var(--sidebar-width); + flex-direction: column; + overflow: hidden; + padding: 28px 20px 22px; + background: + radial-gradient(circle at 30% 110%, rgb(158 226 195 / 13%), transparent 22rem), + linear-gradient(152deg, var(--ink-850), var(--ink-950) 76%); + color: rgb(255 255 255 / 72%); + } + + .sidebar::after { + position: absolute; + right: -68px; + bottom: 12%; + width: 150px; + height: 150px; + border: 1px solid rgb(255 255 255 / 6%); + border-radius: 50%; + box-shadow: + 0 0 0 28px rgb(255 255 255 / 2.5%), + 0 0 0 62px rgb(255 255 255 / 1.5%); + content: ""; + pointer-events: none; + } + + .brand { + position: relative; + z-index: 1; + display: flex; + align-items: center; + gap: 12px; + min-height: 46px; + padding: 0 10px; + color: var(--white); + } + + .brand-mark, + .logo-mark { + display: grid; + width: 38px; + height: 38px; + flex: 0 0 auto; + place-items: center; + border-radius: 12px; + background: var(--coral); + box-shadow: 0 9px 24px rgb(255 107 74 / 28%); + color: var(--white); + font-family: var(--font-display); + font-size: 1.1rem; + font-weight: 800; + } + + .brand-copy, + .brand-name { + display: grid; + font-family: var(--font-display); + font-size: 1rem; + font-weight: 700; + letter-spacing: -0.02em; + line-height: 1.15; + } + + .brand-copy small, + .brand-subtitle { + margin-top: 4px; + color: rgb(255 255 255 / 42%); + font-family: var(--font-sans); + font-size: 0.66rem; + font-weight: 600; + letter-spacing: 0.11em; + text-transform: uppercase; + } + + .sidebar-nav, + .nav { + position: relative; + z-index: 1; + display: grid; + gap: 6px; + margin-top: 54px; + } + + .nav-label { + padding: 0 13px 9px; + color: rgb(255 255 255 / 34%); + font-size: 0.66rem; + font-weight: 700; + letter-spacing: 0.14em; + text-transform: uppercase; + } + + .nav-item { + position: relative; + display: flex; + width: 100%; + min-height: 47px; + align-items: center; + gap: 12px; + border-radius: 13px; + padding: 0 13px; + background: transparent; + color: rgb(255 255 255 / 57%); + font-size: 0.88rem; + font-weight: 600; + text-align: left; + transition: + color 180ms ease, + background 180ms ease, + transform 180ms ease; + } + + .nav-item:hover { + background: rgb(255 255 255 / 5%); + color: var(--white); + transform: translateX(2px); + } + + .nav-item.active { + background: rgb(255 255 255 / 9%); + box-shadow: inset 0 0 0 1px rgb(255 255 255 / 5%); + color: var(--white); + } + + .nav-item.active::before { + position: absolute; + left: -20px; + width: 4px; + height: 24px; + border-radius: 0 6px 6px 0; + background: var(--coral); + box-shadow: 0 0 16px rgb(255 107 74 / 60%); + content: ""; + } + + .nav-icon, + .button-icon { + display: grid; + width: 22px; + flex: 0 0 22px; + place-items: center; + font-size: 1.03rem; + line-height: 1; + } + + .sidebar-footer, + .profile-card { + position: relative; + z-index: 1; + display: flex; + align-items: center; + gap: 10px; + margin-top: auto; + border: 1px solid rgb(255 255 255 / 7%); + border-radius: 15px; + padding: 11px; + background: rgb(255 255 255 / 4%); + } + + .avatar { + display: grid; + width: 36px; + height: 36px; + flex: 0 0 auto; + place-items: center; + border-radius: 12px; + background: var(--mint); + color: var(--ink-950); + font-size: 0.76rem; + font-weight: 800; + } + + .profile-copy { + display: grid; + min-width: 0; + color: var(--white); + font-size: 0.78rem; + font-weight: 650; + } + + .profile-copy small { + overflow: hidden; + color: rgb(255 255 255 / 38%); + font-size: 0.67rem; + font-weight: 500; + text-overflow: ellipsis; + white-space: nowrap; + } + + .page { + grid-column: 2; + min-width: 0; + min-height: 100vh; + } + + .topbar { + position: sticky; + z-index: 30; + top: 0; + display: flex; + height: var(--topbar-height); + align-items: center; + justify-content: space-between; + gap: 22px; + border-bottom: 1px solid rgb(7 26 28 / 6%); + padding: 0 var(--page-gutter); + background: rgb(247 247 242 / 84%); + backdrop-filter: blur(20px) saturate(130%); + } + + .topbar-title { + display: grid; + gap: 2px; + } + + .topbar-title strong { + font-family: var(--font-display); + font-size: 1rem; + letter-spacing: -0.02em; + } + + .topbar-title span, + .topbar-subtitle { + color: var(--ink-500); + font-size: 0.74rem; + } + + .topbar-actions { + display: flex; + align-items: center; + gap: 9px; + } + + .page-content, + .content { + width: min(100%, 1560px); + margin-inline: auto; + padding: 34px var(--page-gutter) 64px; + } + + .page-header { + display: flex; + align-items: end; + justify-content: space-between; + gap: 24px; + margin-bottom: 28px; + } + + .page-header-copy { + display: grid; + gap: 8px; + } + + .page-header p, + .lede, + .muted { + color: var(--ink-500); + } + + .section-grid, + .dashboard-grid { + display: grid; + grid-template-columns: minmax(0, 1.45fr) minmax(300px, 0.72fr); + gap: 20px; + align-items: start; + } +} + diff --git a/examples/projects/modules/web/src/styles/pages.css b/examples/projects/modules/web/src/styles/pages.css new file mode 100644 index 00000000..7d6b7399 --- /dev/null +++ b/examples/projects/modules/web/src/styles/pages.css @@ -0,0 +1,89 @@ +/* The selectors below are the concrete Osprey client vocabulary. Keeping this + map together makes it obvious that React receives semantic view data rather + than a parallel hand-authored component application. */ +@layer components { + .app-main { grid-column: 2; min-width: 0; } + .main-nav { position: relative; z-index: 1; display: grid; gap: 5px; margin-top: 48px; } + .nav-item .nav-label { padding: 0; color: inherit; font-size: inherit; letter-spacing: normal; text-transform: none; } + .nav-section-label { padding: 0 13px 8px; color: rgb(255 255 255 / 32%); font-size: .61rem; font-weight: 800; letter-spacing: .15em; } + .nav-section-label.secondary { margin-top: 25px; } + .sidebar-bottom { position: relative; z-index: 1; display: grid; gap: 12px; margin-top: auto; } + .secure-chip { display: flex; align-items: center; gap: 8px; padding: 9px 12px; border: 1px solid rgb(158 226 195 / 12%); border-radius: 11px; background: rgb(158 226 195 / 7%); color: var(--mint); font-size: .66rem; font-weight: 700; } + .sidebar-profile { display: grid; grid-template-columns: 36px minmax(0,1fr) auto; align-items: center; gap: 10px; padding: 11px; border: 1px solid rgb(255 255 255 / 7%); border-radius: 15px; background: rgb(255 255 255 / 4%); } + .sidebar-profile > span:nth-child(2) { display: grid; min-width: 0; color: white; font-size: .75rem; } + .sidebar-profile small { color: rgb(255 255 255 / 38%); font-size: .65rem; } + .profile-more { color: rgb(255 255 255 / 30%); letter-spacing: .08em; } + .page { display: grid; gap: 26px; animation: page-enter 360ms var(--ease-out) both; } + .overview-page,.accounts-page,.activity-page,.move-page,.security-page,.loading-page { isolation: isolate; } + .page-heading,.section-heading { display: flex; align-items: end; justify-content: space-between; gap: 20px; } + .page-heading > div,.section-heading > div { display: grid; gap: 7px; } + .page-heading p { max-width: 620px; color: var(--ink-500); } + .section-block { display: grid; gap: 17px; } + .section-block.card { gap: 0; padding: 4px 24px 12px; } + .section-block.card .section-heading { min-height: 78px; border-bottom: 1px solid var(--ink-150); } + .text-button,.toast-close { display: inline-flex; align-items: center; gap: 8px; padding: 7px; background: transparent; color: var(--mint-dark); font-size: .73rem; font-weight: 750; } + .icon-button .button-label,.toast-close .button-label { display: none; } + .ghost-on-dark { border: 1px solid rgb(255 255 255 / 15%); background: rgb(255 255 255 / 7%); box-shadow: none; } + .notification-button { position: relative; } + .mobile-menu { display: none; } + .notification-dot { position: absolute; top: 8px; right: 8px; width: 7px; height: 7px; border: 2px solid var(--paper); border-radius: 50%; background: var(--coral); } + .top-progress { position: fixed; z-index: 80; top: var(--topbar-height); right: 0; left: var(--sidebar-width); height: 2px; overflow: hidden; background: rgb(255 107 74 / 15%); } + .top-progress::after { display: block; width: 38%; height: 100%; background: var(--coral); content: ""; animation: progress 900ms ease-in-out infinite; } + .hero-card { grid-template-columns: minmax(0,1fr) minmax(210px,.6fr); align-items: center; } + .hero-copy { position: relative; z-index: 2; display: grid; justify-items: start; } + .hero-copy h1 { margin-top: 10px; color: white; font-size: clamp(2.7rem,5.4vw,4.8rem); letter-spacing: -.07em; } + .hero-copy > p { margin-top: 10px; color: rgb(255 255 255 / 52%); } + .hero-copy .hero-actions { margin-top: 28px; } + .hero-art { position: relative; min-height: 165px; } + .hero-monogram { position: absolute; z-index: 2; top: 50%; left: 50%; display: grid; width: 90px; height: 90px; place-items: center; border: 1px solid rgb(255 255 255 / 20%); border-radius: 29px; background: rgb(255 255 255 / 10%); box-shadow: 0 24px 45px rgb(0 0 0 / 22%); color: white; font-family: var(--font-display); font-size: 2rem; font-weight: 800; transform: translate(-50%,-50%) rotate(8deg); backdrop-filter: blur(10px); } + .orb { position: absolute; border-radius: 50%; filter: blur(.1px); } + .orb-one { top: 2px; right: 4%; width: 120px; height: 120px; background: rgb(158 226 195 / 14%); } + .orb-two { right: 43%; bottom: -5px; width: 76px; height: 76px; background: rgb(255 107 74 / 22%); } + .stat-card { display: grid; grid-template-columns: 45px minmax(0,1fr); align-items: center; gap: 14px; } + .stat-icon { display: grid; width: 44px; height: 44px; place-items: center; border-radius: 14px; background: var(--mint-soft); color: var(--mint-dark); font-size: 1rem; font-weight: 800; } + .stat-copy { position: relative; z-index: 1; display: grid; } + .stat-copy small,.stat-copy em { color: var(--ink-500); font-size: .66rem; font-style: normal; } + .stat-copy strong { margin-block: 3px; font-family: var(--font-display); font-size: 1.45rem; letter-spacing: -.04em; } + .account-mark { display: grid; width: 36px; height: 36px; place-items: center; border-radius: 12px; background: var(--mint-soft); color: var(--mint-dark); font-family: var(--font-display); font-weight: 800; } + .account-mark.violet,.account-card.violet .account-mark { background: #f0edff; color: #6556ae; } + .account-card.deposit .account-mark { background: var(--mint-soft); }.account-card.withdraw .account-mark { background: var(--gold-soft); color: #92701e; } + .account-card > small { position: relative; z-index: 1; color: var(--ink-500); font-size: .65rem; } + .account-more { color: var(--ink-400); letter-spacing: .08em; } + .account-grid-wide { grid-template-columns: repeat(3,minmax(0,1fr)); } + .account-detail-grid { display: grid; grid-template-columns: minmax(0,1.25fr) minmax(320px,.75fr); gap: 20px; align-items: start; } + .account-detail { overflow: hidden; padding: 28px; } + .detail-heading { display: flex; align-items: center; justify-content: space-between; gap: 18px; } + .detail-heading > div { display: flex; align-items: center; gap: 13px; }.detail-heading small { color: var(--ink-500); font-size: .63rem; } + .status-pill { display: inline-flex; align-items: center; border-radius: 999px; padding: 6px 10px; background: var(--ink-100); color: var(--ink-600); font-size: .64rem; font-weight: 750; } + .status-pill.success { background: var(--mint-soft); color: var(--mint-dark); } + .detail-balance { display: grid; gap: 4px; margin: 32px -28px 24px; padding: 28px; background: linear-gradient(110deg,var(--ink-100),transparent); } + .detail-balance small,.detail-balance span { color: var(--ink-500); font-size: .71rem; }.detail-balance strong { font: 700 clamp(2rem,4vw,3.25rem)/1 var(--font-display); letter-spacing: -.06em; } + .detail-actions { display: flex; flex-wrap: wrap; gap: 9px; }.detail-facts { display: grid; grid-template-columns: repeat(3,1fr); gap: 12px; margin-top: 25px; } + .detail-facts > div { display: grid; gap: 3px; padding: 13px; border-radius: 12px; background: var(--ink-100); }.detail-facts dt { color: var(--ink-500); font-size: .61rem; }.detail-facts dd { font-size: .72rem; font-weight: 700; } + .compact-activity { padding: 8px 22px 12px; }.compact-activity .section-heading { min-height: 70px; border-bottom: 1px solid var(--ink-150); } + .movement-row { display: grid; grid-template-columns: 42px minmax(0,1fr) auto; align-items: center; gap: 14px; min-height: 76px; border-bottom: 1px solid var(--ink-150); padding: 12px 0; }.movement-row:last-child { border-bottom: 0; } + .movement-icon { display: grid; width: 40px; height: 40px; place-items: center; border-radius: 13px; background: var(--mint-soft); color: var(--mint-dark); font-weight: 800; }.movement-icon.debit { background: var(--gold-soft); color: #96701e; }.movement-icon.refused { background: var(--red-soft); color: var(--red); } + .movement-copy,.movement-meta { display: grid; min-width: 0; }.movement-copy strong { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: .8rem; }.movement-copy small,.movement-meta small { color: var(--ink-500); font-size: .67rem; } + .movement-meta { justify-items: end; }.movement-amount { font-size: .79rem; font-variant-numeric: tabular-nums; }.movement-amount.credit { color: var(--mint-dark); }.movement-amount.refused { color: var(--red); text-decoration: line-through; } + .mini-stat-grid { display: grid; grid-template-columns: repeat(4,1fr); gap: 12px; }.mini-stat { display: flex; align-items: center; gap: 11px; border: 1px solid var(--ink-150); border-radius: 15px; padding: 15px; background: rgb(255 255 255 / 66%); }.mini-stat > span { font-size: 1rem; }.mini-stat div { display: grid; }.mini-stat small { color: var(--ink-500); font-size: .62rem; }.mini-stat strong { font-size: 1rem; } + .ledger-card { overflow: hidden; padding: 0 24px 12px; }.ledger-toolbar { display: flex; align-items: center; justify-content: space-between; gap: 15px; min-height: 82px; border-bottom: 1px solid var(--ink-150); }.ledger-toolbar .search-box { flex: 1; max-width: 360px; }.search-box > span { position: absolute; z-index: 1; top: 50%; left: 14px; transform: translateY(-50%); }.search-box input { width: 100%; height: 44px; border: 1px solid var(--ink-200); border-radius: 13px; outline: none; padding: 0 14px 0 39px; background: white; font-size: .76rem; }.search-box input:focus { border-color: var(--mint-dark); box-shadow: 0 0 0 4px rgb(30 121 90 / 10%); } + .activity-list-full .movement-row { min-height: 82px; } + .move-grid,.security-grid { display: grid; grid-template-columns: minmax(0,1.2fr) minmax(300px,.7fr); gap: 20px; align-items: start; }.move-tabs { width: min(100%,560px); } + .form-card { padding: clamp(22px,3vw,34px); }.money-form,.modal-form { display: grid; gap: 24px; }.form-intro { display: flex; align-items: center; gap: 14px; }.form-intro > div { display: grid; gap: 5px; }.form-intro p { color: var(--ink-500); font-size: .75rem; } + .form-icon { display: grid; width: 50px; height: 50px; place-items: center; border-radius: 16px; background: var(--mint-soft); color: var(--mint-dark); font-size: 1.15rem; }.form-icon.withdraw { background: var(--gold-soft); color: #8e6b18; }.form-icon.transfer { background: #f0edff; color: #6556ae; } + .money-input { position: relative; }.money-input > span { position: absolute; z-index: 1; top: 50%; left: 15px; color: var(--ink-500); transform: translateY(-50%); }.money-input input { padding-left: 30px; font-size: 1rem; font-weight: 700; } + .amount-field { min-width: 0; } + .paired-fields { grid-column: 1/-1; display: grid; grid-template-columns: 1fr auto 1fr; align-items: end; gap: 12px; }.swap-mark { display: grid; width: 36px; height: 48px; place-items: center; color: var(--ink-400); }.submit-button { grid-column: 1/-1; justify-self: end; min-width: 160px; } + .guidance-card { overflow: hidden; padding: 28px; background: linear-gradient(150deg,var(--ink-900),var(--ink-950)); color: rgb(255 255 255 / 68%); }.guidance-card h2 { margin-top: 8px; color: white; }.tip-list { display: grid; gap: 17px; margin-top: 28px; }.tip-list li { display: grid; grid-template-columns: 35px 1fr; gap: 11px; }.tip-list li > span:last-child { display: grid; }.tip-list small { color: rgb(255 255 255 / 45%); font-size: .67rem; }.tip-icon { display: grid; width: 34px; height: 34px; place-items: center; border-radius: 11px; background: rgb(158 226 195 / 10%); color: var(--mint); } + .shield-seal { display: flex; align-items: center; gap: 10px; margin-top: 30px; padding-top: 20px; border-top: 1px solid rgb(255 255 255 / 8%); font-size: .69rem; }.shield-seal strong { display: grid; width: 30px; height: 30px; place-items: center; border-radius: 10px; background: var(--coral); color: white; } + .security-hero { display: grid; grid-template-columns: .55fr 1fr; align-items: center; min-height: 285px; overflow: hidden; border-radius: var(--radius-xl); padding: 32px; background: linear-gradient(135deg,var(--ink-950),var(--ink-850)); color: white; }.security-hero-copy { display: grid; justify-items: start; gap: 13px; }.security-hero-copy h2 { color: white; font-size: clamp(1.8rem,3.4vw,3rem); }.security-hero-copy p { color: rgb(255 255 255 / 53%); } + .security-orbit { position: relative; min-height: 210px; }.security-orbit > strong { position: absolute; z-index: 2; top: 50%; left: 50%; display: grid; width: 66px; height: 66px; place-items: center; border-radius: 22px; background: var(--coral); font: 800 1.6rem var(--font-display); transform: translate(-50%,-50%); }.orbit-ring { position: absolute; top: 50%; left: 50%; border: 1px solid rgb(158 226 195 / 18%); border-radius: 50%; transform: translate(-50%,-50%); }.ring-one { width: 140px; height: 140px; }.ring-two { width: 205px; height: 205px; } + .security-card,.architecture-card { padding: 26px; }.security-list { display: grid; margin-top: 18px; }.security-control { display: grid; grid-template-columns: 40px minmax(0,1fr) auto; align-items: center; gap: 12px; border-bottom: 1px solid var(--ink-150); padding: 15px 0; }.security-control:last-child { border: 0; }.security-icon { display: grid; width: 39px; height: 39px; place-items: center; border-radius: 12px; background: var(--mint-soft); color: var(--mint-dark); }.security-copy { display: grid; }.security-copy small { color: var(--ink-500); font-size: .65rem; } + .architecture-lead { margin-top: 10px; color: var(--ink-500); font-size: .76rem; }.architecture-stack { display: grid; gap: 11px; margin-top: 22px; }.architecture-layer { display: grid; grid-template-columns: 36px 1fr; gap: 12px; padding: 15px; border-radius: 14px; background: var(--ink-100); }.layer-number { color: var(--coral-dark); font-size: .67rem; font-weight: 800; }.architecture-layer small { color: var(--ink-500); font-size: .57rem; letter-spacing: .08em; }.architecture-layer h3 { margin-block: 3px; font-size: .85rem; }.architecture-layer p { color: var(--ink-500); font-size: .65rem; } + .modal-form { padding: 28px; }.modal-heading { display: flex; align-items: start; justify-content: space-between; gap: 18px; }.modal-heading > div { display: grid; gap: 6px; }.modal-heading p { color: var(--ink-500); font-size: .74rem; }.modal-reassurance { display: flex; gap: 10px; border-radius: 13px; padding: 13px; background: var(--mint-soft); color: var(--mint-dark); font-size: .69rem; }.modal-actions { display: flex; justify-content: flex-end; gap: 9px; } + .toast-copy small { color: rgb(255 255 255 / 63%); font-size: .7rem; } + .topbar-title small { color: var(--ink-500); font-size: .63rem; font-weight: 700; letter-spacing: .06em; } + .skeleton-hero { height: 230px; border-radius: var(--radius-xl); }.skeleton-grid { display: grid; grid-template-columns: repeat(3,1fr); gap: 15px; }.skeleton-grid .skeleton { height: 105px; }.skeleton-table { height: 330px; border-radius: var(--radius-lg); } + @keyframes page-enter { from { opacity: 0; transform: translateY(7px); } } + @keyframes progress { from { transform: translateX(-110%); } to { transform: translateX(280%); } } +} diff --git a/examples/projects/modules/web/src/styles/responsive.css b/examples/projects/modules/web/src/styles/responsive.css new file mode 100644 index 00000000..6ce35974 --- /dev/null +++ b/examples/projects/modules/web/src/styles/responsive.css @@ -0,0 +1,237 @@ +@layer responsive { + @media (max-width: 860px) { + .app-main { grid-column: auto; } + .mobile-menu { display: inline-flex; } + .top-progress { left: 0; } + .hero-card { grid-template-columns: 1fr; } + .hero-art { position: absolute; right: 15px; width: 42%; opacity: .8; } + .account-detail-grid,.move-grid,.security-grid { grid-template-columns: 1fr; } + .mini-stat-grid { grid-template-columns: repeat(2,1fr); } + .ledger-toolbar { align-items: stretch; flex-direction: column; padding-block: 16px; } + .ledger-toolbar .search-box { width: 100%; max-width: none; } + } + @media (max-width: 620px) { + .page-heading,.section-heading { align-items: stretch; flex-direction: column; } + .account-grid-wide,.mini-stat-grid,.skeleton-grid { grid-template-columns: 1fr; } + .detail-facts { grid-template-columns: 1fr; } + .paired-fields { grid-template-columns: 1fr; }.swap-mark { width: 100%; height: 20px; transform: rotate(90deg); } + .security-hero { grid-template-columns: 1fr; }.security-orbit { min-height: 165px; } + .movement-row { grid-template-columns: 38px minmax(0,1fr) auto; gap: 9px; } + .modal-actions { align-items: stretch; flex-direction: column-reverse; }.modal-actions .button { width: 100%; } + } +} + +@layer responsive { + @media (max-width: 1180px) { + :root { + --sidebar-width: 222px; + } + + .account-grid { + grid-template-columns: repeat(2, minmax(0, 1fr)); + } + + .section-grid, + .dashboard-grid { + grid-template-columns: 1fr; + } + } + + @media (max-width: 860px) { + :root { + --topbar-height: 70px; + } + + .app-shell { + display: block; + } + + .sidebar { + width: min(82vw, 300px); + box-shadow: var(--shadow-float); + transform: translateX(-105%); + transition: transform 280ms var(--ease-out); + } + + .app-shell.menu-open .sidebar, + .sidebar.open { + transform: translateX(0); + } + + .page { + min-height: 100vh; + } + + .menu-button, + .mobile-only { + display: inline-flex; + } + + .topbar { + padding-inline: 20px; + } + + .page-content, + .content { + padding: 24px 20px 50px; + } + + .page-header { + align-items: start; + } + + .hero-card { + min-height: 200px; + } + + .stat-grid, + .tiles { + grid-template-columns: repeat(2, minmax(0, 1fr)); + } + + .stat-grid > :first-child:last-child, + .stat-grid > :last-child:nth-child(odd), + .tiles > :last-child:nth-child(odd) { + grid-column: 1 / -1; + } + } + + @media (max-width: 620px) { + body { + font-size: 14px; + } + + .topbar-title span, + .topbar-subtitle { + display: none; + } + + .topbar-actions .button-label { + display: none; + } + + .topbar-actions .btn, + .topbar-actions .button { + width: 43px; + padding: 0; + } + + .page-header { + display: grid; + gap: 18px; + } + + .page-header > .button, + .page-header > .btn, + .page-header-actions { + width: 100%; + } + + .page-header-actions .button, + .page-header-actions .btn { + flex: 1; + } + + .hero-card { + border-radius: 25px; + padding: 26px 22px; + } + + .hero-value { + font-size: 2.7rem; + } + + .hero-meta { + align-items: start; + flex-direction: column; + } + + .stat-grid, + .tiles, + .account-grid, + .form-grid { + grid-template-columns: 1fr; + } + + .stat-grid > :last-child:nth-child(odd), + .tiles > :last-child:nth-child(odd) { + grid-column: auto; + } + + .card { + border-radius: 20px; + } + + .card-header, + .card-body { + padding-inline: 18px; + } + + .card-header { + align-items: start; + flex-direction: column; + } + + .account-card { + min-height: 165px; + } + + .activity-item, + .feed li { + grid-template-columns: 38px minmax(0, 1fr) auto; + gap: 10px; + } + + .activity-icon, + .kind { + width: 36px; + height: 36px; + } + + .modal-backdrop { + align-items: end; + padding: 0; + } + + .modal { + max-height: 94vh; + overflow-y: auto; + border-radius: 26px 26px 0 0; + } + + .modal-header, + .modal-body { + padding-inline: 22px; + } + + .form-actions { + align-items: stretch; + flex-direction: column-reverse; + } + + .form-actions .btn, + .form-actions .button { + width: 100%; + } + + .toast { + right: 16px; + bottom: 16px; + } + + .hide-mobile { + display: none !important; + } + } + + @media (prefers-reduced-motion: reduce) { + *, + *::before, + *::after { + scroll-behavior: auto !important; + animation-duration: 0.01ms !important; + animation-iteration-count: 1 !important; + transition-duration: 0.01ms !important; + } + } +} diff --git a/examples/projects/modules/web/src/wasi.js b/examples/projects/modules/web/src/wasi.js new file mode 100644 index 00000000..d717e41f --- /dev/null +++ b/examples/projects/modules/web/src/wasi.js @@ -0,0 +1,102 @@ +// Small WASI Preview 1 host for Osprey command modules. Browser applications +// do not need a virtual filesystem, but wasi-libc still imports a handful of +// process, clock, random and stdio functions. + +const ESUCCESS = 0; +const ENOSYS = 52; +const textDecoder = new TextDecoder("utf-8"); + +function dataView(state) { + if (!state.memory) throw new Error("WASI memory is not attached"); + return new DataView(state.memory.buffer); +} + +function bytes(state) { + if (!state.memory) throw new Error("WASI memory is not attached"); + return new Uint8Array(state.memory.buffer); +} + +function flushPending(state, write) { + if (!state.pending) return; + write(state.pending); + state.pending = ""; +} + +function fdWrite(state, flush, fd, iovs, iovsLength, writtenPointer) { + const view = dataView(state); + let count = 0; + let output = ""; + for (let index = 0; index < iovsLength; index += 1) { + const pointer = view.getUint32(iovs + index * 8, true); + const length = view.getUint32(iovs + index * 8 + 4, true); + output += textDecoder.decode(bytes(state).subarray(pointer, pointer + length)); + count += length; + } + view.setUint32(writtenPointer, count, true); + if (fd === 1 || fd === 2) { + state.pending += output; + if (output.includes("\n")) flush(); + } + return ESUCCESS; +} + +function zeroPair(state, countPointer, sizePointer) { + const view = dataView(state); + view.setUint32(countPointer, 0, true); + view.setUint32(sizePointer, 0, true); + return ESUCCESS; +} + +function stdioCalls(state, flush) { + return { + fd_write: (...args) => fdWrite(state, flush, ...args), + proc_exit: () => { + flush(); + return ESUCCESS; + }, + fd_close: () => ESUCCESS, + fd_seek: () => ESUCCESS, + fd_fdstat_get: () => ESUCCESS, + fd_fdstat_set_flags: () => ESUCCESS, + }; +} + +function platformCalls(state) { + return { + environ_sizes_get: (...args) => zeroPair(state, ...args), + environ_get: () => ESUCCESS, + args_sizes_get: (...args) => zeroPair(state, ...args), + args_get: () => ESUCCESS, + clock_time_get: (_clock, _precision, outputPointer) => { + dataView(state).setBigUint64(outputPointer, BigInt(Date.now()) * 1_000_000n, true); + return ESUCCESS; + }, + random_get: (pointer, length) => { + globalThis.crypto.getRandomValues(bytes(state).subarray(pointer, pointer + length)); + return ESUCCESS; + }, + sched_yield: () => ESUCCESS, + poll_oneoff: () => ENOSYS, + }; +} + +function importsFor(implementations) { + return new Proxy(implementations, { + get(target, property) { + return target[property] ?? (() => ENOSYS); + }, + }); +} + +export function createWasi(write = (text) => console.debug(text.trimEnd())) { + const state = { memory: null, pending: "" }; + const flush = () => flushPending(state, write); + const implementations = { ...stdioCalls(state, flush), ...platformCalls(state) }; + return { + imports: importsFor(implementations), + setMemory(nextMemory) { + state.memory = nextMemory; + }, + flush, + }; +} diff --git a/examples/projects/modules/web/test/embed.test.mjs b/examples/projects/modules/web/test/embed.test.mjs new file mode 100644 index 00000000..158a1643 --- /dev/null +++ b/examples/projects/modules/web/test/embed.test.mjs @@ -0,0 +1,33 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { mkdtemp, readFile, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import path from "node:path"; +import { embed } from "../scripts/embed.mjs"; + +async function embedFixture() { + const directory = await mkdtemp(path.join(tmpdir(), "osprey-web-")); + const javascriptPath = path.join(directory, "host.js"); + const cssPath = path.join(directory, "host.css"); + const wasmPath = path.join(directory, "client.wasm"); + const outputPath = path.join(directory, "bundle.ospml"); + await Promise.all([ + writeFile(javascriptPath, 'const wasm="__OSPREY_WASM_BASE64__";const label="route";'), + writeFile(cssPath, ':root{color:#123}'), + writeFile(wasmPath, Buffer.from([0, 97, 115, 109])), + ]); + return { javascriptPath, cssPath, wasmPath, outputPath }; +} + +async function embedsRawAssets() { + const fixture = await embedFixture(); + await embed(fixture); + const generated = await readFile(fixture.outputPath, "utf8"); + assert.match(generated, /namespace "bank\/web"/); + assert.match(generated, /style \(\) = ":root\{color:#123\}"/); + assert.match(generated, /AGFzbQ==/); + assert.doesNotMatch(generated, /

    Osprey cross-language benchmarks

    -

    Osprey, Osprey (GC), Rust, C, OCaml, Haskell, Osprey (wasm), Rust (wasm) — same naive algorithm and parameters in every language, native +

    Osprey, Osprey (ARC), Osprey (GC), Rust, C, C# (AOT), Dart (AOT), OCaml, Haskell, Osprey (wasm), Rust (wasm) — same naive algorithm and parameters in every language, native release builds, output checked against an integer oracle. CPU = hyperfine mean ± stddev; memory = peak resident set size. Generated mechanically by benchmarks/report.py; re-run with make bench.

    -
    1CPU wins (fastest of all)
    1.42×CPU vs Rust
    1.61×CPU vs C
    1.09×CPU vs OCaml
    0.76×CPU vs Haskell
    0.71×CPU vs Rust (wasm)

    Osprey is the fastest of all five languages on primes. Lower is better; ★ marks an Osprey win.

    +
    0CPU wins (fastest of all)
    2.32×CPU vs Rust
    2.65×CPU vs C
    1.89×CPU vs C# (AOT)
    0.95×CPU vs Dart (AOT)
    1.82×CPU vs OCaml
    1.27×CPU vs Haskell
    1.18×CPU vs Rust (wasm)

    Osprey is the fastest of all five languages on —. Lower is better; ★ marks an Osprey win.

    CPU time

    -
    BenchmarkOspreyOsprey (GC)RustCOCamlHaskellOsprey (wasm)Rust (wasm)
    ackermann127.4 ms126.6 ms128.6 ms126.3 ms110.8 ms65.1 ms130.6 ms136.1 ms
    binarytrees417.1 ms1.498 s711.9 ms348.2 ms50.2 ms17.0 ms516.0 ms793.0 ms
    coins72.1 ms70.2 ms73.9 ms69.0 ms91.4 ms52.2 ms92.1 ms100.5 ms
    collatz12.5 ms11.8 ms11.2 ms9.1 ms53.8 ms35.0 ms19.2 ms22.6 ms
    coprime62.9 ms61.3 ms59.1 ms58.3 ms86.9 ms100.1 ms69.4 ms71.3 ms
    digitsum5.2 ms5.1 ms5.3 ms5.2 ms18.5 ms29.7 ms12.3 ms17.3 ms
    exprtree6.7 ms20.6 ms10.2 ms5.7 ms5.2 ms16.6 ms—19.8 ms
    factorial33.9 ms31.7 ms32.0 ms32.0 ms44.0 ms52.5 ms42.0 ms45.8 ms
    fib20.5 ms20.5 ms16.2 ms17.8 ms23.8 ms45.1 ms32.8 ms36.6 ms
    gcdsum75.3 ms71.7 ms71.2 ms71.7 ms96.9 ms100.2 ms79.1 ms82.7 ms
    hanoi39.0 ms36.3 ms36.4 ms36.1 ms59.9 ms53.5 ms47.5 ms51.1 ms
    isqrt12.6 ms12.2 ms10.1 ms9.6 ms19.1 ms40.6 ms23.7 ms21.3 ms
    josephus32.1 ms30.9 ms30.2 ms30.3 ms37.8 ms43.0 ms36.9 ms40.5 ms
    listops499.2 ms651.0 ms1.5 ms1.3 ms2.0 ms16.7 ms—13.1 ms
    mutual12.6 ms11.9 ms12.0 ms11.7 ms28.6 ms34.8 ms23.7 ms28.1 ms
    nestedloop43.6 ms41.4 ms43.2 ms42.0 ms52.3 ms63.6 ms54.3 ms58.0 ms
    pascal27.6 ms26.6 ms27.0 ms26.9 ms43.5 ms57.8 ms42.4 ms47.0 ms
    powmod22.6 ms21.5 ms21.8 ms21.7 ms56.3 ms55.3 ms28.4 ms31.7 ms
    primes6.3 ms ★6.4 ms7.1 ms6.7 ms8.7 ms15.8 ms12.5 ms16.3 ms
    tak32.6 ms32.4 ms32.2 ms32.7 ms43.8 ms63.2 ms85.4 ms91.1 ms
    textstats3.2 ms3.4 ms2.0 ms2.1 ms4.0 ms17.7 ms—12.2 ms
    wordfreq19.3 ms53.3 ms4.4 ms1.5 ms2.4 ms18.4 ms—15.3 ms
    +
    BenchmarkOspreyOsprey (ARC)Osprey (GC)RustCC# (AOT)Dart (AOT)OCamlHaskellOsprey (wasm)Rust (wasm)
    ackermann134.6 ms131.2 ms129.8 ms130.0 ms129.5 ms132.4 ms186.4 ms111.9 ms65.4 ms146.1 ms146.4 ms
    binarytrees555.1 ms1.957 s3.177 s752.6 ms367.3 ms127.7 ms126.9 ms52.3 ms16.3 ms573.7 ms809.2 ms
    coins78.2 ms78.2 ms78.3 ms82.5 ms77.6 ms101.5 ms122.4 ms100.5 ms52.2 ms101.1 ms111.1 ms
    collatz104.9 ms263.3 ms251.2 ms12.5 ms10.2 ms57.0 ms67.0 ms59.2 ms40.5 ms88.0 ms24.2 ms
    coprime67.8 ms67.8 ms67.8 ms65.2 ms63.4 ms77.1 ms106.3 ms90.7 ms103.9 ms75.9 ms77.2 ms
    digitsum137.5 ms375.3 ms358.5 ms5.4 ms5.4 ms16.3 ms28.9 ms18.9 ms29.7 ms104.6 ms18.0 ms
    exprtree8.0 ms26.5 ms27.5 ms10.9 ms6.2 ms6.4 ms13.3 ms5.1 ms16.1 ms—20.2 ms
    factorial261.3 ms843.1 ms666.2 ms35.5 ms35.1 ms37.2 ms51.4 ms48.5 ms53.8 ms196.5 ms48.8 ms
    fib21.1 ms21.0 ms21.2 ms17.3 ms17.7 ms35.9 ms51.6 ms23.9 ms48.4 ms33.0 ms36.7 ms
    gcdsum79.3 ms79.4 ms79.4 ms79.1 ms79.0 ms86.3 ms108.8 ms101.4 ms106.1 ms86.6 ms91.0 ms
    hanoi38.1 ms38.0 ms38.4 ms36.9 ms38.4 ms38.5 ms103.0 ms62.4 ms57.9 ms47.7 ms51.3 ms
    isqrt308.1 ms855.7 ms807.4 ms11.0 ms10.4 ms16.9 ms32.9 ms20.5 ms43.7 ms285.8 ms22.8 ms
    josephus33.3 ms33.3 ms33.3 ms33.5 ms32.9 ms34.9 ms42.1 ms41.1 ms43.7 ms38.5 ms41.9 ms
    listops531.7 ms1.088 s660.5 ms1.4 ms1.2 ms2.9 ms9.8 ms1.9 ms18.1 ms—11.4 ms
    mutual11.8 ms11.1 ms10.8 ms11.6 ms11.7 ms19.1 ms297.7 ms28.6 ms32.6 ms23.4 ms27.0 ms
    nestedloop45.2 ms43.8 ms41.4 ms42.1 ms41.3 ms43.4 ms54.4 ms53.2 ms60.4 ms60.7 ms64.8 ms
    pascal28.4 ms28.5 ms28.4 ms28.3 ms27.8 ms33.4 ms64.7 ms44.3 ms59.7 ms43.4 ms47.1 ms
    powmod23.3 ms23.3 ms23.4 ms23.4 ms23.4 ms34.1 ms50.5 ms60.7 ms58.1 ms30.0 ms33.9 ms
    primes6.5 ms6.5 ms6.5 ms6.7 ms6.5 ms8.6 ms44.1 ms8.5 ms17.3 ms13.1 ms17.1 ms
    tak32.9 ms32.5 ms32.7 ms32.8 ms32.6 ms34.9 ms81.9 ms44.4 ms64.7 ms86.6 ms90.4 ms
    textstats3.5 ms5.1 ms3.6 ms2.0 ms2.1 ms3.7 ms11.0 ms3.8 ms17.3 ms—12.6 ms
    wordfreq22.6 ms78.0 ms70.9 ms4.5 ms1.5 ms3.3 ms10.6 ms2.3 ms17.3 ms—15.6 ms

    Peak memory

    -
    BenchmarkOspreyOsprey (GC)RustCOCamlHaskellOsprey (wasm)Rust (wasm)
    ackermann1.6 MiB ★1.7 MiB1.8 MiB1.6 MiB2.6 MiB15.1 MiB——
    binarytrees905.0 MiB12.3 MiB2.1 MiB1.7 MiB5.1 MiB11.0 MiB——
    coins1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    collatz1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    coprime1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    digitsum1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    exprtree9.0 MiB6.5 MiB2.7 MiB11.5 MiB6.0 MiB11.4 MiB——
    factorial1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    fib1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    gcdsum1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    hanoi1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    isqrt1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    josephus1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    listops2493.5 MiB4.1 MiB1.6 MiB1.4 MiB2.5 MiB11.3 MiB——
    mutual1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    nestedloop1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.0 MiB——
    pascal1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    powmod1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    primes1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    tak1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    textstats1.4 MiB1.5 MiB1.6 MiB1.4 MiB2.3 MiB11.4 MiB——
    wordfreq52.8 MiB4.4 MiB1.6 MiB1.4 MiB2.3 MiB11.3 MiB——
    +
    BenchmarkOspreyOsprey (ARC)Osprey (GC)RustCC# (AOT)Dart (AOT)OCamlHaskellOsprey (wasm)Rust (wasm)
    ackermann1.7 MiB1.7 MiB1.7 MiB1.8 MiB1.7 MiB7.1 MiB14.2 MiB2.7 MiB15.1 MiB——
    binarytrees905.1 MiB487.5 MiB27.5 MiB2.2 MiB1.7 MiB16.1 MiB22.5 MiB5.2 MiB11.1 MiB——
    coins1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.5 MiB6.9 MiB13.9 MiB2.3 MiB11.1 MiB——
    collatz221.7 MiB65.5 MiB6.6 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    coprime1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    digitsum335.1 MiB65.5 MiB6.6 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    exprtree9.0 MiB6.7 MiB15.2 MiB2.7 MiB11.5 MiB15.2 MiB22.7 MiB6.1 MiB11.4 MiB——
    factorial614.2 MiB129.5 MiB6.6 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.2 MiB11.1 MiB——
    fib1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.9 MiB13.9 MiB2.3 MiB11.1 MiB——
    gcdsum1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    hanoi1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    isqrt779.1 MiB257.5 MiB8.3 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    josephus1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.1 MiB2.3 MiB11.1 MiB——
    listops2493.5 MiB3383.9 MiB3.8 MiB1.7 MiB1.5 MiB7.1 MiB14.3 MiB2.6 MiB11.4 MiB——
    mutual1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB13.9 MiB2.3 MiB11.1 MiB——
    nestedloop1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.9 MiB13.9 MiB2.2 MiB11.1 MiB——
    pascal1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    powmod1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB13.9 MiB2.3 MiB11.1 MiB——
    primes1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.2 MiB11.1 MiB——
    tak1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    textstats1.5 MiB1.6 MiB1.5 MiB1.6 MiB1.5 MiB6.8 MiB14.1 MiB2.3 MiB11.4 MiB——
    wordfreq59.0 MiB91.9 MiB4.7 MiB1.6 MiB1.4 MiB6.8 MiB14.2 MiB2.3 MiB11.4 MiB——
    diff --git a/benchmarks/results/results.json b/benchmarks/results/results.json index 176e523b..df4cf528 100644 --- a/benchmarks/results/results.json +++ b/benchmarks/results/results.json @@ -1,9 +1,12 @@ { "languages": [ "osprey", + "osprey-arc", "osprey-gc", "rust", "c", + "csharp", + "dart", "ocaml", "haskell", "osprey-wasm", @@ -13,447 +16,615 @@ "ackermann": { "osprey": { "status": "ok", - "rss": 1687552, - "mean": 0.12736866660869567, - "stddev": 0.002459543253816204, - "min": 0.12040150000000001, - "max": 0.13318437500000002 + "rss": 1769472, + "mean": 0.1345645226818182, + "stddev": 0.005452519551321495, + "min": 0.130096875, + "max": 0.156190209 + }, + "osprey-arc": { + "status": "ok", + "rss": 1802240, + "mean": 0.13115390345454547, + "stddev": 0.002719497379572533, + "min": 0.128188792, + "max": 0.139743167 }, "osprey-gc": { "status": "ok", - "rss": 1736704, - "mean": 0.12663914847826085, - "stddev": 0.0021330935690949374, - "min": 0.121384667, - "max": 0.13194466700000002 + "rss": 1785856, + "mean": 0.1297908026086957, + "stddev": 0.0013412721934446422, + "min": 0.127573875, + "max": 0.13264783400000002 }, "rust": { "status": "ok", - "rss": 1835008, - "mean": 0.12855516117391302, - "stddev": 0.006624488453047539, - "min": 0.12360216700000001, - "max": 0.15071604200000002 + "rss": 1867776, + "mean": 0.12995958517391304, + "stddev": 0.0015747509231243677, + "min": 0.128046875, + "max": 0.134430208 }, "c": { "status": "ok", - "rss": 1703936, - "mean": 0.12626428426086955, - "stddev": 0.0024300606337593973, - "min": 0.120284416, - "max": 0.13079279100000002 + "rss": 1753088, + "mean": 0.12950896373913048, + "stddev": 0.0015939714302684112, + "min": 0.12741829200000002, + "max": 0.13321554100000002 + }, + "csharp": { + "status": "ok", + "rss": 7405568, + "mean": 0.1323539111818182, + "stddev": 0.001988542564299666, + "min": 0.129967625, + "max": 0.138640792 + }, + "dart": { + "status": "ok", + "rss": 14843904, + "mean": 0.186408036375, + "stddev": 0.001833328809860568, + "min": 0.18530279200000002, + "max": 0.191866541 }, "ocaml": { "status": "ok", - "rss": 2752512, - "mean": 0.11077185485185186, - "stddev": 0.004511175386376077, - "min": 0.10786000000000001, - "max": 0.126096458 + "rss": 2785280, + "mean": 0.11186707534615385, + "stddev": 0.0005221674023018245, + "min": 0.110813833, + "max": 0.112841334 }, "haskell": { "status": "ok", - "rss": 15826944, - "mean": 0.0650837935111111, - "stddev": 0.0016568500349725874, - "min": 0.061242625, - "max": 0.067802375 + "rss": 15876096, + "mean": 0.06542362220454546, + "stddev": 0.00340463275238016, + "min": 0.060129417000000004, + "max": 0.07913091700000001 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.13056522345454546, - "stddev": 0.0013066069843639444, - "min": 0.12875308300000002, - "max": 0.134443416 + "mean": 0.14612629566666668, + "stddev": 0.01591528365396644, + "min": 0.14063075, + "max": 0.21501054200000003 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.1360977605, - "stddev": 0.0048118742405834315, - "min": 0.13124333400000002, - "max": 0.14545033400000001 + "mean": 0.14640418129999996, + "stddev": 0.001700853865062307, + "min": 0.143973083, + "max": 0.15203945800000002 } }, "binarytrees": { "osprey": { "status": "ok", - "rss": 948928512, - "mean": 0.4171027916000001, - "stddev": 0.005368873774811168, - "min": 0.409974667, - "max": 0.427641708 + "rss": 949043200, + "mean": 0.5551312793000001, + "stddev": 0.008308801648642972, + "min": 0.54427525, + "max": 0.570839709 + }, + "osprey-arc": { + "status": "ok", + "rss": 511148032, + "mean": 1.9570361958, + "stddev": 0.07321798345552279, + "min": 1.8527507920000001, + "max": 2.067338 }, "osprey-gc": { "status": "ok", - "rss": 12894208, - "mean": 1.4981348957999998, - "stddev": 0.03200887146983784, - "min": 1.454544542, - "max": 1.5622914159999999 + "rss": 28852224, + "mean": 3.177285725, + "stddev": 0.0805671165782267, + "min": 3.0496595, + "max": 3.267500792 }, "rust": { "status": "ok", - "rss": 2228224, - "mean": 0.7119244999000001, - "stddev": 0.0063616883237827705, - "min": 0.7019235, - "max": 0.722862167 + "rss": 2326528, + "mean": 0.7526467585000001, + "stddev": 0.009777289594734931, + "min": 0.734756375, + "max": 0.765693209 }, "c": { "status": "ok", - "rss": 1753088, - "mean": 0.34818765, - "stddev": 0.0010506250252650126, - "min": 0.34681754200000003, - "max": 0.350219 + "rss": 1802240, + "mean": 0.36731783760000003, + "stddev": 0.011733240558909574, + "min": 0.360583459, + "max": 0.39995425 + }, + "csharp": { + "status": "ok", + "rss": 16908288, + "mean": 0.12765211786956526, + "stddev": 0.0022703525472382697, + "min": 0.12451475000000001, + "max": 0.133455125 + }, + "dart": { + "status": "ok", + "rss": 23576576, + "mean": 0.12686870660869567, + "stddev": 0.003931457216010006, + "min": 0.12253145800000001, + "max": 0.140329167 }, "ocaml": { "status": "ok", - "rss": 5373952, - "mean": 0.05015624088135594, - "stddev": 0.0008755254676432713, - "min": 0.04922125, - "max": 0.053505875 + "rss": 5423104, + "mean": 0.05232826971929825, + "stddev": 0.006859383236888313, + "min": 0.050166083, + "max": 0.102642125 }, "haskell": { "status": "ok", - "rss": 11550720, - "mean": 0.01701763330769231, - "stddev": 0.0011621268606972776, - "min": 0.014544125000000001, - "max": 0.026212500000000003 + "rss": 11599872, + "mean": 0.01627018013333333, + "stddev": 0.0009579311977375298, + "min": 0.014074708, + "max": 0.019786042 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.5160466626, - "stddev": 0.011906033373220703, - "min": 0.5053384590000001, - "max": 0.536465375 + "mean": 0.5736881915, + "stddev": 0.004697743167241167, + "min": 0.565529083, + "max": 0.582800416 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.7930139458000001, - "stddev": 0.007143942188152813, - "min": 0.7737100840000001, - "max": 0.799466042 + "mean": 0.8092432168, + "stddev": 0.00950941447554287, + "min": 0.7886334580000001, + "max": 0.8162796670000001 } }, "coins": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.07212004475609758, - "stddev": 0.003377214671984259, - "min": 0.069020209, - "max": 0.077594667 + "rss": 1556480, + "mean": 0.07822102305263158, + "stddev": 0.0005224255167752527, + "min": 0.077551125, + "max": 0.08071479200000001 + }, + "osprey-arc": { + "status": "ok", + "rss": 1556480, + "mean": 0.0781546490263158, + "stddev": 0.0003746187035225157, + "min": 0.0769925, + "max": 0.078842541 }, "osprey-gc": { "status": "ok", - "rss": 1523712, - "mean": 0.07016199616279072, - "stddev": 0.002041511861044162, - "min": 0.068459084, - "max": 0.079539125 + "rss": 1572864, + "mean": 0.07829742642105264, + "stddev": 0.0005003219582959711, + "min": 0.07706725, + "max": 0.079201375 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.07386395507894737, - "stddev": 0.0016244328108029622, - "min": 0.072250334, - "max": 0.07842475 + "rss": 1638400, + "mean": 0.08251765975, + "stddev": 0.0004402681423428472, + "min": 0.081476375, + "max": 0.083225541 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.06897973816666667, - "stddev": 0.0007158242593869825, - "min": 0.068110917, - "max": 0.071911375 + "rss": 1523712, + "mean": 0.0776159132894737, + "stddev": 0.0004391096245679562, + "min": 0.07683187500000001, + "max": 0.07854941600000001 + }, + "csharp": { + "status": "ok", + "rss": 7192576, + "mean": 0.10148286203448276, + "stddev": 0.0005567023234758983, + "min": 0.100526792, + "max": 0.10277654200000001 + }, + "dart": { + "status": "ok", + "rss": 14614528, + "mean": 0.12239364062500002, + "stddev": 0.0016825115888894197, + "min": 0.11892954200000001, + "max": 0.12582637500000002 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.0914358800909091, - "stddev": 0.0020929661932820726, - "min": 0.088602417, - "max": 0.097721875 + "rss": 2375680, + "mean": 0.10046314372413793, + "stddev": 0.000665900343883962, + "min": 0.099341625, + "max": 0.102070166 }, "haskell": { "status": "ok", - "rss": 11599872, - "mean": 0.052192122216666664, - "stddev": 0.0028862917045871773, - "min": 0.041684083000000004, - "max": 0.06328679200000001 + "rss": 11649024, + "mean": 0.05220763116393443, + "stddev": 0.0017259338212954182, + "min": 0.048504125, + "max": 0.05506275 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.09207955346875, - "stddev": 0.0016124838324076912, - "min": 0.08916479100000001, - "max": 0.097345834 + "mean": 0.10113390143333331, + "stddev": 0.0014515391342867442, + "min": 0.098042083, + "max": 0.10538950000000001 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.10054772229999999, - "stddev": 0.0022293550701104063, - "min": 0.09711729200000001, - "max": 0.108666542 + "mean": 0.1110740465, + "stddev": 0.0014345512865940552, + "min": 0.107758792, + "max": 0.11357220900000001 } }, "collatz": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.012545572675799097, - "stddev": 0.0007508079792310841, - "min": 0.011583834000000001, - "max": 0.015584458 + "rss": 232505344, + "mean": 0.10486057146428572, + "stddev": 0.001443199432568061, + "min": 0.10263208400000001, + "max": 0.109490083 + }, + "osprey-arc": { + "status": "ok", + "rss": 68698112, + "mean": 0.26326781818181816, + "stddev": 0.010513790792834004, + "min": 0.24876225000000002, + "max": 0.27854179100000004 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.011776092250000002, - "stddev": 0.00038083972998952716, - "min": 0.011190083, - "max": 0.014055542 + "rss": 6897664, + "mean": 0.25122201024999996, + "stddev": 0.0049168244912322565, + "min": 0.242828167, + "max": 0.25861725 }, "rust": { "status": "ok", - "rss": 1605632, - "mean": 0.011229557091575085, - "stddev": 0.0005197024886975661, - "min": 0.010748834, - "max": 0.015912875 + "rss": 1638400, + "mean": 0.012528667373949585, + "stddev": 0.00016419152677289923, + "min": 0.012136583000000001, + "max": 0.013145917 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.009143812271084344, - "stddev": 0.0003248461302836168, - "min": 0.008733000000000001, - "max": 0.010763208 + "rss": 1507328, + "mean": 0.010160753315436236, + "stddev": 0.00025094201150486725, + "min": 0.009773708, + "max": 0.012859834 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.05696826121153845, + "stddev": 0.0004637976098669413, + "min": 0.056162750000000004, + "max": 0.057909042 + }, + "dart": { + "status": "ok", + "rss": 14647296, + "mean": 0.06699445191111113, + "stddev": 0.0005575477299572578, + "min": 0.065834791, + "max": 0.06791683300000001 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.05384459749056604, - "stddev": 0.001693421025873247, - "min": 0.052014791000000005, - "max": 0.058015083 + "rss": 2375680, + "mean": 0.05920743137254903, + "stddev": 0.00044417522285832066, + "min": 0.058244583, + "max": 0.059915541 }, "haskell": { "status": "ok", - "rss": 11616256, - "mean": 0.03504228187254903, - "stddev": 0.005347767419208669, - "min": 0.028140167, - "max": 0.041864292000000004 + "rss": 11665408, + "mean": 0.04052061760273973, + "stddev": 0.00163461799494423, + "min": 0.036554083, + "max": 0.042717000000000005 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.0192491512420382, - "stddev": 0.0007538348927423456, - "min": 0.018100792, - "max": 0.022112166000000003 + "mean": 0.08804973788235293, + "stddev": 0.0015854748423113783, + "min": 0.084603208, + "max": 0.09143920800000001 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.022615930829629642, - "stddev": 0.0018145933737602747, - "min": 0.020886750000000003, - "max": 0.037893458000000005 + "mean": 0.024240399711864407, + "stddev": 0.0007804159479572756, + "min": 0.023360875000000003, + "max": 0.030919708 } }, "coprime": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.06291767812765957, - "stddev": 0.0028832678517612133, - "min": 0.059396041000000004, - "max": 0.073785084 + "rss": 1540096, + "mean": 0.06783205588636364, + "stddev": 0.0008913568088513631, + "min": 0.067106125, + "max": 0.07308529200000001 + }, + "osprey-arc": { + "status": "ok", + "rss": 1572864, + "mean": 0.0677547386818182, + "stddev": 0.0003872525436284277, + "min": 0.066821084, + "max": 0.06869583400000001 }, "osprey-gc": { "status": "ok", - "rss": 1523712, - "mean": 0.06127333508163266, - "stddev": 0.0016299256547941555, - "min": 0.059423833, - "max": 0.065732 + "rss": 1572864, + "mean": 0.06778855109090909, + "stddev": 0.0007750820517765402, + "min": 0.06680791700000001, + "max": 0.07049525000000001 }, "rust": { "status": "ok", - "rss": 1605632, - "mean": 0.059120166604166684, - "stddev": 0.0020439484543486952, - "min": 0.057053125, - "max": 0.06846529200000001 + "rss": 1654784, + "mean": 0.06522360332608698, + "stddev": 0.001709715009866785, + "min": 0.06389958400000001, + "max": 0.07580516600000001 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.05829657930769229, - "stddev": 0.0034262603697402237, - "min": 0.056251792, - "max": 0.079902583 + "rss": 1507328, + "mean": 0.06336895651063831, + "stddev": 0.000435036617911987, + "min": 0.062364083, + "max": 0.064612 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.07712703392105263, + "stddev": 0.0017958264633376794, + "min": 0.074456375, + "max": 0.08001812500000001 + }, + "dart": { + "status": "ok", + "rss": 14712832, + "mean": 0.10631477964285715, + "stddev": 0.0008504343680686866, + "min": 0.10476620900000001, + "max": 0.10946879100000001 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.08688494482352942, - "stddev": 0.0015512859012374908, - "min": 0.084144334, - "max": 0.09161416600000001 + "rss": 2375680, + "mean": 0.0906536450909091, + "stddev": 0.0006076981695146543, + "min": 0.089586625, + "max": 0.09205070800000001 }, "haskell": { "status": "ok", - "rss": 11616256, - "mean": 0.10008550840000002, - "stddev": 0.00256559025744893, - "min": 0.09627904200000001, - "max": 0.10595491600000001 + "rss": 11665408, + "mean": 0.10392730276666669, + "stddev": 0.004189262373305113, + "min": 0.098147625, + "max": 0.11158404200000001 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.06936656140476191, - "stddev": 0.003265549291210689, - "min": 0.065833417, - "max": 0.0834825 + "mean": 0.07594523755000002, + "stddev": 0.0011490444784922104, + "min": 0.07446900000000001, + "max": 0.08215583300000001 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.07129117464285713, - "stddev": 0.001351472523202834, - "min": 0.069808958, - "max": 0.076489125 + "mean": 0.07716228730769231, + "stddev": 0.0015284024196467218, + "min": 0.075777458, + "max": 0.085454083 } }, "digitsum": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.005170246262267343, - "stddev": 0.000781678113238482, - "min": 0.004651625, - "max": 0.020299834000000003 + "rss": 351371264, + "mean": 0.1374745754761905, + "stddev": 0.0024174804760194583, + "min": 0.134810542, + "max": 0.14248158300000002 + }, + "osprey-arc": { + "status": "ok", + "rss": 68665344, + "mean": 0.37533211650000003, + "stddev": 0.014736225313382175, + "min": 0.35511841600000005, + "max": 0.396856417 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.005112774088926182, - "stddev": 0.0003147887309799651, - "min": 0.004723291, - "max": 0.007927875000000001 + "rss": 6881280, + "mean": 0.3584930998000001, + "stddev": 0.007535611289880487, + "min": 0.34818295800000004, + "max": 0.37085462500000005 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.005250681641263943, - "stddev": 0.00022697628757271102, - "min": 0.004930459, - "max": 0.006225833 + "rss": 1638400, + "mean": 0.005433431840659342, + "stddev": 0.00013229900198446882, + "min": 0.005151166, + "max": 0.0059826670000000005 }, "c": { "status": "ok", - "rss": 1441792, - "mean": 0.005150541593368241, - "stddev": 0.00017681968244626792, - "min": 0.004894375, - "max": 0.007009208 + "rss": 1507328, + "mean": 0.005420886127777776, + "stddev": 0.000257362979291614, + "min": 0.00516125, + "max": 0.010372708000000001 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.01625011494535519, + "stddev": 0.00033526427830981535, + "min": 0.015575084000000001, + "max": 0.01749625 + }, + "dart": { + "status": "ok", + "rss": 14680064, + "mean": 0.02890240268316832, + "stddev": 0.000643132673262398, + "min": 0.027618416000000003, + "max": 0.031924291 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.01854850368125, - "stddev": 0.0004513520644684195, - "min": 0.017969291000000002, - "max": 0.022834292000000003 + "rss": 2375680, + "mean": 0.01885908625, + "stddev": 0.00033301509286210503, + "min": 0.018250500000000003, + "max": 0.0218215 }, "haskell": { "status": "ok", - "rss": 11616256, - "mean": 0.02966093847572815, - "stddev": 0.003594441951270849, - "min": 0.026504292000000002, - "max": 0.046723708 + "rss": 11665408, + "mean": 0.02968039509821428, + "stddev": 0.00354134395443631, + "min": 0.025994458, + "max": 0.039148417000000005 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.012269523911894268, - "stddev": 0.000553571233264967, - "min": 0.011425667, - "max": 0.014235333000000001 + "mean": 0.10463570542857141, + "stddev": 0.0019169096479341988, + "min": 0.10087175000000001, + "max": 0.108792834 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.017340458551136365, - "stddev": 0.0008586470987554304, - "min": 0.016389083000000002, - "max": 0.021746791 + "mean": 0.01803478125, + "stddev": 0.0005484856375491714, + "min": 0.017099, + "max": 0.021199167 } }, "exprtree": { "osprey": { "status": "ok", - "rss": 9388032, - "mean": 0.006669227870044061, - "stddev": 0.0008438215759033783, - "min": 0.005992916, - "max": 0.016138292000000002 + "rss": 9469952, + "mean": 0.007978456673740052, + "stddev": 0.00038408989198099216, + "min": 0.0075060840000000005, + "max": 0.012056208 + }, + "osprey-arc": { + "status": "ok", + "rss": 6995968, + "mean": 0.02645341894545454, + "stddev": 0.0010751518543495695, + "min": 0.022619125, + "max": 0.029006292000000003 }, "osprey-gc": { "status": "ok", - "rss": 6782976, - "mean": 0.020578401538461542, - "stddev": 0.0017146595955369757, - "min": 0.018666625000000003, - "max": 0.0285075 + "rss": 15892480, + "mean": 0.027528585990909103, + "stddev": 0.000996293839098802, + "min": 0.025244583, + "max": 0.02948575 }, "rust": { "status": "ok", - "rss": 2801664, - "mean": 0.010237154587412594, - "stddev": 0.00042782228586382915, - "min": 0.009574042000000001, - "max": 0.013407375000000001 + "rss": 2818048, + "mean": 0.01086708121014493, + "stddev": 0.0005563390576302379, + "min": 0.009946375, + "max": 0.014375542000000002 }, "c": { "status": "ok", - "rss": 12025856, - "mean": 0.005720792699999997, - "stddev": 0.0001533465193324896, - "min": 0.005393584000000001, - "max": 0.006655417 + "rss": 12075008, + "mean": 0.00620275053533191, + "stddev": 0.00021670351964556803, + "min": 0.005682875, + "max": 0.007407292 + }, + "csharp": { + "status": "ok", + "rss": 15958016, + "mean": 0.006411362004329005, + "stddev": 0.00025843357086850803, + "min": 0.005950666, + "max": 0.008270875 + }, + "dart": { + "status": "ok", + "rss": 23756800, + "mean": 0.01327907005381165, + "stddev": 0.000345860250665422, + "min": 0.01268525, + "max": 0.015122542000000001 }, "ocaml": { "status": "ok", - "rss": 6340608, - "mean": 0.00519815269558101, - "stddev": 0.0008117369387332161, - "min": 0.0046136250000000005, - "max": 0.020534625 + "rss": 6389760, + "mean": 0.005089618352331609, + "stddev": 0.00012257606960148587, + "min": 0.004816625000000001, + "max": 0.005554459 }, "haskell": { "status": "ok", - "rss": 11911168, - "mean": 0.016550161152631575, - "stddev": 0.0009376980389405851, - "min": 0.014253167, - "max": 0.019917875 + "rss": 11943936, + "mean": 0.01609413099444445, + "stddev": 0.000889235300501243, + "min": 0.013752458, + "max": 0.017879334 }, "osprey-wasm": { "status": "wasm_incompatible", @@ -462,456 +633,624 @@ "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.01980479784615383, - "stddev": 0.0010000000404604649, - "min": 0.018361542, - "max": 0.024348042 + "mean": 0.020167579695945934, + "stddev": 0.0004495564433719155, + "min": 0.019167833000000002, + "max": 0.0211175 } }, "factorial": { "osprey": { "status": "ok", - "rss": 1458176, - "mean": 0.03389132114606741, - "stddev": 0.007019229266663181, - "min": 0.030905458, - "max": 0.09033687500000001 + "rss": 644071424, + "mean": 0.2612707461818182, + "stddev": 0.0034858928188341303, + "min": 0.25368412500000004, + "max": 0.266988125 + }, + "osprey-arc": { + "status": "ok", + "rss": 135839744, + "mean": 0.8430764208999999, + "stddev": 0.016848091085279102, + "min": 0.8240432910000001, + "max": 0.873288625 }, "osprey-gc": { "status": "ok", - "rss": 1523712, - "mean": 0.0317362938, - "stddev": 0.0009527660830065876, - "min": 0.030675708000000003, - "max": 0.035603458000000004 + "rss": 6881280, + "mean": 0.6661575415000001, + "stddev": 0.016662232845861363, + "min": 0.643113583, + "max": 0.6889027080000001 }, "rust": { "status": "ok", - "rss": 1605632, - "mean": 0.03199023580851065, - "stddev": 0.002171628854097729, - "min": 0.030897833000000003, - "max": 0.049992875000000006 + "rss": 1638400, + "mean": 0.03549786155952381, + "stddev": 0.00024244979862158468, + "min": 0.034866708, + "max": 0.036251375 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.03200252560227273, - "stddev": 0.0010432744584930277, - "min": 0.030777500000000003, - "max": 0.035524084000000004 + "rss": 1507328, + "mean": 0.03510839332142858, + "stddev": 0.0003263347937990731, + "min": 0.034403333, + "max": 0.0365955 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.03724943107407409, + "stddev": 0.00027494842744011906, + "min": 0.036700625, + "max": 0.03785725 + }, + "dart": { + "status": "ok", + "rss": 14647296, + "mean": 0.051431194403508775, + "stddev": 0.001572344237857508, + "min": 0.05055925, + "max": 0.061838916 }, "ocaml": { "status": "ok", - "rss": 2310144, - "mean": 0.04395305566153846, - "stddev": 0.0010123276576510952, - "min": 0.042696042000000003, - "max": 0.047625583000000006 + "rss": 2359296, + "mean": 0.048526261688524606, + "stddev": 0.00045267088336931033, + "min": 0.047642917, + "max": 0.050580083000000005 }, "haskell": { "status": "ok", - "rss": 11632640, - "mean": 0.05252409381666669, - "stddev": 0.0020327991925892337, - "min": 0.048136375, - "max": 0.0583125 + "rss": 11681792, + "mean": 0.053797523456140355, + "stddev": 0.0035085728254948935, + "min": 0.049266334, + "max": 0.06272554200000001 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.04195653821917807, - "stddev": 0.002562799206950008, - "min": 0.039287666000000006, - "max": 0.060856458 + "mean": 0.1964765888666667, + "stddev": 0.001374029714928674, + "min": 0.19380525, + "max": 0.199602834 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.04583300308695652, - "stddev": 0.002596669859652369, - "min": 0.043298875, - "max": 0.0588235 + "mean": 0.04878427776666667, + "stddev": 0.0006019195355215574, + "min": 0.047530959000000005, + "max": 0.050127500000000005 } }, "fib": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.02051394144055944, - "stddev": 0.0013691293178279996, - "min": 0.018527250000000002, - "max": 0.02951275 + "rss": 1556480, + "mean": 0.021108200307142853, + "stddev": 0.0007509983904057311, + "min": 0.0203495, + "max": 0.027971125000000003 + }, + "osprey-arc": { + "status": "ok", + "rss": 1572864, + "mean": 0.021039977725352113, + "stddev": 0.0003080067764151423, + "min": 0.020355042, + "max": 0.022430833 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.02051100517763159, - "stddev": 0.0019918731609918612, - "min": 0.01892125, - "max": 0.041399375 + "rss": 1556480, + "mean": 0.021246296370629376, + "stddev": 0.00044988382326856567, + "min": 0.020440709, + "max": 0.023497834000000002 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.01620914889729729, - "stddev": 0.0006940610551309475, - "min": 0.015182542, - "max": 0.019881292000000002 + "rss": 1638400, + "mean": 0.017348509535294113, + "stddev": 0.0005815005441706882, + "min": 0.016438792, + "max": 0.021881625000000002 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.017762794154761896, - "stddev": 0.0014664239909498442, - "min": 0.016354333000000002, - "max": 0.029877 + "rss": 1507328, + "mean": 0.017706915164705895, + "stddev": 0.00035248638452148193, + "min": 0.016900375000000002, + "max": 0.019532583000000003 + }, + "csharp": { + "status": "ok", + "rss": 7192576, + "mean": 0.03589416719047619, + "stddev": 0.0007583701565999027, + "min": 0.034825917000000005, + "max": 0.039738667000000005 + }, + "dart": { + "status": "ok", + "rss": 14614528, + "mean": 0.051574550714285725, + "stddev": 0.0006618506575265432, + "min": 0.050161083, + "max": 0.05346341600000001 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.023769823843750006, - "stddev": 0.0008148866972769889, - "min": 0.022750000000000003, - "max": 0.029588875 + "rss": 2375680, + "mean": 0.02388422668000001, + "stddev": 0.0005719476946591753, + "min": 0.023178292000000003, + "max": 0.02852725 }, "haskell": { "status": "ok", - "rss": 11632640, - "mean": 0.04507473178873239, - "stddev": 0.005351906297128206, - "min": 0.038009959, - "max": 0.054779125000000005 + "rss": 11681792, + "mean": 0.048423553236111125, + "stddev": 0.0049062206845668435, + "min": 0.040000917000000004, + "max": 0.054145167 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.032834075076923076, - "stddev": 0.0019921666347583766, - "min": 0.031065917000000002, - "max": 0.049011166 + "mean": 0.033025759853932586, + "stddev": 0.0005277174973016417, + "min": 0.031527, + "max": 0.034190375 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.036624897734177216, - "stddev": 0.0026297678346860536, - "min": 0.03468025, - "max": 0.057620000000000005 + "mean": 0.036714996912499985, + "stddev": 0.0004947542466814679, + "min": 0.035642166, + "max": 0.037659416 } }, "gcdsum": { "osprey": { "status": "ok", - "rss": 1458176, - "mean": 0.07526948292307696, - "stddev": 0.004305469918117689, - "min": 0.070863833, - "max": 0.09634445800000001 + "rss": 1556480, + "mean": 0.07934559221621625, + "stddev": 0.0003360556195974216, + "min": 0.07869812500000001, + "max": 0.07993475 + }, + "osprey-arc": { + "status": "ok", + "rss": 1572864, + "mean": 0.07938019821621622, + "stddev": 0.0004120310589183741, + "min": 0.078552708, + "max": 0.080254084 }, "osprey-gc": { "status": "ok", - "rss": 1523712, - "mean": 0.07169628156097561, - "stddev": 0.0017325429328319411, - "min": 0.069940292, - "max": 0.077799292 + "rss": 1572864, + "mean": 0.07936307563157895, + "stddev": 0.0005685630151869321, + "min": 0.078575458, + "max": 0.081417875 }, "rust": { "status": "ok", - "rss": 1605632, - "mean": 0.07120980834999999, - "stddev": 0.0018146914072642059, - "min": 0.069471, - "max": 0.07867679200000001 + "rss": 1638400, + "mean": 0.07910054715789476, + "stddev": 0.0003725333543801194, + "min": 0.07855775000000001, + "max": 0.079933375 }, "c": { "status": "ok", - "rss": 1441792, - "mean": 0.07166573023809526, - "stddev": 0.0022975045921178635, - "min": 0.0695965, - "max": 0.07812287500000001 + "rss": 1507328, + "mean": 0.07900756473684212, + "stddev": 0.0009239326542319176, + "min": 0.077707209, + "max": 0.08341975 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.08629469114705884, + "stddev": 0.000601859359215893, + "min": 0.084755667, + "max": 0.08775962500000001 + }, + "dart": { + "status": "ok", + "rss": 14712832, + "mean": 0.10875445518518521, + "stddev": 0.0018086499452933222, + "min": 0.10269750000000001, + "max": 0.111456125 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.09686222925000001, - "stddev": 0.00462645647678677, - "min": 0.093128625, - "max": 0.117092792 + "rss": 2375680, + "mean": 0.10140632317241381, + "stddev": 0.0004427377162381708, + "min": 0.099739333, + "max": 0.102087416 }, "haskell": { "status": "ok", - "rss": 11616256, - "mean": 0.10016629996666666, - "stddev": 0.0024861800307271766, - "min": 0.09422454200000001, - "max": 0.104632 + "rss": 11665408, + "mean": 0.10612753707407407, + "stddev": 0.004234018619129058, + "min": 0.098280875, + "max": 0.11224579100000001 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.07909176415789472, - "stddev": 0.0028096609694049078, - "min": 0.076552125, - "max": 0.0858405 + "mean": 0.08662867647058824, + "stddev": 0.0005726063124368779, + "min": 0.08590062500000001, + "max": 0.088159333 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.08267815636111112, - "stddev": 0.0024309706048319885, - "min": 0.080230459, - "max": 0.091406791 + "mean": 0.09097997656249998, + "stddev": 0.0008198958320934371, + "min": 0.0894945, + "max": 0.09326345800000001 } }, "hanoi": { "osprey": { "status": "ok", - "rss": 1458176, - "mean": 0.03898016027777777, - "stddev": 0.006323380006029107, - "min": 0.034034875, - "max": 0.083411917 + "rss": 1540096, + "mean": 0.03813411935135134, + "stddev": 0.001294421515214723, + "min": 0.03621225, + "max": 0.045716625000000004 + }, + "osprey-arc": { + "status": "ok", + "rss": 1572864, + "mean": 0.037964461499999984, + "stddev": 0.0007294215395749614, + "min": 0.036205167, + "max": 0.039678958 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.03632642127777776, - "stddev": 0.001984527050003104, - "min": 0.032262709, - "max": 0.041072667 + "rss": 1556480, + "mean": 0.03842205982051281, + "stddev": 0.0014079034977757027, + "min": 0.035828167, + "max": 0.0461815 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.03635548826923078, - "stddev": 0.0029921233529167784, - "min": 0.032812167, - "max": 0.051303083000000006 + "rss": 1638400, + "mean": 0.03690097615476191, + "stddev": 0.001086633779384452, + "min": 0.035139625, + "max": 0.040334666000000005 }, "c": { "status": "ok", - "rss": 1441792, - "mean": 0.036084054160919546, - "stddev": 0.0015624262255261017, - "min": 0.032889167000000004, - "max": 0.040231750000000004 + "rss": 1490944, + "mean": 0.03842720398684211, + "stddev": 0.001493288743904572, + "min": 0.03642525, + "max": 0.045783250000000004 + }, + "csharp": { + "status": "ok", + "rss": 7159808, + "mean": 0.03850589040740742, + "stddev": 0.001237997132746092, + "min": 0.036802167000000004, + "max": 0.04274025 + }, + "dart": { + "status": "ok", + "rss": 14663680, + "mean": 0.10302890925000001, + "stddev": 0.0007986264057087221, + "min": 0.10166870900000001, + "max": 0.10611812500000001 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.05986861664000002, - "stddev": 0.0012111948840090034, - "min": 0.057735041, - "max": 0.06350562500000001 + "rss": 2375680, + "mean": 0.06235808075510203, + "stddev": 0.0014335296522688403, + "min": 0.060959125, + "max": 0.071534417 }, "haskell": { "status": "ok", - "rss": 11632640, - "mean": 0.05346391745454545, - "stddev": 0.0025891811180582414, - "min": 0.047976209000000006, - "max": 0.06370175 + "rss": 11681792, + "mean": 0.05787081734615382, + "stddev": 0.0024146516531912197, + "min": 0.051673959000000005, + "max": 0.06240300000000001 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.04752694432258065, - "stddev": 0.001284844754663887, - "min": 0.044559292, - "max": 0.05107375 + "mean": 0.04768449401587302, + "stddev": 0.000843226088547746, + "min": 0.046270125, + "max": 0.051256875 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.051082082724137924, - "stddev": 0.001213465546339915, - "min": 0.049107625, - "max": 0.054411166000000004 + "mean": 0.05132190818644068, + "stddev": 0.0008502906665828736, + "min": 0.049708125000000006, + "max": 0.054014583000000005 } }, "isqrt": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.012629960207207209, - "stddev": 0.0006986788353532812, - "min": 0.011404792, - "max": 0.014392708 + "rss": 816922624, + "mean": 0.3080578124000001, + "stddev": 0.004313446303007066, + "min": 0.30237616700000003, + "max": 0.315587291 + }, + "osprey-arc": { + "status": "ok", + "rss": 270057472, + "mean": 0.8557002043, + "stddev": 0.03498573763392344, + "min": 0.8018863340000001, + "max": 0.906049791 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.012172614474308304, - "stddev": 0.0006673462649462981, - "min": 0.011402500000000001, - "max": 0.016675792000000002 + "rss": 8732672, + "mean": 0.8073826998000001, + "stddev": 0.013654727909004285, + "min": 0.7904256660000001, + "max": 0.835586291 }, "rust": { "status": "ok", - "rss": 1605632, - "mean": 0.010062476886986303, - "stddev": 0.0004975310973058484, - "min": 0.009469208, - "max": 0.012382166 + "rss": 1654784, + "mean": 0.010983467040441182, + "stddev": 0.0002014130495948603, + "min": 0.010496458, + "max": 0.011892333000000001 }, "c": { "status": "ok", - "rss": 1441792, - "mean": 0.00961993262616823, - "stddev": 0.0005248119026738091, - "min": 0.009013959, - "max": 0.013415625 + "rss": 1490944, + "mean": 0.010417533161971837, + "stddev": 0.0002061798476161348, + "min": 0.010055334, + "max": 0.011834208 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.01694701073684211, + "stddev": 0.0006771194438999128, + "min": 0.015362292000000001, + "max": 0.018167041000000002 + }, + "dart": { + "status": "ok", + "rss": 14680064, + "mean": 0.03289552612087913, + "stddev": 0.0010243533684369088, + "min": 0.032018833000000003, + "max": 0.039753500000000004 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.019114320095541402, - "stddev": 0.000800030566234774, - "min": 0.018154125, - "max": 0.024944875000000002 + "rss": 2375680, + "mean": 0.020546318075862074, + "stddev": 0.0003477964652945999, + "min": 0.020100292000000002, + "max": 0.023951875 }, "haskell": { "status": "ok", - "rss": 11616256, - "mean": 0.040613052884615364, - "stddev": 0.0014728346591968075, - "min": 0.036254209, - "max": 0.042864916 + "rss": 11665408, + "mean": 0.04367416172368421, + "stddev": 0.002950067571321298, + "min": 0.036774375000000005, + "max": 0.048956667 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.02370038815384615, - "stddev": 0.0010625457344029916, - "min": 0.021986458, - "max": 0.028581125000000002 + "mean": 0.2858395542, + "stddev": 0.0020868130215307193, + "min": 0.281659125, + "max": 0.28926287500000003 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.02132080785714285, - "stddev": 0.001047824632730243, - "min": 0.019645208, - "max": 0.025109667000000002 + "mean": 0.022778217044776106, + "stddev": 0.000734915978652451, + "min": 0.021317000000000003, + "max": 0.024959500000000003 } }, "josephus": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.03206687318681319, - "stddev": 0.0024738244043878616, - "min": 0.029176917, - "max": 0.048944625000000005 + "rss": 1556480, + "mean": 0.033272754633333346, + "stddev": 0.0002862483844275866, + "min": 0.032823917, + "max": 0.034875167000000006 + }, + "osprey-arc": { + "status": "ok", + "rss": 1572864, + "mean": 0.033303100877777776, + "stddev": 0.00043050191594833467, + "min": 0.032832166, + "max": 0.036188375 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.030889781210000012, - "stddev": 0.002217418265447028, - "min": 0.029252208000000002, - "max": 0.047989792 + "rss": 1572864, + "mean": 0.033318404988764046, + "stddev": 0.00022916510397678988, + "min": 0.032887208, + "max": 0.033851459 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.03018944914000002, - "stddev": 0.001106064607898799, - "min": 0.029157291000000002, - "max": 0.03375075 + "rss": 1654784, + "mean": 0.03347245976136364, + "stddev": 0.0002442429475795455, + "min": 0.032940500000000004, + "max": 0.03410775 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.03029346875000001, - "stddev": 0.0012372235894371093, - "min": 0.028975084, - "max": 0.033559625 + "rss": 1490944, + "mean": 0.032906200593406605, + "stddev": 0.0002441522606012701, + "min": 0.032372375, + "max": 0.033523083 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.03491813692857143, + "stddev": 0.0004469809156558845, + "min": 0.034004709, + "max": 0.038010084 + }, + "dart": { + "status": "ok", + "rss": 14761984, + "mean": 0.042094154555555555, + "stddev": 0.0007110514366167589, + "min": 0.040663292000000004, + "max": 0.045950708 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.03783895061728396, - "stddev": 0.002663089079122089, - "min": 0.036365125000000005, - "max": 0.057168542 + "rss": 2375680, + "mean": 0.04111357923611108, + "stddev": 0.0003289158483281863, + "min": 0.040393375, + "max": 0.041817166 }, "haskell": { "status": "ok", - "rss": 11616256, - "mean": 0.04302655951428571, - "stddev": 0.00460702620487097, - "min": 0.037120417, - "max": 0.054705042 + "rss": 11665408, + "mean": 0.04374498096969698, + "stddev": 0.0027692043489831748, + "min": 0.038977084, + "max": 0.050435417 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.036892117902439035, - "stddev": 0.0012903578859848918, - "min": 0.035456292, - "max": 0.04508675 + "mean": 0.03852403623376623, + "stddev": 0.0006683354001262924, + "min": 0.037195083000000004, + "max": 0.040756875000000005 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.04050323567123287, - "stddev": 0.0015212885551802516, - "min": 0.038929042000000004, - "max": 0.044929250000000004 + "mean": 0.04192726188571428, + "stddev": 0.000597849860643074, + "min": 0.040615208, + "max": 0.043516458 } }, "listops": { "osprey": { "status": "ok", - "rss": 2614575104, - "mean": 0.4992477335000001, - "stddev": 0.012753006481641254, - "min": 0.48592937500000005, - "max": 0.527530917 + "rss": 2614591488, + "mean": 0.5317172751000001, + "stddev": 0.005037973977676098, + "min": 0.5234145, + "max": 0.5384586250000001 + }, + "osprey-arc": { + "status": "ok", + "rss": 3548282880, + "mean": 1.0881916708, + "stddev": 0.014829940104248655, + "min": 1.0704225840000001, + "max": 1.116767667 }, "osprey-gc": { "status": "ok", - "rss": 4341760, - "mean": 0.6509993206000001, - "stddev": 0.013755113620804152, - "min": 0.636951708, - "max": 0.6808396250000001 + "rss": 3932160, + "mean": 0.6605329208000001, + "stddev": 0.008371314355412399, + "min": 0.6430895000000001, + "max": 0.67297775 }, "rust": { "status": "ok", - "rss": 1703936, - "mean": 0.0014738148716605555, - "stddev": 0.000190777093872242, - "min": 0.001263584, - "max": 0.003932541 + "rss": 1736704, + "mean": 0.00137688654350105, + "stddev": 0.0001345308863739621, + "min": 0.001227666, + "max": 0.003952542 }, "c": { "status": "ok", - "rss": 1474560, - "mean": 0.0013442372648148114, - "stddev": 0.00016199288240932277, - "min": 0.001145125, - "max": 0.002037583 + "rss": 1523712, + "mean": 0.001178319222359738, + "stddev": 6.744330879786567e-05, + "min": 0.0010408330000000001, + "max": 0.001656541 + }, + "csharp": { + "status": "ok", + "rss": 7421952, + "mean": 0.002877564453252032, + "stddev": 0.00014490080444438743, + "min": 0.00264875, + "max": 0.004004084000000001 + }, + "dart": { + "status": "ok", + "rss": 15040512, + "mean": 0.009812585640410963, + "stddev": 0.0005419425402238753, + "min": 0.009108375, + "max": 0.015435666 }, "ocaml": { "status": "ok", - "rss": 2654208, - "mean": 0.001971891221189591, - "stddev": 0.00023640887698620205, - "min": 0.001771041, - "max": 0.008106959 + "rss": 2703360, + "mean": 0.0018979480423728795, + "stddev": 9.271196656977805e-05, + "min": 0.001745334, + "max": 0.0025287910000000003 }, "haskell": { "status": "ok", - "rss": 11862016, - "mean": 0.01674602562631579, - "stddev": 0.0009638053637768733, - "min": 0.014610584000000001, - "max": 0.019286625 + "rss": 11911168, + "mean": 0.018076607695652173, + "stddev": 0.0015579832014204452, + "min": 0.014682583, + "max": 0.020427709000000002 }, "osprey-wasm": { "status": "wasm_incompatible", @@ -920,456 +1259,624 @@ "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.013138021443946197, - "stddev": 0.001376279649515157, - "min": 0.011319708000000001, - "max": 0.022722084 + "mean": 0.011447783744186053, + "stddev": 0.0006599589452747025, + "min": 0.010861500000000001, + "max": 0.020555667 } }, "mutual": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.012616265615740741, - "stddev": 0.0007349277505286447, - "min": 0.01096425, - "max": 0.016611667 + "rss": 1556480, + "mean": 0.01175217482745098, + "stddev": 0.0003391920961277852, + "min": 0.010514250000000001, + "max": 0.012357375 + }, + "osprey-arc": { + "status": "ok", + "rss": 1556480, + "mean": 0.011111069444444443, + "stddev": 0.0005510888055985828, + "min": 0.010369959000000002, + "max": 0.012307667000000001 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.011886927537549413, - "stddev": 0.0005564055069057845, - "min": 0.011234666, - "max": 0.014337500000000001 + "rss": 1572864, + "mean": 0.010813424035971225, + "stddev": 0.000256989128333634, + "min": 0.010351125000000001, + "max": 0.012053458000000001 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.01201531354999999, - "stddev": 0.0008148322746304114, - "min": 0.010820875, - "max": 0.016388708000000002 + "rss": 1638400, + "mean": 0.011613327939163502, + "stddev": 0.0003314409951328484, + "min": 0.011018334000000001, + "max": 0.013283917000000001 }, "c": { "status": "ok", - "rss": 1441792, - "mean": 0.011682933150943396, - "stddev": 0.0007869429500042517, - "min": 0.010658125000000001, - "max": 0.016314875 + "rss": 1507328, + "mean": 0.011655067379699246, + "stddev": 0.000780019862447817, + "min": 0.010763625, + "max": 0.020331625000000002 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.01906923807453415, + "stddev": 0.0004107605854414093, + "min": 0.018507625, + "max": 0.021355167 + }, + "dart": { + "status": "ok", + "rss": 14581760, + "mean": 0.29772791660000003, + "stddev": 0.0013403887551222762, + "min": 0.29569525, + "max": 0.299473292 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.02864359828301886, - "stddev": 0.0034627559257139544, - "min": 0.026055542, - "max": 0.04374025 + "rss": 2375680, + "mean": 0.028597680907407403, + "stddev": 0.0030756725110168727, + "min": 0.026441125000000003, + "max": 0.038695292 }, "haskell": { "status": "ok", - "rss": 11632640, - "mean": 0.03478966937974683, - "stddev": 0.005555666740297695, - "min": 0.027321375000000002, - "max": 0.042813542 + "rss": 11681792, + "mean": 0.032551467161616145, + "stddev": 0.00386425845382139, + "min": 0.027665541000000002, + "max": 0.044638667 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.0237384124, - "stddev": 0.0009039520256497789, - "min": 0.022632125000000003, - "max": 0.027770458 + "mean": 0.023394538453125, + "stddev": 0.00048565925153069205, + "min": 0.022569583, + "max": 0.025395958000000003 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.02807970413888888, - "stddev": 0.0014215482905751428, - "min": 0.025863709000000002, - "max": 0.031503958 + "mean": 0.02702167211111111, + "stddev": 0.0004702324925435166, + "min": 0.026111333, + "max": 0.02851325 } }, "nestedloop": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.043554934924242436, - "stddev": 0.0020482107251585772, - "min": 0.040747000000000005, - "max": 0.047293083 + "rss": 1556480, + "mean": 0.045206511880597024, + "stddev": 0.0012928570807331234, + "min": 0.041372167, + "max": 0.047949250000000006 + }, + "osprey-arc": { + "status": "ok", + "rss": 1556480, + "mean": 0.043770306000000016, + "stddev": 0.0019619301890485613, + "min": 0.040667709, + "max": 0.046459083000000005 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.041364883281690155, - "stddev": 0.0008960689777100419, - "min": 0.040364875, - "max": 0.045776667 + "rss": 1572864, + "mean": 0.041443957777777776, + "stddev": 0.0006821382856133759, + "min": 0.040900042000000005, + "max": 0.044811584 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.04319007302739726, - "stddev": 0.004445000564518174, - "min": 0.040837666, - "max": 0.072538167 + "rss": 1638400, + "mean": 0.042053493178082206, + "stddev": 0.0014472494773428003, + "min": 0.040632416000000005, + "max": 0.048473042 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.042016669972602734, - "stddev": 0.0015777522640113247, - "min": 0.040520709, - "max": 0.04589175 + "rss": 1507328, + "mean": 0.04129237094520548, + "stddev": 0.0006147909317099843, + "min": 0.040679541, + "max": 0.044025208 + }, + "csharp": { + "status": "ok", + "rss": 7208960, + "mean": 0.04342677627941177, + "stddev": 0.0009775658759752, + "min": 0.042308583000000004, + "max": 0.047335833 + }, + "dart": { + "status": "ok", + "rss": 14581760, + "mean": 0.05444237340740741, + "stddev": 0.0006521738676024426, + "min": 0.053719208000000004, + "max": 0.057008875 }, "ocaml": { "status": "ok", - "rss": 2310144, - "mean": 0.05232290074545456, - "stddev": 0.0009124512190083698, - "min": 0.051140791000000005, - "max": 0.056090917000000004 + "rss": 2359296, + "mean": 0.05318908773214285, + "stddev": 0.0008227943662688304, + "min": 0.052046542, + "max": 0.057201833 }, "haskell": { "status": "ok", - "rss": 11567104, - "mean": 0.06358799628888889, - "stddev": 0.0037143083203781194, - "min": 0.053930834000000004, - "max": 0.067331792 + "rss": 11616256, + "mean": 0.06039119273584905, + "stddev": 0.004005308275800649, + "min": 0.0532045, + "max": 0.071779125 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.05433713910714287, - "stddev": 0.002363197675999686, - "min": 0.052149208, - "max": 0.061190541 + "mean": 0.06070026303921569, + "stddev": 0.005120101737498492, + "min": 0.056822458000000006, + "max": 0.082334291 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.05798517532075472, - "stddev": 0.002089688792777313, - "min": 0.055038208000000005, - "max": 0.065816792 + "mean": 0.06484370369565218, + "stddev": 0.003147799333135707, + "min": 0.062217458, + "max": 0.07713241600000001 } }, "pascal": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.027610028957627125, - "stddev": 0.002182662057530186, - "min": 0.024585584, - "max": 0.046491291000000004 + "rss": 1540096, + "mean": 0.028383599317757024, + "stddev": 0.0012476911211756457, + "min": 0.02563, + "max": 0.033189041 + }, + "osprey-arc": { + "status": "ok", + "rss": 1572864, + "mean": 0.02852050484466018, + "stddev": 0.0011574988734415113, + "min": 0.025672083000000002, + "max": 0.034986125 }, "osprey-gc": { "status": "ok", - "rss": 1523712, - "mean": 0.02661059825242719, - "stddev": 0.0012051119780563534, - "min": 0.02320325, - "max": 0.029578791 + "rss": 1572864, + "mean": 0.028366449898989888, + "stddev": 0.001206615138530928, + "min": 0.024810250000000002, + "max": 0.032677375 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.027010158893805314, - "stddev": 0.001449185902100662, - "min": 0.023684625, - "max": 0.032747958 + "rss": 1654784, + "mean": 0.02831931748, + "stddev": 0.0009446056222433292, + "min": 0.026276583000000003, + "max": 0.0312735 }, "c": { "status": "ok", - "rss": 1441792, - "mean": 0.026932608635514024, - "stddev": 0.0011975650599050651, - "min": 0.023513000000000003, - "max": 0.031111875 + "rss": 1507328, + "mean": 0.027828429378378382, + "stddev": 0.0010034586740013314, + "min": 0.024439250000000003, + "max": 0.029857916 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.03344404353932586, + "stddev": 0.0007761867025639757, + "min": 0.032033917, + "max": 0.036242667 + }, + "dart": { + "status": "ok", + "rss": 14696448, + "mean": 0.06465853171739129, + "stddev": 0.0006129124648685397, + "min": 0.06390633300000001, + "max": 0.06718866700000001 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.04352384802941176, - "stddev": 0.0007884400357257317, - "min": 0.0418735, - "max": 0.045676292 + "rss": 2375680, + "mean": 0.04426928345454544, + "stddev": 0.0006483151478026522, + "min": 0.043026666000000005, + "max": 0.045839542000000004 }, "haskell": { "status": "ok", - "rss": 11632640, - "mean": 0.05775935322916668, - "stddev": 0.005175760185362821, - "min": 0.050807041000000004, - "max": 0.06668775 + "rss": 11681792, + "mean": 0.059710348226415105, + "stddev": 0.0037423404359571803, + "min": 0.05401025, + "max": 0.070405625 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.04237343966666667, - "stddev": 0.0009740545501274057, - "min": 0.041030375, - "max": 0.046938083000000005 + "mean": 0.04340832797101449, + "stddev": 0.00044495828172633466, + "min": 0.042253625, + "max": 0.044164875000000006 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.047031632661538474, - "stddev": 0.00560866892967439, - "min": 0.045041875, - "max": 0.079016958 + "mean": 0.04707895371428571, + "stddev": 0.00045552468239568674, + "min": 0.045925, + "max": 0.047957916 } }, "powmod": { "osprey": { "status": "ok", - "rss": 1458176, - "mean": 0.022561285984962397, - "stddev": 0.0012148558652572742, - "min": 0.020663833000000003, - "max": 0.028241833 + "rss": 1556480, + "mean": 0.023339936851562514, + "stddev": 0.0001719149711197937, + "min": 0.023038208, + "max": 0.023922708 + }, + "osprey-arc": { + "status": "ok", + "rss": 1572864, + "mean": 0.023306294333333342, + "stddev": 0.0003011736842792953, + "min": 0.022876125, + "max": 0.026077916000000003 }, "osprey-gc": { "status": "ok", - "rss": 1523712, - "mean": 0.02151261349275363, - "stddev": 0.0013688080561625059, - "min": 0.020672708, - "max": 0.035645417000000006 + "rss": 1556480, + "mean": 0.023359087598425192, + "stddev": 0.00015541699476402294, + "min": 0.023096333, + "max": 0.023781458000000002 }, "rust": { "status": "ok", - "rss": 1605632, - "mean": 0.021758035874125878, - "stddev": 0.0010077034388687686, - "min": 0.020636583, - "max": 0.026317791 + "rss": 1654784, + "mean": 0.02338032943750001, + "stddev": 0.0001466785614970051, + "min": 0.023097667000000002, + "max": 0.023785792 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.021735257784172672, - "stddev": 0.0012828516860458948, - "min": 0.020794916, - "max": 0.03296525 + "rss": 1490944, + "mean": 0.023385482101562504, + "stddev": 0.00015277462744046303, + "min": 0.022929833, + "max": 0.023897125 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.03411458569318183, + "stddev": 0.00023785588568669367, + "min": 0.033707, + "max": 0.034820083 + }, + "dart": { + "status": "ok", + "rss": 14598144, + "mean": 0.05046806808333333, + "stddev": 0.0005251425266990937, + "min": 0.049545500000000006, + "max": 0.052023333000000005 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.0563331439056604, - "stddev": 0.001375970662833434, - "min": 0.054606375000000006, - "max": 0.060137917000000006 + "rss": 2375680, + "mean": 0.06069337416326532, + "stddev": 0.00019364579665970752, + "min": 0.060303208000000004, + "max": 0.061066042 }, "haskell": { "status": "ok", - "rss": 11632640, - "mean": 0.05534521062500001, - "stddev": 0.005423780431217941, - "min": 0.048905250000000004, - "max": 0.08130000000000001 + "rss": 11681792, + "mean": 0.05810676678846156, + "stddev": 0.0024640986015557562, + "min": 0.053602375, + "max": 0.06436975 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.028396511212962976, - "stddev": 0.0014452167803785363, - "min": 0.026489041, - "max": 0.035036625 + "mean": 0.02995943458999999, + "stddev": 0.0003814254024520109, + "min": 0.029145667, + "max": 0.031019958 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.03173851111702128, - "stddev": 0.0011749305003748583, - "min": 0.030132584, - "max": 0.035529417 + "mean": 0.03385078277528091, + "stddev": 0.0003449188895104627, + "min": 0.033234875000000004, + "max": 0.034846875 } }, "primes": { "osprey": { "status": "ok", - "rss": 1458176, - "mean": 0.006332090133333329, - "stddev": 0.0006138090595851455, - "min": 0.0056905, - "max": 0.016033792 + "rss": 1540096, + "mean": 0.006511247116129029, + "stddev": 0.00020045248258412102, + "min": 0.006252416, + "max": 0.007907458000000001 + }, + "osprey-arc": { + "status": "ok", + "rss": 1572864, + "mean": 0.006490696064159291, + "stddev": 0.00016748082725496363, + "min": 0.006096708, + "max": 0.007650458000000001 }, "osprey-gc": { "status": "ok", - "rss": 1523712, - "mean": 0.0063650648516260155, - "stddev": 0.0005376167524009866, - "min": 0.005757375, - "max": 0.011145750000000001 + "rss": 1572864, + "mean": 0.006546066563941299, + "stddev": 0.00017576753488412534, + "min": 0.006177333, + "max": 0.007683000000000001 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.007085161930069932, - "stddev": 0.0008779259260102914, - "min": 0.006151959, - "max": 0.018334625 + "rss": 1638400, + "mean": 0.0067181771999999945, + "stddev": 0.0004878107615662352, + "min": 0.0062879170000000005, + "max": 0.015371458000000001 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.0066936431380368085, - "stddev": 0.0007730552557776503, - "min": 0.005772125, - "max": 0.014513708 + "rss": 1490944, + "mean": 0.00645802941509434, + "stddev": 0.00021054882119670768, + "min": 0.00607825, + "max": 0.007545792000000001 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.00855040191988951, + "stddev": 0.00031378656333736914, + "min": 0.007910333, + "max": 0.009790041000000001 + }, + "dart": { + "status": "ok", + "rss": 14712832, + "mean": 0.044095990059701495, + "stddev": 0.0009561825632432441, + "min": 0.0412845, + "max": 0.046104458 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.00874638351752022, - "stddev": 0.001043307949207943, - "min": 0.007679, - "max": 0.012737125 + "rss": 2359296, + "mean": 0.008504648155882356, + "stddev": 0.0002711246384523538, + "min": 0.0080065, + "max": 0.009423583000000001 }, "haskell": { "status": "ok", - "rss": 11616256, - "mean": 0.01578291061827957, - "stddev": 0.0007475176687906046, - "min": 0.013527583000000001, - "max": 0.016913291 + "rss": 11665408, + "mean": 0.01731606041758242, + "stddev": 0.0015057763708149802, + "min": 0.013571291000000001, + "max": 0.020034958000000002 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.012496934558704452, - "stddev": 0.0004996862788914763, - "min": 0.011506333, - "max": 0.013878875 + "mean": 0.013085596311627904, + "stddev": 0.000455598394469122, + "min": 0.012174291, + "max": 0.016056333000000002 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.016285771976047896, - "stddev": 0.0008468785096141385, - "min": 0.015256416000000002, - "max": 0.022996834 + "mean": 0.01705551379651163, + "stddev": 0.0006675405324645653, + "min": 0.016061416000000002, + "max": 0.023583666000000003 } }, "tak": { "osprey": { "status": "ok", - "rss": 1474560, - "mean": 0.03259094495698924, - "stddev": 0.0006773233072993844, - "min": 0.031226291000000003, - "max": 0.0346665 + "rss": 1556480, + "mean": 0.03294364514285714, + "stddev": 0.0016888658355312869, + "min": 0.031608292, + "max": 0.045960583000000006 + }, + "osprey-arc": { + "status": "ok", + "rss": 1556480, + "mean": 0.032513196406593406, + "stddev": 0.00043786528545716936, + "min": 0.031658625, + "max": 0.033464208 }, "osprey-gc": { "status": "ok", - "rss": 1507328, - "mean": 0.03244788978888887, - "stddev": 0.0006540079576236743, - "min": 0.031403209, - "max": 0.034193125000000005 + "rss": 1572864, + "mean": 0.03267207524731183, + "stddev": 0.0005477852556119617, + "min": 0.031497250000000004, + "max": 0.034013417000000004 }, "rust": { "status": "ok", - "rss": 1589248, - "mean": 0.03220977897752809, - "stddev": 0.0005005389305286803, - "min": 0.031158750000000002, - "max": 0.033770417000000004 + "rss": 1654784, + "mean": 0.03276332186813188, + "stddev": 0.0005522238607066318, + "min": 0.031548458, + "max": 0.033865542000000005 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.03270676039130435, - "stddev": 0.0007636651948225776, - "min": 0.031559250000000004, - "max": 0.035830541 + "rss": 1490944, + "mean": 0.032602421325842706, + "stddev": 0.0005563217917883579, + "min": 0.031775042, + "max": 0.036556041000000004 + }, + "csharp": { + "status": "ok", + "rss": 7159808, + "mean": 0.03487428571764705, + "stddev": 0.00047329630748500794, + "min": 0.034063292, + "max": 0.036316125000000005 + }, + "dart": { + "status": "ok", + "rss": 14696448, + "mean": 0.08192690983333334, + "stddev": 0.000663580838016224, + "min": 0.081061625, + "max": 0.085175791 }, "ocaml": { "status": "ok", - "rss": 2326528, - "mean": 0.0437846199850746, - "stddev": 0.0006256212569344629, - "min": 0.042898667, - "max": 0.045502833 + "rss": 2375680, + "mean": 0.04444724376119404, + "stddev": 0.0004327111641700817, + "min": 0.043710959, + "max": 0.045681834000000004 }, "haskell": { "status": "ok", - "rss": 11632640, - "mean": 0.06324120059183673, - "stddev": 0.006755559946592524, - "min": 0.056682, - "max": 0.098651916 + "rss": 11681792, + "mean": 0.06472224314285714, + "stddev": 0.004695850124932039, + "min": 0.058247, + "max": 0.073870375 }, "osprey-wasm": { "status": "ok", "rss": 0, - "mean": 0.08539072971428571, - "stddev": 0.0011136630836610802, - "min": 0.08360408400000001, - "max": 0.08806770800000001 + "mean": 0.08664469768571431, + "stddev": 0.0021742841139857404, + "min": 0.08507675, + "max": 0.09856529200000001 }, "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.09112537234375001, - "stddev": 0.005974166438777923, - "min": 0.087356084, - "max": 0.11400995800000001 + "mean": 0.09035319442424243, + "stddev": 0.00034912398306977187, + "min": 0.089710042, + "max": 0.09132116700000001 } }, "textstats": { "osprey": { "status": "ok", - "rss": 1458176, - "mean": 0.0032227805671100358, - "stddev": 0.00030231765071380237, - "min": 0.0028787500000000002, - "max": 0.007316125000000001 + "rss": 1556480, + "mean": 0.0035267961775362344, + "stddev": 0.0001431062829734598, + "min": 0.0032630830000000004, + "max": 0.0042202080000000005 + }, + "osprey-arc": { + "status": "ok", + "rss": 1638400, + "mean": 0.005054718929159812, + "stddev": 0.00022906116145529943, + "min": 0.004680958000000001, + "max": 0.007757167000000001 }, "osprey-gc": { "status": "ok", - "rss": 1540096, - "mean": 0.0033533974814323577, - "stddev": 0.0002740030699617818, - "min": 0.0030340410000000003, - "max": 0.00532725 + "rss": 1589248, + "mean": 0.0036128678327044038, + "stddev": 0.00018134929198197506, + "min": 0.003265875, + "max": 0.004185250000000001 }, "rust": { "status": "ok", - "rss": 1671168, - "mean": 0.001972454907869482, - "stddev": 0.0001294193843523947, - "min": 0.001789917, - "max": 0.003074292 + "rss": 1703936, + "mean": 0.002009261853708789, + "stddev": 0.00014947587773994292, + "min": 0.0017809590000000001, + "max": 0.00298275 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.0021172119455172417, - "stddev": 0.0001836906132437394, - "min": 0.0019032500000000002, - "max": 0.003787167 + "rss": 1523712, + "mean": 0.0020918755675487463, + "stddev": 9.907612812028048e-05, + "min": 0.0019201670000000002, + "max": 0.002675958 + }, + "csharp": { + "status": "ok", + "rss": 7176192, + "mean": 0.003650588901323707, + "stddev": 0.0001479658480924744, + "min": 0.003355667, + "max": 0.0042965 + }, + "dart": { + "status": "ok", + "rss": 14745600, + "mean": 0.010964553323636366, + "stddev": 0.0006355558987092062, + "min": 0.010122417, + "max": 0.018972834 }, "ocaml": { "status": "ok", - "rss": 2392064, - "mean": 0.003950491971354171, - "stddev": 0.0006458604992151191, - "min": 0.003537459, - "max": 0.014356209000000002 + "rss": 2441216, + "mean": 0.0038447673630319186, + "stddev": 0.00011169167186976136, + "min": 0.003642834, + "max": 0.004438708 }, "haskell": { "status": "ok", - "rss": 11911168, - "mean": 0.01771699186666667, - "stddev": 0.0015880792414159147, - "min": 0.013867209, - "max": 0.019913 + "rss": 11960320, + "mean": 0.017273827748538015, + "stddev": 0.0015268057753566168, + "min": 0.014026042, + "max": 0.020516125 }, "osprey-wasm": { "status": "wasm_incompatible", @@ -1378,60 +1885,84 @@ "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.012156513161538459, - "stddev": 0.0007975437728936715, - "min": 0.011331167000000001, - "max": 0.018450584000000003 + "mean": 0.012639777915254244, + "stddev": 0.0004850527546099312, + "min": 0.011702583, + "max": 0.013894917000000001 } }, "wordfreq": { "osprey": { "status": "ok", - "rss": 55394304, - "mean": 0.01926546162499999, - "stddev": 0.0005666898981438634, - "min": 0.018337334, - "max": 0.020730500000000002 + "rss": 61915136, + "mean": 0.022583303601503766, + "stddev": 0.0004984132750889346, + "min": 0.021475292, + "max": 0.0243515 + }, + "osprey-arc": { + "status": "ok", + "rss": 96370688, + "mean": 0.077969447875, + "stddev": 0.00449143555176588, + "min": 0.067607333, + "max": 0.087297208 }, "osprey-gc": { "status": "ok", - "rss": 4636672, - "mean": 0.05327347734545453, - "stddev": 0.0016463313516705495, - "min": 0.050478917000000005, - "max": 0.058515500000000005 + "rss": 4931584, + "mean": 0.07089195651111112, + "stddev": 0.002600194228861416, + "min": 0.065755167, + "max": 0.076065833 }, "rust": { "status": "ok", - "rss": 1654784, - "mean": 0.004400151734992679, - "stddev": 0.0003069320345003637, - "min": 0.004050625, - "max": 0.005846709 + "rss": 1703936, + "mean": 0.004471526839771103, + "stddev": 0.00015559812776018783, + "min": 0.004139833, + "max": 0.005037584 }, "c": { "status": "ok", - "rss": 1458176, - "mean": 0.0014600501617277766, - "stddev": 0.00010148161712535852, - "min": 0.001325917, - "max": 0.0020288330000000003 + "rss": 1490944, + "mean": 0.001462064488995211, + "stddev": 0.00012531673597277954, + "min": 0.001302917, + "max": 0.003885916 + }, + "csharp": { + "status": "ok", + "rss": 7159808, + "mean": 0.0032876054257767557, + "stddev": 0.00015414289994849083, + "min": 0.002931167, + "max": 0.004004708 + }, + "dart": { + "status": "ok", + "rss": 14860288, + "mean": 0.010627116810218983, + "stddev": 0.0005085530549204008, + "min": 0.009855125000000001, + "max": 0.013516750000000001 }, "ocaml": { "status": "ok", - "rss": 2408448, - "mean": 0.0024033592520193844, - "stddev": 0.0006016260201339824, - "min": 0.002142625, - "max": 0.021152833000000003 + "rss": 2457600, + "mean": 0.002349943567747295, + "stddev": 0.00010458771395379523, + "min": 0.002195125, + "max": 0.003443625 }, "haskell": { "status": "ok", - "rss": 11862016, - "mean": 0.018430894917159744, - "stddev": 0.0019730041371095945, - "min": 0.014325209, - "max": 0.025187083000000002 + "rss": 11911168, + "mean": 0.017322703707317078, + "stddev": 0.0015885038415285298, + "min": 0.013586917, + "max": 0.020547417000000002 }, "osprey-wasm": { "status": "wasm_incompatible", @@ -1440,10 +1971,10 @@ "rust-wasm": { "status": "ok", "rss": 0, - "mean": 0.015253087661202187, - "stddev": 0.0005984250089546093, - "min": 0.014172750000000001, - "max": 0.017286291000000002 + "mean": 0.015603332748691098, + "stddev": 0.0005297905922589253, + "min": 0.014396458, + "max": 0.016862416 } } } diff --git a/benchmarks/run.sh b/benchmarks/run.sh index 5b580014..9ab36fc0 100644 --- a/benchmarks/run.sh +++ b/benchmarks/run.sh @@ -36,12 +36,13 @@ MEMRUNS=${BENCH_MEMRUNS:-3} # Language order is the report's column order. "Speed of light" baselines (C, # Rust) first after Osprey so the gap to Osprey reads left-to-right. `osprey-gc` -# is the SAME .osp compiled with the tracing GC backend (--memory=gc), so the -# allocation cases (binarytrees) show reclamation next to the default backend. -LANGS=(osprey osprey-gc rust c ocaml haskell osprey-wasm rust-wasm c-wasm) +# and `osprey-arc` are the SAME .osp compiled with the tracing-GC (--memory=gc) +# and Perceus ARC (--memory=arc) backends, so the allocation cases +# (binarytrees) show both reclamation strategies next to the default backend. +LANGS=(osprey osprey-arc osprey-gc rust c csharp dart ocaml haskell osprey-wasm rust-wasm c-wasm) typeset -A EXT -EXT=(osprey osp osprey-gc osp rust rs c c ocaml ml haskell hs - osprey-wasm osp rust-wasm rs c-wasm c) +EXT=(osprey osp osprey-arc osp osprey-gc osp rust rs c c csharp cs dart dart + ocaml ml haskell hs osprey-wasm osp rust-wasm rs c-wasm c) have() { command -v "$1" >/dev/null 2>&1 } @@ -67,9 +68,11 @@ wasm_wrap() { printf '#!/bin/sh\nexec wasmtime run "%s.wasm" "$@"\n' "$1" > "$1" # probed once into CWASM_OK because stock clang+wasi-libc often lacks it.) toolchain_ok() { case "$1" in - osprey|osprey-gc) [[ -x "$OSP" ]] ;; + osprey|osprey-gc|osprey-arc) [[ -x "$OSP" ]] ;; rust) have rustc ;; c) have cc ;; + csharp) have dotnet ;; + dart) have dart ;; ocaml) have ocamlopt ;; haskell) have ghc ;; osprey-wasm) [[ -x "$OSP" ]] && have wasmtime && [[ -f "$ROOT/compiler/lib/libosprey_runtime_wasm.a" ]] ;; @@ -83,9 +86,19 @@ build() { local lang=$1 dir=$2 name=$3 out=$4 case "$lang" in osprey) ( cd "$dir" && "$OSP" "$name.osp" --compile >/dev/null 2>&1 ) && mv -f "$dir/$name" "$out" ;; - osprey-gc) ( cd "$dir" && "$OSP" "$name.osp" --memory=gc --compile >/dev/null 2>&1 ) && mv -f "$dir/$name" "$out" ;; + osprey-gc) ( cd "$dir" && "$OSP" "$name.osp" --memory=gc --compile >/dev/null 2>&1 ) && mv -f "$dir/$name" "$out" ;; + osprey-arc) ( cd "$dir" && "$OSP" "$name.osp" --memory=arc --compile >/dev/null 2>&1 ) && mv -f "$dir/$name" "$out" ;; rust) rustc -C opt-level=3 -C overflow-checks=off -o "$out" "$dir/$name.rs" 2>/dev/null ;; c) cc -O2 -o "$out" "$dir/$name.c" 2>/dev/null ;; + # C# via NativeAOT (dotnet publish): a real native binary, the fair + # comparison against the other AOT columns. One throwaway SDK project per + # case in $TMP; the published binary is moved to $out. + csharp) csd="$TMP/cs_$name" && rm -rf "$csd" && mkdir -p "$csd" && \ + cp "$dir/$name.cs" "$csd/Program.cs" && \ + printf '%s\n' 'Exenet10.0trueSpeedtruedisablebench' > "$csd/bench.csproj" && \ + ( cd "$csd" && dotnet publish -c Release -o out --nologo -v q >/dev/null 2>&1 ) && \ + mv -f "$csd/out/bench" "$out" ;; + dart) dart compile exe "$dir/$name.dart" -o "$out" >/dev/null 2>&1 ;; ocaml) cp "$dir/$name.ml" "$TMP/$name.ml" && \ ( cd "$TMP" && ocamlopt -O3 -unsafe -o "$out" "$name.ml" >/dev/null 2>&1 ) ;; # compile a copy: ocamlopt litters .cmi/.cmx/.o beside the source haskell) ghc -O2 -outputdir "$TMP/hs_$name" -o "$out" "$dir/$name.hs" >/dev/null 2>&1 ;; diff --git a/compiler/runtime/memory_arc.c b/compiler/runtime/memory_arc.c index 3b46c3ba..989abc12 100644 --- a/compiler/runtime/memory_arc.c +++ b/compiler/runtime/memory_arc.c @@ -312,6 +312,12 @@ void osp_release(void *o) { pthread_mutex_unlock(&g_lock); } +// Codegen-proved-unique drop (memory_hooks.h): the caller proved rc == 1, so +// this is exactly osp_release — the distinct symbol only exists to carry +// LLVM's free-pair attributes so -O2 can delete non-escaping alloc+release +// pairs before they ever reach the runtime. +void osp_release_unique(void *o) { osp_release(o); } + // Full-collection hook: nothing to do — acyclic naive RC is already complete // (Bacon/Cheng/Rajan; TR §2.2). void osp_collect(void) {} diff --git a/compiler/runtime/memory_gc.c b/compiler/runtime/memory_gc.c index 6bc2f8bb..c84bd5f8 100644 --- a/compiler/runtime/memory_gc.c +++ b/compiler/runtime/memory_gc.c @@ -333,6 +333,9 @@ void *osp_alloc_tagged(int64_t size, int64_t meta) { // the collector reclaims, so dup/drop carry no work. void osp_retain(void *o) { (void)o; } void osp_release(void *o) { (void)o; } +// Codegen-proved-unique drop (memory_hooks.h) — a no-op like osp_release; the +// separate symbol carries LLVM free-pair attributes in the emitted IR. +void osp_release_unique(void *o) { (void)o; } // Singleton-immortality hook (memory_hooks.h) — meaningful only under ARC. void osp_mem_immortal(void *p) { (void)p; } diff --git a/compiler/runtime/memory_hooks.h b/compiler/runtime/memory_hooks.h index 6b00ba19..b4ad32d2 100644 --- a/compiler/runtime/memory_hooks.h +++ b/compiler/runtime/memory_hooks.h @@ -11,6 +11,17 @@ void osp_retain(void *o); void osp_release(void *o); +// Release a reference codegen PROVES is the only one (a fresh, never-bound, +// never-stored value consumed in the expression that created it). Runtime +// behaviour is identical to osp_release; the separate symbol exists so +// codegen can declare it with LLVM's allocator free-pair attributes +// (allockind("free") / allocptr) and -O2 can delete a provably-dead +// alloc+release pair outright — restoring the [MEM-OWNERSHIP] static-free +// ideal for per-operation Result blocks. Those attributes let LLVM assume +// the pointee is dead after the call, which is only true when rc == 1 — +// hence the uniqueness proof requirement on every emission site. +void osp_release_unique(void *o); + // Mark a shared C-runtime singleton immortal (ARC: rc < 0 — dup/drop skip it // forever). For objects returned from multiple call sites by construction, // e.g. the empty-list singleton. diff --git a/compiler/runtime/memory_runtime.c b/compiler/runtime/memory_runtime.c index a385f6aa..ccf87513 100644 --- a/compiler/runtime/memory_runtime.c +++ b/compiler/runtime/memory_runtime.c @@ -37,6 +37,9 @@ void *osp_alloc_tagged(int64_t size, int64_t meta) { // duality: under tracing or leak-everything, reference counts carry no work). void osp_retain(void *o) { (void)o; } void osp_release(void *o) { (void)o; } +// Codegen-proved-unique drop (memory_hooks.h) — same no-op here; the symbol +// exists so codegen can attach LLVM free-pair attributes to it. +void osp_release_unique(void *o) { (void)o; } // Singleton-immortality hook (memory_hooks.h) — meaningful only under ARC. void osp_mem_immortal(void *p) { (void)p; } diff --git a/crates/osprey-codegen/src/arc.rs b/crates/osprey-codegen/src/arc.rs index 56e9ad68..ab3366e7 100644 --- a/crates/osprey-codegen/src/arc.rs +++ b/crates/osprey-codegen/src/arc.rs @@ -18,14 +18,23 @@ use osprey_ast::{Expr, Stmt}; const RETAIN_DECL: &str = "declare void @osp_retain(i8*)"; const RELEASE_DECL: &str = "declare void @osp_release(i8*)"; +/// The proved-unique drop: `allockind("free")`/`allocptr` pair it with +/// `osp_alloc`/`osp_alloc_tagged` (same `alloc-family`), so -O2 deletes a +/// non-escaping alloc+release outright — the [MEM-OWNERSHIP] static free. +/// Sound ONLY where codegen proves rc == 1 (see [`consume_fresh`]): the +/// attributes let LLVM treat the pointee as dead after the call. +const RELEASE_UNIQUE_DECL: &str = "declare void @osp_release_unique(i8* allocptr noundef) allockind(\"free\") mustprogress nounwind willreturn \"alloc-family\"=\"osprey\""; /// One owned value: the SSA operand it was registered under (for move /// detection at `bind`), the binding name once `let`-bound (for last-use -/// drops, M6), and the entry-block spill slot holding it. +/// drops, M6), the entry-block spill slot holding it, and whether the block +/// provably holds no managed references (a scalar-payload Result with no +/// heap errmsg — eligible for [`consume_fresh`]). struct Entry { operand: String, name: Option, slot: String, + pure_scalar: bool, } /// The per-function ownership ledger: a stack of frames (function body, @@ -85,10 +94,50 @@ pub(crate) fn own(cg: &mut Codegen, v: &Value) { operand: v.operand.clone(), name: None, slot, + pure_scalar: false, }); } } +/// Mark the just-owned `v` as holding no managed references (its producer +/// proved a scalar payload and a non-heap errmsg), enabling [`consume_fresh`]. +pub(crate) fn mark_pure_scalar(cg: &mut Codegen, v: &Value) { + if let Some(e) = cg + .arc + .frames + .last_mut() + .and_then(|f| f.last_mut()) + .filter(|e| e.operand == v.operand) + { + e.pure_scalar = true; + } +} + +/// Consume a freshly produced, never-bound owner at its immediate unwrap: +/// pop the newest innermost-frame entry when it is `v` itself, unnamed and +/// pure-scalar, and drop it via `@osp_release_unique` — whose free-pair +/// attributes let -O2 delete the whole non-escaping alloc+release. The gates +/// make the rc == 1 proof: same SSA register ⇒ the creation dominates and +/// nothing was rebound; newest entry + unnamed ⇒ no store or `let` aliased +/// it; pure-scalar ⇒ eliding the pair drops no interior references either. +pub(crate) fn consume_fresh(cg: &mut Codegen, v: &Value) { + let fresh = cg + .arc + .frames + .last() + .and_then(|f| f.last()) + .is_some_and(|e| e.operand == v.operand && e.name.is_none() && e.pure_scalar); + if !fresh { + return; + } + if let Some(e) = cg.arc.frames.last_mut().and_then(Vec::pop) { + cg.add_extern(RELEASE_UNIQUE_DECL); + let ptr = as_i8ptr(cg, v); + cg.emit(format!("call void @osp_release_unique(i8* {ptr})")); + cg.emit(format!("store i8* null, i8** {}", e.slot)); + } +} + /// Open a region: statement, loop body. pub(crate) fn push_frame(cg: &mut Codegen) { cg.arc.frames.push(Vec::new()); @@ -135,6 +184,7 @@ pub(crate) fn bind_owned(cg: &mut Codegen, name: &str, v: &Value) { operand: v.operand.clone(), name: Some(name.to_string()), slot, + pure_scalar: false, }, ); } diff --git a/crates/osprey-codegen/src/result.rs b/crates/osprey-codegen/src/result.rs index a4962747..083102dc 100644 --- a/crates/osprey-codegen/src/result.rs +++ b/crates/osprey-codegen/src/result.rs @@ -52,6 +52,12 @@ pub(crate) fn make_result( cg.emit(format!("store i8* {errmsg}, i8** {mp}")); let out = Value::result(obj, inner).with_payload_owner(payload_owner); crate::arc::own(cg, &out); + // A scalar payload plus a non-register errmsg (null / rodata constant) + // means the block holds zero managed references — eligible for the + // consume-at-unwrap fast path that lets -O2 delete the whole block. + if !matches!(inner, LType::Str | LType::Ptr) && !errmsg.starts_with('%') { + crate::arc::mark_pure_scalar(cg, &out); + } Ok(out) } @@ -225,7 +231,9 @@ pub(crate) fn repack_to_inner(cg: &mut Codegen, v: Value, inner: LType) -> Resul /// yielding its success payload; a non-Result value passes through. pub(crate) fn unwrap(cg: &mut Codegen, v: Value) -> Value { if v.result_inner.is_some() { - load_value(cg, &v) + let out = load_value(cg, &v); + crate::arc::consume_fresh(cg, &v); + out } else { v } diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..9d714756 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,6 @@ +[tool] + +[tool.basilisk] + +[tool.basilisk.rule-tags] +basilisk = "error" diff --git a/website/src/_includes/benchmarks-tables.html b/website/src/_includes/benchmarks-tables.html index bd3922ff..7c2ed502 100644 --- a/website/src/_includes/benchmarks-tables.html +++ b/website/src/_includes/benchmarks-tables.html @@ -1,6 +1,6 @@ -
    1CPU wins (fastest of all)
    1.42×CPU vs Rust
    1.61×CPU vs C
    1.09×CPU vs OCaml
    0.76×CPU vs Haskell
    0.71×CPU vs Rust (wasm)

    Osprey is the fastest of all five languages on primes. Lower is better; ★ marks an Osprey win.

    +
    0CPU wins (fastest of all)
    2.32×CPU vs Rust
    2.65×CPU vs C
    1.89×CPU vs C# (AOT)
    0.95×CPU vs Dart (AOT)
    1.82×CPU vs OCaml
    1.27×CPU vs Haskell
    1.18×CPU vs Rust (wasm)

    Osprey is the fastest of all five languages on —. Lower is better; ★ marks an Osprey win.

    CPU time

    -
    BenchmarkOspreyOsprey (GC)RustCOCamlHaskellOsprey (wasm)Rust (wasm)
    ackermann127.4 ms126.6 ms128.6 ms126.3 ms110.8 ms65.1 ms130.6 ms136.1 ms
    binarytrees417.1 ms1.498 s711.9 ms348.2 ms50.2 ms17.0 ms516.0 ms793.0 ms
    coins72.1 ms70.2 ms73.9 ms69.0 ms91.4 ms52.2 ms92.1 ms100.5 ms
    collatz12.5 ms11.8 ms11.2 ms9.1 ms53.8 ms35.0 ms19.2 ms22.6 ms
    coprime62.9 ms61.3 ms59.1 ms58.3 ms86.9 ms100.1 ms69.4 ms71.3 ms
    digitsum5.2 ms5.1 ms5.3 ms5.2 ms18.5 ms29.7 ms12.3 ms17.3 ms
    exprtree6.7 ms20.6 ms10.2 ms5.7 ms5.2 ms16.6 ms—19.8 ms
    factorial33.9 ms31.7 ms32.0 ms32.0 ms44.0 ms52.5 ms42.0 ms45.8 ms
    fib20.5 ms20.5 ms16.2 ms17.8 ms23.8 ms45.1 ms32.8 ms36.6 ms
    gcdsum75.3 ms71.7 ms71.2 ms71.7 ms96.9 ms100.2 ms79.1 ms82.7 ms
    hanoi39.0 ms36.3 ms36.4 ms36.1 ms59.9 ms53.5 ms47.5 ms51.1 ms
    isqrt12.6 ms12.2 ms10.1 ms9.6 ms19.1 ms40.6 ms23.7 ms21.3 ms
    josephus32.1 ms30.9 ms30.2 ms30.3 ms37.8 ms43.0 ms36.9 ms40.5 ms
    listops499.2 ms651.0 ms1.5 ms1.3 ms2.0 ms16.7 ms—13.1 ms
    mutual12.6 ms11.9 ms12.0 ms11.7 ms28.6 ms34.8 ms23.7 ms28.1 ms
    nestedloop43.6 ms41.4 ms43.2 ms42.0 ms52.3 ms63.6 ms54.3 ms58.0 ms
    pascal27.6 ms26.6 ms27.0 ms26.9 ms43.5 ms57.8 ms42.4 ms47.0 ms
    powmod22.6 ms21.5 ms21.8 ms21.7 ms56.3 ms55.3 ms28.4 ms31.7 ms
    primes6.3 ms ★6.4 ms7.1 ms6.7 ms8.7 ms15.8 ms12.5 ms16.3 ms
    tak32.6 ms32.4 ms32.2 ms32.7 ms43.8 ms63.2 ms85.4 ms91.1 ms
    textstats3.2 ms3.4 ms2.0 ms2.1 ms4.0 ms17.7 ms—12.2 ms
    wordfreq19.3 ms53.3 ms4.4 ms1.5 ms2.4 ms18.4 ms—15.3 ms
    +
    BenchmarkOspreyOsprey (ARC)Osprey (GC)RustCC# (AOT)Dart (AOT)OCamlHaskellOsprey (wasm)Rust (wasm)
    ackermann134.6 ms131.2 ms129.8 ms130.0 ms129.5 ms132.4 ms186.4 ms111.9 ms65.4 ms146.1 ms146.4 ms
    binarytrees555.1 ms1.957 s3.177 s752.6 ms367.3 ms127.7 ms126.9 ms52.3 ms16.3 ms573.7 ms809.2 ms
    coins78.2 ms78.2 ms78.3 ms82.5 ms77.6 ms101.5 ms122.4 ms100.5 ms52.2 ms101.1 ms111.1 ms
    collatz104.9 ms263.3 ms251.2 ms12.5 ms10.2 ms57.0 ms67.0 ms59.2 ms40.5 ms88.0 ms24.2 ms
    coprime67.8 ms67.8 ms67.8 ms65.2 ms63.4 ms77.1 ms106.3 ms90.7 ms103.9 ms75.9 ms77.2 ms
    digitsum137.5 ms375.3 ms358.5 ms5.4 ms5.4 ms16.3 ms28.9 ms18.9 ms29.7 ms104.6 ms18.0 ms
    exprtree8.0 ms26.5 ms27.5 ms10.9 ms6.2 ms6.4 ms13.3 ms5.1 ms16.1 ms—20.2 ms
    factorial261.3 ms843.1 ms666.2 ms35.5 ms35.1 ms37.2 ms51.4 ms48.5 ms53.8 ms196.5 ms48.8 ms
    fib21.1 ms21.0 ms21.2 ms17.3 ms17.7 ms35.9 ms51.6 ms23.9 ms48.4 ms33.0 ms36.7 ms
    gcdsum79.3 ms79.4 ms79.4 ms79.1 ms79.0 ms86.3 ms108.8 ms101.4 ms106.1 ms86.6 ms91.0 ms
    hanoi38.1 ms38.0 ms38.4 ms36.9 ms38.4 ms38.5 ms103.0 ms62.4 ms57.9 ms47.7 ms51.3 ms
    isqrt308.1 ms855.7 ms807.4 ms11.0 ms10.4 ms16.9 ms32.9 ms20.5 ms43.7 ms285.8 ms22.8 ms
    josephus33.3 ms33.3 ms33.3 ms33.5 ms32.9 ms34.9 ms42.1 ms41.1 ms43.7 ms38.5 ms41.9 ms
    listops531.7 ms1.088 s660.5 ms1.4 ms1.2 ms2.9 ms9.8 ms1.9 ms18.1 ms—11.4 ms
    mutual11.8 ms11.1 ms10.8 ms11.6 ms11.7 ms19.1 ms297.7 ms28.6 ms32.6 ms23.4 ms27.0 ms
    nestedloop45.2 ms43.8 ms41.4 ms42.1 ms41.3 ms43.4 ms54.4 ms53.2 ms60.4 ms60.7 ms64.8 ms
    pascal28.4 ms28.5 ms28.4 ms28.3 ms27.8 ms33.4 ms64.7 ms44.3 ms59.7 ms43.4 ms47.1 ms
    powmod23.3 ms23.3 ms23.4 ms23.4 ms23.4 ms34.1 ms50.5 ms60.7 ms58.1 ms30.0 ms33.9 ms
    primes6.5 ms6.5 ms6.5 ms6.7 ms6.5 ms8.6 ms44.1 ms8.5 ms17.3 ms13.1 ms17.1 ms
    tak32.9 ms32.5 ms32.7 ms32.8 ms32.6 ms34.9 ms81.9 ms44.4 ms64.7 ms86.6 ms90.4 ms
    textstats3.5 ms5.1 ms3.6 ms2.0 ms2.1 ms3.7 ms11.0 ms3.8 ms17.3 ms—12.6 ms
    wordfreq22.6 ms78.0 ms70.9 ms4.5 ms1.5 ms3.3 ms10.6 ms2.3 ms17.3 ms—15.6 ms

    Peak memory

    -
    BenchmarkOspreyOsprey (GC)RustCOCamlHaskellOsprey (wasm)Rust (wasm)
    ackermann1.6 MiB ★1.7 MiB1.8 MiB1.6 MiB2.6 MiB15.1 MiB——
    binarytrees905.0 MiB12.3 MiB2.1 MiB1.7 MiB5.1 MiB11.0 MiB——
    coins1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    collatz1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    coprime1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    digitsum1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    exprtree9.0 MiB6.5 MiB2.7 MiB11.5 MiB6.0 MiB11.4 MiB——
    factorial1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    fib1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    gcdsum1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    hanoi1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    isqrt1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    josephus1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    listops2493.5 MiB4.1 MiB1.6 MiB1.4 MiB2.5 MiB11.3 MiB——
    mutual1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    nestedloop1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.0 MiB——
    pascal1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    powmod1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    primes1.4 MiB1.5 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    tak1.4 MiB1.4 MiB1.5 MiB1.4 MiB2.2 MiB11.1 MiB——
    textstats1.4 MiB1.5 MiB1.6 MiB1.4 MiB2.3 MiB11.4 MiB——
    wordfreq52.8 MiB4.4 MiB1.6 MiB1.4 MiB2.3 MiB11.3 MiB——
    +
    BenchmarkOspreyOsprey (ARC)Osprey (GC)RustCC# (AOT)Dart (AOT)OCamlHaskellOsprey (wasm)Rust (wasm)
    ackermann1.7 MiB1.7 MiB1.7 MiB1.8 MiB1.7 MiB7.1 MiB14.2 MiB2.7 MiB15.1 MiB——
    binarytrees905.1 MiB487.5 MiB27.5 MiB2.2 MiB1.7 MiB16.1 MiB22.5 MiB5.2 MiB11.1 MiB——
    coins1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.5 MiB6.9 MiB13.9 MiB2.3 MiB11.1 MiB——
    collatz221.7 MiB65.5 MiB6.6 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    coprime1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    digitsum335.1 MiB65.5 MiB6.6 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    exprtree9.0 MiB6.7 MiB15.2 MiB2.7 MiB11.5 MiB15.2 MiB22.7 MiB6.1 MiB11.4 MiB——
    factorial614.2 MiB129.5 MiB6.6 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.2 MiB11.1 MiB——
    fib1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.9 MiB13.9 MiB2.3 MiB11.1 MiB——
    gcdsum1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    hanoi1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    isqrt779.1 MiB257.5 MiB8.3 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    josephus1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.1 MiB2.3 MiB11.1 MiB——
    listops2493.5 MiB3383.9 MiB3.8 MiB1.7 MiB1.5 MiB7.1 MiB14.3 MiB2.6 MiB11.4 MiB——
    mutual1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB13.9 MiB2.3 MiB11.1 MiB——
    nestedloop1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.9 MiB13.9 MiB2.2 MiB11.1 MiB——
    pascal1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    powmod1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB13.9 MiB2.3 MiB11.1 MiB——
    primes1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.2 MiB11.1 MiB——
    tak1.5 MiB1.5 MiB1.5 MiB1.6 MiB1.4 MiB6.8 MiB14.0 MiB2.3 MiB11.1 MiB——
    textstats1.5 MiB1.6 MiB1.5 MiB1.6 MiB1.5 MiB6.8 MiB14.1 MiB2.3 MiB11.4 MiB——
    wordfreq59.0 MiB91.9 MiB4.7 MiB1.6 MiB1.4 MiB6.8 MiB14.2 MiB2.3 MiB11.4 MiB——