diff --git a/crates/echo_ast/src/lib.rs b/crates/echo_ast/src/lib.rs index 09a8bd4d..468e0046 100644 --- a/crates/echo_ast/src/lib.rs +++ b/crates/echo_ast/src/lib.rs @@ -6,7 +6,7 @@ mod pretty; -pub use pretty::format_file; +pub use pretty::{FormatError, format_file, format_file_with_comments}; use echo_source::{SourceId, Span}; use echo_syntax::LeaderKind; @@ -94,6 +94,33 @@ pub enum Stmt { Expr(Expr), } +impl Stmt { + /// Source span of the whole statement, including any braced body. + #[must_use] + pub fn span(&self) -> Span { + match self { + Self::Bind(s) => s.span, + Self::MultiBind(s) => s.span, + Self::Assign(s) => s.span, + Self::Struct(s) | Self::StructExt(s) => s.span, + Self::If(s) => s.span, + Self::ElseIf(s) => s.span, + Self::Else(s) => s.span, + Self::ErrorReturn(s) => s.span, + Self::Return(s) => s.span, + Self::Loop(s) => s.span, + Self::Break { span } | Self::Continue { span } => *span, + Self::Match(s) => s.span, + Self::TaskSpawn(s) => s.span, + Self::TaskJoin(s) => s.span, + Self::EffectBlock(s) => s.span, + Self::Import(s) => s.span, + Self::Export(s) => s.span, + Self::Expr(e) => e.span(), + } + } +} + /// `& { … }` or `& name = { … }` — auto-unwrap result/option; short-circuit on fail. #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)] pub struct EffectBlockStmt { diff --git a/crates/echo_ast/src/pretty.rs b/crates/echo_ast/src/pretty.rs index 9bed778d..e36cd86c 100644 --- a/crates/echo_ast/src/pretty.rs +++ b/crates/echo_ast/src/pretty.rs @@ -3,52 +3,265 @@ //! Rules: `docs/syntax.md`, `docs/pipeline.md` § formatter — leaders, same-line //! `{`, indentation, no trailing commas. Does not change program meaning. +use echo_source::Span; + use crate::{ AssignTarget, BinaryOp, BindLeader, BindStmt, Expr, File, Ident, ImportPathSeg, LoopKind, - MatchArmKind, MultiBindStmt, Stmt, StringKind, TaskBody, TaskJoinKind, UnaryOp, Width, + MatchArm, MatchArmKind, MultiBindStmt, Stmt, StringKind, TaskBody, TaskJoinKind, UnaryOp, + Width, }; const INDENT: &str = " "; +/// Why a file could not be formatted without losing a comment. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FormatError { + /// Stable diagnostic code (`fmt-comment-in-expression`). + pub code: &'static str, + pub message: String, + /// Source span of the comment that could not be placed. + pub span: Span, +} + +/// Printer state: output text plus the source and comment spans that let the +/// formatter keep `;` comments and blank lines (`docs/pipeline.md` § formatter). +struct Out<'a> { + text: String, + src: &'a str, + comments: &'a [Span], + next: usize, + error: Option, +} + +impl<'a> Out<'a> { + fn new(src: &'a str, comments: &'a [Span]) -> Self { + Self { + text: String::new(), + src, + comments, + next: 0, + error: None, + } + } + + fn push(&mut self, c: char) { + self.text.push(c); + } + + fn push_str(&mut self, s: &str) { + self.text.push_str(s); + } + + fn comment_text(&self, c: Span) -> &'a str { + let bytes = self.src.as_bytes(); + let (a, b) = (c.start.0 as usize, (c.end.0 as usize).min(bytes.len())); + self.src.get(a..b).unwrap_or("").trim_end() + } + + /// True when the source has at least one blank line between byte offsets. + fn blank_between(&self, from: u32, to: u32) -> bool { + let bytes = self.src.as_bytes(); + let (a, b) = (from as usize, (to as usize).min(bytes.len())); + a < b && bytes[a..b].iter().filter(|c| **c == b'\n').count() >= 2 + } + + fn comment_before(&self, upto: u32) -> bool { + self.comments + .get(self.next) + .is_some_and(|c| c.end.0 <= upto) + } + + /// Consume a comment that sits on the same line right after `stmt_end`. + fn take_trailing(&mut self, stmt_end: u32, limit: u32) -> Option { + let c = *self.comments.get(self.next)?; + if c.start.0 < stmt_end || c.start.0 >= limit { + return None; + } + let gap = self + .src + .as_bytes() + .get(stmt_end as usize..c.start.0 as usize)?; + if gap.contains(&b'\n') { + return None; + } + self.next += 1; + Some(c) + } + + /// Consume a comment on the first line of a braced node, before its body. + fn take_header_comment(&mut self, owner_start: u32, limit: u32) -> Option { + let c = *self.comments.get(self.next)?; + if c.start.0 < owner_start || c.start.0 >= limit { + return None; + } + let gap = self + .src + .as_bytes() + .get(owner_start as usize..c.start.0 as usize)?; + if gap.contains(&b'\n') { + return None; + } + self.next += 1; + Some(c) + } + + /// A comment that starts inside a statement but was not placed by a nested + /// statement list sits in the middle of an expression. Never drop it. + fn reject_inner_comment(&mut self, stmt: Span) { + if self.error.is_some() { + return; + } + if let Some(c) = self.comments.get(self.next) + && c.start.0 < stmt.end.0 + { + self.error = Some(FormatError { + code: "fmt-comment-in-expression", + message: "comment sits inside an expression; move it to its own line".into(), + span: *c, + }); + } + } +} + /// Format a complete file to canonical source text (trailing newline). +/// +/// This entry point has no source text, so it cannot place `;` comments or +/// blank lines. Use [`format_file_with_comments`] for user source. #[must_use] pub fn format_file(file: &File) -> String { - let mut out = String::new(); - for stmt in &file.stmts { - write_stmt(stmt, 0, &mut out); - out.push('\n'); + format_file_with_comments(file, "", &[]).unwrap_or_default() +} + +/// Format a file and keep its `;` comments and blank lines. +/// +/// `src` is the text the AST was parsed from and `comments` are the lexer's +/// comment spans in source order. Rules: one blank line is kept where the +/// source had one or more, none is added, none starts or ends a block, and a +/// comment on the same line as a statement stays on that line. A comment inside +/// an expression has no safe place, so it is an error and nothing is rewritten. +pub fn format_file_with_comments( + file: &File, + src: &str, + comments: &[Span], +) -> Result { + let mut out = Out::new(src, comments); + write_list( + &file.stmts, + file.span.end.0, + 0, + &mut out, + Stmt::span, + |stmt, out| write_stmt(stmt, 0, out), + ); + if let Some(err) = out.error { + return Err(err); } - if out.is_empty() { - out.push('\n'); + // Last line of defense: a comment no list consumed must never vanish. + if let Some(c) = out.comments.get(out.next) { + return Err(FormatError { + code: "fmt-comment-unplaced", + message: "comment could not be placed; file left unchanged".into(), + span: *c, + }); } - out + if out.text.is_empty() { + out.text.push('\n'); + } + Ok(out.text) } -fn write_indent(level: usize, out: &mut String) { +fn write_indent(level: usize, out: &mut Out<'_>) { for _ in 0..level { out.push_str(INDENT); } } -fn write_block(body: &[Stmt], level: usize, out: &mut String) { +/// Offset of the closing `}` of a braced node (spans end after it). +fn brace_end(span: Span) -> u32 { + span.end.0.saturating_sub(1) +} + +/// Write `items` one per line at `level`, with comments and blank lines from +/// the source. `end` bounds the comments that belong to this list. +fn write_list( + items: &[T], + end: u32, + level: usize, + out: &mut Out<'_>, + span_of: impl Fn(&T) -> Span, + mut write: impl FnMut(&T, &mut Out<'_>), +) { + let mut prev_end: Option = None; + for item in items { + let span = span_of(item); + flush_comments(span.start.0, level, &mut prev_end, out); + if let Some(prev) = prev_end + && out.blank_between(prev, span.start.0) + { + out.push('\n'); + } + write_indent(level, out); + write(item, out); + let mut last = span.end.0; + if let Some(c) = out.take_trailing(span.end.0, end.max(span.end.0)) { + out.push(' '); + let text = out.comment_text(c); + out.push_str(text); + last = c.end.0; + } + out.push('\n'); + out.reject_inner_comment(span); + prev_end = Some(last); + } + flush_comments(end, level, &mut prev_end, out); +} + +/// Emit own-line comments that end at or before `upto`. +fn flush_comments(upto: u32, level: usize, prev_end: &mut Option, out: &mut Out<'_>) { + while let Some(&c) = out.comments.get(out.next) { + if c.end.0 > upto { + break; + } + if let Some(prev) = *prev_end + && out.blank_between(prev, c.start.0) + { + out.push('\n'); + } + write_indent(level, out); + let text = out.comment_text(c); + out.push_str(text); + out.push('\n'); + *prev_end = Some(c.end.0); + out.next += 1; + } +} + +/// `owner` is the span of the node that owns the braces (statement, arm, or fn). +fn write_block(body: &[Stmt], owner: Span, level: usize, out: &mut Out<'_>) { + let end = brace_end(owner); out.push_str(" {"); - if body.is_empty() { + // A comment on the header line (`? x { ; why`) stays on that line. + let first_stmt = body.first().map_or(end, |s| s.span().start.0); + if let Some(c) = out.take_header_comment(owner.start.0, first_stmt.min(end)) { + out.push(' '); + let text = out.comment_text(c); + out.push_str(text); + } + if body.is_empty() && !out.comment_before(end) { out.push('\n'); write_indent(level, out); out.push('}'); return; } out.push('\n'); - for s in body { - write_indent(level + 1, out); + write_list(body, end, level + 1, out, Stmt::span, |s, out| { write_stmt(s, level + 1, out); - out.push('\n'); - } + }); write_indent(level, out); out.push('}'); } -fn write_stmt(stmt: &Stmt, level: usize, out: &mut String) { +fn write_stmt(stmt: &Stmt, level: usize, out: &mut Out<'_>) { match stmt { Stmt::Bind(b) => write_bind(b, level, out), Stmt::MultiBind(m) => write_multi_bind(m, level, out), @@ -61,26 +274,26 @@ fn write_stmt(stmt: &Stmt, level: usize, out: &mut String) { Stmt::Struct(s) => { out.push_str("% "); out.push_str(&s.name.name); - write_block(&s.members, level, out); + write_block(&s.members, s.span, level, out); } Stmt::StructExt(s) => { out.push_str("@ "); out.push_str(&s.name.name); - write_block(&s.members, level, out); + write_block(&s.members, s.span, level, out); } Stmt::If(s) => { out.push_str("? "); write_expr(&s.cond, 0, level, out); - write_block(&s.body, level, out); + write_block(&s.body, s.span, level, out); } Stmt::ElseIf(s) => { out.push_str(": "); write_expr(&s.cond, 0, level, out); - write_block(&s.body, level, out); + write_block(&s.body, s.span, level, out); } Stmt::Else(s) => { out.push_str(":"); - write_block(&s.body, level, out); + write_block(&s.body, s.span, level, out); } Stmt::ErrorReturn(s) => { out.push_str("! "); @@ -96,19 +309,19 @@ fn write_stmt(stmt: &Stmt, level: usize, out: &mut String) { Stmt::Loop(s) => match &s.kind { LoopKind::Infinite => { out.push('*'); - write_block(&s.body, level, out); + write_block(&s.body, s.span, level, out); } LoopKind::While(e) => { out.push_str("* "); write_expr(e, 0, level, out); - write_block(&s.body, level, out); + write_block(&s.body, s.span, level, out); } LoopKind::For { item, iter } => { out.push_str("* "); out.push_str(&item.name); out.push_str(" : "); write_expr(iter, 0, level, out); - write_block(&s.body, level, out); + write_block(&s.body, s.span, level, out); } }, Stmt::Break { .. } => out.push('<'), @@ -118,34 +331,14 @@ fn write_stmt(stmt: &Stmt, level: usize, out: &mut String) { write_expr(&m.scrutinee, 0, level, out); out.push_str(" {"); out.push('\n'); - for arm in &m.arms { - write_indent(level + 1, out); - match &arm.kind { - MatchArmKind::Values(ps) => { - for (i, p) in ps.iter().enumerate() { - if i > 0 { - out.push_str(", "); - } - write_expr(p, 0, level, out); - } - } - MatchArmKind::Type { name } => { - out.push_str("% "); - out.push_str(&name.name); - } - MatchArmKind::BindOk { name } => { - out.push_str("$ "); - out.push_str(&name.name); - } - MatchArmKind::BindErr { name } => { - out.push_str("! "); - out.push_str(&name.name); - } - MatchArmKind::Default => out.push(':'), - } - write_block(&arm.body, level + 1, out); - out.push('\n'); - } + write_list( + &m.arms, + brace_end(m.span), + level + 1, + out, + |arm| arm.span, + |arm, out| write_arm(arm, level + 1, out), + ); write_indent(level, out); out.push('}'); } @@ -156,7 +349,7 @@ fn write_stmt(stmt: &Stmt, level: usize, out: &mut String) { out.push_str(&b.name); out.push_str(" ="); } - write_task_body(&s.body, level, out); + write_task_body(&s.body, s.span, level, out); } Stmt::TaskJoin(s) => match &s.kind { TaskJoinKind::Block { bind, body } => { @@ -166,7 +359,7 @@ fn write_stmt(stmt: &Stmt, level: usize, out: &mut String) { out.push_str(&b.name); out.push_str(" ="); } - write_block(body, level, out); + write_block(body, s.span, level, out); } TaskJoinKind::Handle { bind, handle } => { out.push_str("- "); @@ -184,7 +377,7 @@ fn write_stmt(stmt: &Stmt, level: usize, out: &mut String) { out.push_str(&b.name); out.push_str(" ="); } - write_block(&s.body, level, out); + write_block(&s.body, s.span, level, out); } Stmt::Import(s) => { out.push_str("/ "); @@ -203,7 +396,34 @@ fn write_stmt(stmt: &Stmt, level: usize, out: &mut String) { } } -fn write_bind(b: &BindStmt, level: usize, out: &mut String) { +fn write_arm(arm: &MatchArm, level: usize, out: &mut Out<'_>) { + match &arm.kind { + MatchArmKind::Values(ps) => { + for (i, p) in ps.iter().enumerate() { + if i > 0 { + out.push_str(", "); + } + write_expr(p, 0, level - 1, out); + } + } + MatchArmKind::Type { name } => { + out.push_str("% "); + out.push_str(&name.name); + } + MatchArmKind::BindOk { name } => { + out.push_str("$ "); + out.push_str(&name.name); + } + MatchArmKind::BindErr { name } => { + out.push_str("! "); + out.push_str(&name.name); + } + MatchArmKind::Default => out.push(':'), + } + write_block(&arm.body, arm.span, level, out); +} + +fn write_bind(b: &BindStmt, level: usize, out: &mut Out<'_>) { out.push_str(bind_leader_glyph(b.leader)); out.push(' '); out.push_str(&b.name.name); @@ -213,7 +433,7 @@ fn write_bind(b: &BindStmt, level: usize, out: &mut String) { } } -fn write_multi_bind(m: &MultiBindStmt, level: usize, out: &mut String) { +fn write_multi_bind(m: &MultiBindStmt, level: usize, out: &mut Out<'_>) { out.push_str(bind_leader_glyph(m.leader)); out.push(' '); for (i, it) in m.items.iter().enumerate() { @@ -236,7 +456,7 @@ fn bind_leader_glyph(l: BindLeader) -> &'static str { } } -fn write_assign_target(t: &AssignTarget, level: usize, out: &mut String) { +fn write_assign_target(t: &AssignTarget, level: usize, out: &mut Out<'_>) { match t { AssignTarget::Name(n) => out.push_str(&n.name), AssignTarget::Field { base, field } => { @@ -259,7 +479,7 @@ fn write_assign_target(t: &AssignTarget, level: usize, out: &mut String) { } } -fn write_import_path(path: &[ImportPathSeg], out: &mut String) { +fn write_import_path(path: &[ImportPathSeg], out: &mut Out<'_>) { // `./a/b` → Dot, Name(a), Name(b); `std/io` → Name(std), Name(io); // `github.com/x` → Name("github.com"), Name(x) (parser coalesces host dots). let mut i = 0; @@ -297,9 +517,9 @@ fn write_import_path(path: &[ImportPathSeg], out: &mut String) { } } -fn write_task_body(body: &TaskBody, level: usize, out: &mut String) { +fn write_task_body(body: &TaskBody, owner: Span, level: usize, out: &mut Out<'_>) { match body { - TaskBody::Block(stmts) => write_block(stmts, level, out), + TaskBody::Block(stmts) => write_block(stmts, owner, level, out), TaskBody::Call(e) => { out.push(' '); write_expr(e, 0, level, out); @@ -316,7 +536,7 @@ fn write_task_body(body: &TaskBody, level: usize, out: &mut String) { } out.push(']'); } - write_block(body, level, out); + write_block(body, owner, level, out); } } } @@ -368,7 +588,7 @@ fn bin_glyph(op: BinaryOp) -> &'static str { } /// `stmt_level` is the indent of the containing statement (for nested fn blocks). -fn write_expr(e: &Expr, parent_prec: u8, stmt_level: usize, out: &mut String) { +fn write_expr(e: &Expr, parent_prec: u8, stmt_level: usize, out: &mut Out<'_>) { match e { Expr::Name(Ident { name, .. }) => out.push_str(name), Expr::Number { text, width, .. } => { @@ -505,7 +725,7 @@ fn write_expr(e: &Expr, parent_prec: u8, stmt_level: usize, out: &mut String) { } out.push('}'); } - Expr::Fn { params, body, .. } => { + Expr::Fn { params, body, span } => { out.push('('); for (i, p) in params.iter().enumerate() { if i > 0 { @@ -514,7 +734,7 @@ fn write_expr(e: &Expr, parent_prec: u8, stmt_level: usize, out: &mut String) { out.push_str(&p.name); } out.push(')'); - write_block(body, stmt_level, out); + write_block(body, *span, stmt_level, out); } Expr::Group { expr, .. } => { out.push('('); @@ -550,6 +770,19 @@ mod tests { } } + /// A comment outside every statement list is an error, never silently lost. + #[test] + fn unplaced_comment_is_an_error() { + let file = File { + source: SourceId::from_u32(0), + stmts: vec![], + span: sp(), + }; + let beyond = Span::new(SourceId::from_u32(0), BytePos(50), BytePos(55)); + let err = format_file_with_comments(&file, "", &[beyond]).unwrap_err(); + assert_eq!(err.code, "fmt-comment-unplaced"); + } + #[test] fn formats_simple_bind() { let file = File { diff --git a/crates/echo_lexer/src/lib.rs b/crates/echo_lexer/src/lib.rs index 647a3831..c80a295c 100644 --- a/crates/echo_lexer/src/lib.rs +++ b/crates/echo_lexer/src/lib.rs @@ -168,6 +168,10 @@ pub struct Token { #[derive(Debug, Clone, PartialEq, Eq)] pub struct Lexed { pub tokens: Vec, + /// `;` line comments in source order. The span runs from `;` to the end of + /// the line (newline excluded). Comments are not tokens; the formatter uses + /// this list so it never re-scans source and mistakes a `;` inside a string. + pub comments: Vec, pub diagnostics: Diagnostics, } @@ -185,6 +189,7 @@ struct Lexer<'a> { /// Next non-trivia token is at statement start (after newline / BOF / indent). at_statement_start: bool, tokens: Vec, + comments: Vec, diagnostics: Diagnostics, } @@ -197,6 +202,7 @@ impl<'a> Lexer<'a> { pos: 0, at_statement_start: true, tokens: Vec::new(), + comments: Vec::new(), diagnostics: Diagnostics::new(), } } @@ -250,6 +256,7 @@ impl<'a> Lexer<'a> { Lexed { tokens: self.tokens, + comments: self.comments, diagnostics: self.diagnostics, } } @@ -265,6 +272,7 @@ impl<'a> Lexer<'a> { fn skip_line_comment(&mut self) { // `;` already at pos + let start = self.pos; while self.pos < self.bytes.len() { let b = self.bytes[self.pos]; if b == b'\n' || b == b'\r' { @@ -272,6 +280,8 @@ impl<'a> Lexer<'a> { } self.pos += 1; } + let span = self.span_from(start); + self.comments.push(span); // Do not consume newline here — let main loop handle it so // at_statement_start is set correctly. } @@ -795,6 +805,21 @@ mod tests { lex(map.get(id).unwrap()) } + #[test] + fn comments_are_recorded_with_spans() { + let src = "; head\n$ x = 1 ; tail\n$ s = \"a;b\"\n"; + let mut map = SourceMap::new(); + let id = map.add("test.echo", src); + let lexed = lex(map.get(id).unwrap()); + let texts: Vec<&str> = lexed + .comments + .iter() + .map(|c| &src[c.start.0 as usize..c.end.0 as usize]) + .collect(); + // The `;` inside the string literal is not a comment. + assert_eq!(texts, vec!["; head", "; tail"]); + } + fn kinds(lexed: &Lexed) -> Vec { lexed .tokens diff --git a/crates/echo_parser/src/lib.rs b/crates/echo_parser/src/lib.rs index 5dca894f..51d550c5 100644 --- a/crates/echo_parser/src/lib.rs +++ b/crates/echo_parser/src/lib.rs @@ -51,6 +51,10 @@ pub fn parse(source: &SourceFile) -> Parsed { /// Format Echo source via shared parse + AST pretty-print (`xo fmt`). /// +/// Keeps `;` comments and blank lines (see `echo_ast::format_file_with_comments`). +/// A comment that sits inside an expression has no safe place, so it is an error +/// (`fmt-comment-in-expression`) and the caller must not rewrite the file. +/// /// Returns `Ok(canonical)` when parse succeeds with a file and no error /// diagnostics. On failure, returns diagnostics (caller must not write success). pub fn format_source(source: &SourceFile) -> Result { @@ -63,7 +67,16 @@ pub fn format_source(source: &SourceFile) -> Result { d.push(echo_diagnostics::Diagnostic::error("no AST produced").with_code("fmt-no-ast")); return Err(d); }; - Ok(echo_ast::format_file(file)) + let comments = lex(source).comments; + echo_ast::format_file_with_comments(file, source.text(), &comments).map_err(|e| { + let mut d = Diagnostics::new(); + d.push( + echo_diagnostics::Diagnostic::error(e.message) + .with_code(e.code) + .with_span(e.span), + ); + d + }) } fn parse_uncached(source: &SourceFile) -> Parsed { @@ -154,6 +167,7 @@ fn decode_parsed(bytes: &[u8], source: &SourceFile) -> Option { file: blob.file, lexed: Lexed { tokens: vec![], + comments: vec![], diagnostics: Diagnostics::new(), }, diagnostics, @@ -589,6 +603,94 @@ $ a = 1 (once, twice) } + fn fmt(src: &str) -> Result { + let mut map = SourceMap::new(); + let id = map.add("fmt.echo", src); + format_source(map.get(id).unwrap()) + } + + #[test] + fn format_keeps_header_and_own_line_comments() { + let out = fmt("; header\n\n\n/ std/io\n; before\n$ x = 1\n").unwrap(); + assert_eq!(out, "; header\n\n/ std/io\n; before\n$ x = 1\n"); + } + + #[test] + fn format_keeps_same_line_comment_on_its_line() { + let out = fmt("$ x = 1 ; note\n~ y = 2\n").unwrap(); + assert_eq!(out, "$ x = 1 ; note\n~ y = 2\n"); + } + + #[test] + fn format_collapses_blank_runs_and_adds_none() { + let out = fmt("$ a = 1\n\n\n\n$ b = 2\n$ c = 3\n").unwrap(); + assert_eq!(out, "$ a = 1\n\n$ b = 2\n$ c = 3\n"); + } + + #[test] + fn format_drops_blank_lines_at_block_edges() { + let out = fmt("? 1 == 1 {\n\n $ a = 1\n\n}\n").unwrap(); + assert_eq!(out, "? 1 == 1 {\n $ a = 1\n}\n"); + } + + #[test] + fn format_keeps_dangling_and_empty_block_comments() { + let out = fmt("? 1 == 1 {\n $ a = 1\n ; last\n}\n? 2 == 2 {\n; only\n}\n").unwrap(); + assert_eq!( + out, + "? 1 == 1 {\n $ a = 1\n ; last\n}\n? 2 == 2 {\n ; only\n}\n" + ); + } + + #[test] + fn format_keeps_comments_between_match_arms() { + let src = + "| 1 {\n ; one\n 1 {\n $ a = 1\n }\n\n ; rest\n : {\n }\n}\n"; + assert_eq!(fmt(src).unwrap(), src); + } + + #[test] + fn format_keeps_header_line_comments_on_the_header() { + for src in [ + "? 1 == 1 { ; why\n $ a = 1\n}\n", + "~ i = 0\n* i < 3 { ; note\n ~ i = i + 1\n}\n", + "| 1 {\n 1 { ; one\n $ a = 1\n }\n}\n", + "$ f = (a) { ; doc\n ^ a\n}\n", + "? 1 == 1 { ; empty\n}\n", + ] { + assert_eq!(fmt(src).unwrap(), src, "{src}"); + } + } + + #[test] + fn format_comment_after_one_line_block_stays_after_it() { + // The comment follows `}`, so it trails the whole statement. + let out = fmt("? 1 == 1 { f() } ; after\n").unwrap(); + assert_eq!(out, "? 1 == 1 {\n f()\n} ; after\n"); + } + + #[test] + fn format_leaves_semicolon_in_string_alone() { + let out = fmt("$ s = \"a;b\" ; real\n").unwrap(); + assert_eq!(out, "$ s = \"a;b\" ; real\n"); + } + + #[test] + fn format_with_comments_is_idempotent() { + let src = "; h\n\n$ x = 1 ; t\n? x == 1 {\n ; in\n $ y = 2\n\n ; tail\n}\n"; + let once = fmt(src).unwrap(); + assert_eq!(fmt(&once).unwrap(), once); + } + + #[test] + fn format_rejects_comment_inside_expression() { + let err = fmt("$ xs = [\n 1, ; one\n 2\n]\n").unwrap_err(); + assert_eq!( + err.items()[0].code.as_deref(), + Some("fmt-comment-in-expression") + ); + } + #[test] fn format_idempotent_core_surface() { // Valid Echo with irregular spacing (leaders always have required whitespace). diff --git a/crates/echo_parser/tests/fmt_corpus.rs b/crates/echo_parser/tests/fmt_corpus.rs new file mode 100644 index 00000000..6da19ef9 --- /dev/null +++ b/crates/echo_parser/tests/fmt_corpus.rs @@ -0,0 +1,117 @@ +//! Formatter invariants over every `.echo` file in the repository. +//! +//! For each file that parses cleanly, `format_source` must: +//! 1. succeed and produce source that parses cleanly, +//! 2. keep the program: the `xo ast --kinds` dump of input and output match, +//! 3. keep every `;` comment, in source order, +//! 4. be idempotent. +//! +//! `xo fmt --write` rewrites files in place, so a violation here means data loss. + +use std::fs; +use std::path::{Path, PathBuf}; + +use echo_ast::format_ast_kinds; +use echo_lexer::lex; +use echo_parser::{format_source, parse}; +use echo_source::SourceMap; + +fn repo_root() -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")).join("../..") +} + +fn collect(dir: &Path, out: &mut Vec) { + let Ok(read) = fs::read_dir(dir) else { return }; + for entry in read.flatten() { + let path = entry.path(); + if path.is_dir() { + collect(&path, out); + } else if path.extension().is_some_and(|e| e == "echo") { + out.push(path); + } + } +} + +fn comment_texts(text: &str) -> Vec { + let mut map = SourceMap::new(); + let id = map.add("c.echo", text); + let src = map.get(id).unwrap(); + lex(src) + .comments + .iter() + .map(|c| { + text[c.start.0 as usize..c.end.0 as usize] + .trim_end() + .to_string() + }) + .collect() +} + +fn kinds(text: &str) -> Option { + let mut map = SourceMap::new(); + let id = map.add("k.echo", text); + let parsed = parse(map.get(id).unwrap()); + if parsed.diagnostics.error_count() > 0 { + return None; + } + parsed.file.as_ref().map(format_ast_kinds) +} + +#[test] +fn formatter_preserves_meaning_and_comments_across_the_corpus() { + let root = repo_root(); + let mut files = Vec::new(); + for dir in ["examples", "echo26", "std"] { + collect(&root.join(dir), &mut files); + } + files.sort(); + assert!(files.len() > 100, "corpus too small: {}", files.len()); + + let mut failures: Vec = Vec::new(); + let mut checked = 0usize; + for path in &files { + let text = fs::read_to_string(path).expect("read corpus file"); + let rel = path.strip_prefix(&root).unwrap().display().to_string(); + let Some(before) = kinds(&text) else { + continue; // reject fixtures that do not parse are out of scope + }; + checked += 1; + + let mut map = SourceMap::new(); + let id = map.add("in.echo", &text); + let once = match format_source(map.get(id).unwrap()) { + Ok(out) => out, + Err(_) => { + failures.push(format!("{rel}: format failed")); + continue; + } + }; + + match kinds(&once) { + None => failures.push(format!("{rel}: output does not parse")), + Some(after) if after != before => { + failures.push(format!("{rel}: output changes the AST")); + } + Some(_) => {} + } + if comment_texts(&once) != comment_texts(&text) { + failures.push(format!("{rel}: comments not preserved")); + } + + let mut map2 = SourceMap::new(); + let id2 = map2.add("out.echo", &once); + match format_source(map2.get(id2).unwrap()) { + Ok(twice) if twice == once => {} + _ => failures.push(format!("{rel}: not idempotent")), + } + } + + assert!(checked > 100, "too few parseable files: {checked}"); + assert!( + failures.is_empty(), + "{} of {} files violate formatter invariants:\n{}", + failures.len(), + checked, + failures.join("\n") + ); +} diff --git a/crates/echo_resolver/src/resolve.rs b/crates/echo_resolver/src/resolve.rs index 17113691..7d36d13f 100644 --- a/crates/echo_resolver/src/resolve.rs +++ b/crates/echo_resolver/src/resolve.rs @@ -479,6 +479,7 @@ fn synthetic_runtime_unit(map: &mut SourceMap) -> ModuleUnit { file: None, lexed: Lexed { tokens: vec![], + comments: vec![], diagnostics: Diagnostics::new(), }, diagnostics: Diagnostics::new(), diff --git a/crates/echo_runtime/src/git.rs b/crates/echo_runtime/src/git.rs index 12bb5cd3..61e8e12c 100644 --- a/crates/echo_runtime/src/git.rs +++ b/crates/echo_runtime/src/git.rs @@ -46,7 +46,8 @@ fn pack_checksum(bytes: &[u8]) -> String { hex_encode(&bytes[bytes.len() - 20..]) } -/// 1 if `bytes` is a PACK v2/v3 with a trailer. +/// 1 if `bytes` starts with a PACK v2/v3 header and is at least 32 bytes long. +/// Header check only: the trailer checksum and object data are not verified. #[unsafe(no_mangle)] pub extern "C" fn echo_runtime_git_pack_valid(raw: i64) -> i64 { let bytes = payload(raw); @@ -63,7 +64,12 @@ pub extern "C" fn echo_runtime_git_pack_count(raw: i64) -> i64 { pack_header(&bytes).map(|(_, n)| i64::from(n)).unwrap_or(-1) } -/// Index a pack: `{ ok, count, checksum, objects }` (`objects` = oid hex list). +/// Index a pack: `{ ok, count, checksum, objects }`. +/// +/// `ok` is 1 when the header is valid (same test as `pack_valid`). `count` is +/// the header object count. `checksum` is the stored trailer (last 20 bytes) in +/// hex, not recomputed. `objects` is always empty today: entries are not +/// enumerated, so object ids are not produced (docs/stdlib.md, std/git). #[unsafe(no_mangle)] pub extern "C" fn echo_runtime_git_index_pack(raw: i64) -> i64 { let bytes = payload(raw); @@ -87,8 +93,10 @@ pub extern "C" fn echo_runtime_git_index_pack(raw: i64) -> i64 { out } -/// Split a `git-receive-pack` body into pkt-line commands + trailing PACK. -/// `{ commands, pack }` — `commands` is the text before `0000` / PACK. +/// Split a `git-receive-pack` body at the first `PACK` magic. +/// `{ commands, pack, ref_name, new_oid }`: `commands` is the text before it, +/// `pack` the bytes from it (empty when absent), and `ref_name` / `new_oid` come +/// from the first update command with a 40-char new id and a `refs/` name. #[unsafe(no_mangle)] pub extern "C" fn echo_runtime_git_receive_pack_split(raw: i64) -> i64 { let bytes = payload(raw); @@ -253,6 +261,40 @@ mod tests { assert_eq!(crate::struct_get_value(idx, "count"), 0); } + /// Pins today's behavior: only the header is checked, so a pack whose + /// object data is destroyed still reports valid. Update with the docs if + /// verification is added. + #[test] + fn pack_valid_checks_header_only() { + let mut pack = minimal_pack(); + pack.extend_from_slice(&[0xffu8; 16]); // garbage where object data would be + let h = bytes_to_handle(pack); + assert_eq!(echo_runtime_git_pack_valid(h), 1); + let idx = echo_runtime_git_index_pack(h); + assert_eq!(crate::struct_get_value(idx, "ok"), 1); + } + + /// Pins the documented gap: `objects` is empty even for a valid pack. + #[test] + fn index_pack_objects_are_empty_today() { + let idx = echo_runtime_git_index_pack(bytes_to_handle(minimal_pack())); + let objects = crate::struct_get_value(idx, "objects"); + assert_eq!(crate::list_len_value(objects), 0); + } + + #[test] + fn receive_pack_reads_ref_and_new_oid() { + let oid = "0123456789abcdef0123456789abcdef01234567"; + let old = "0".repeat(40); + let mut body = format!("{old} {oid} refs/heads/main").into_bytes(); + body.extend_from_slice(&minimal_pack()); + let h = echo_runtime_git_receive_pack_split(bytes_to_handle(body)); + let name = crate::struct_get_value(h, "ref_name"); + let new = crate::struct_get_value(h, "new_oid"); + assert_eq!(string_as_str(name).unwrap(), "refs/heads/main"); + assert_eq!(string_as_str(new).unwrap(), oid); + } + #[test] fn receive_pack_splits_on_pack_magic() { let mut body = b"000eunpack ok\n0000".to_vec(); diff --git a/crates/echo_runtime/src/std_ext.rs b/crates/echo_runtime/src/std_ext.rs index 222c9c33..4b25892a 100644 --- a/crates/echo_runtime/src/std_ext.rs +++ b/crates/echo_runtime/src/std_ext.rs @@ -221,6 +221,7 @@ pub extern "C" fn echo_runtime_json_stringify(v: i64) -> i64 { fn json_to_echo(v: &serde_json::Value) -> i64 { use serde_json::Value; match v { + // Lossy by design until JSON values get a tagged representation. Value::Null => 0, Value::Bool(b) => { if *b { @@ -265,13 +266,9 @@ fn echo_to_json(v: i64) -> Option { struct_fields, }; use serde_json::{Map, Value, json}; - if v == 0 { - return Some(Value::Null); - } - if v == 1 { - // ambiguous bool/int — prefer int in stringify of bare 1 - return Some(json!(1)); - } + // Echo values are untagged integers, so 0 and 1 are plain numbers here. + // JSON `null`, `false`, and `true` parse to 0, 0, and 1 and stringify back + // as the numbers 0 and 1 (docs/stdlib.md, std/json). if !is_live_heap(v) { return Some(json!(v)); } @@ -696,6 +693,21 @@ mod tests { assert!(text.contains('1')); } + #[test] + fn json_zero_and_one_stringify_as_numbers() { + assert_eq!(string_data(echo_runtime_json_stringify(0)).unwrap(), "0"); + assert_eq!(string_data(echo_runtime_json_stringify(1)).unwrap(), "1"); + } + + /// `null`, `false`, and `true` map to 0, 0, and 1 and come back as numbers. + #[test] + fn json_null_and_bool_map_to_integers() { + let v = echo_runtime_json_parse(s(r#"{"a":0,"f":false,"n":null,"t":true}"#)); + assert_ne!(v, 0); + let out = string_data(echo_runtime_json_stringify(v)).unwrap(); + assert_eq!(out, r#"{"a":0,"f":0,"n":0,"t":1}"#); + } + /// `+` bodies run on the worker pool. Stringify must not treat a /// worker-allocated string as a bare integer. #[test] diff --git a/crates/echo_syntax/src/tree_sitter.rs b/crates/echo_syntax/src/tree_sitter.rs index a955fde6..696ff1a2 100644 --- a/crates/echo_syntax/src/tree_sitter.rs +++ b/crates/echo_syntax/src/tree_sitter.rs @@ -774,6 +774,22 @@ fn emit_highlights_scm() -> String { ; Captures: leaders vs idents vs literals vs comments.\n\n", ); out.push_str("; Line comments (; → EOL)\n(comment) @comment\n\n"); + // Generic operators and punctuation come first. Consumers resolve two + // captures on one range by taking the last match, so every statement-scoped + // leader capture below must stay after this block or `*`, `%`, `!`, ... + // would render as operators at the start of a statement. + out.push_str( + "; Operators / punctuation (expression dual-use surface)\n\ + ; Keep before the leader captures: later patterns win on the same range.\n\ + [\n\ + \"=\" \"==\" \"!=\" \"===\" \"!==\"\n\ + \"<\" \">\" \"<=\" \">=\" \"<<\" \">>\"\n\ + \"+\" \"-\" \"*\" \"/\" \"%\"\n\ + \"&&\" \"||\" \"&\" \"^\" \"|\" \"~\" \"!\" \"..\"\n\ + \".\" \",\" \":\"\n\ + \"(\" \")\" \"[\" \"]\" \"{\" \"}\"\n\ + ] @operator\n\n", + ); out.push_str("; Leader-only tokens (named rules)\n"); for kind in LEADERS.iter().filter(|k| !k.is_dual_use()) { out.push_str(&format!("({}) @keyword\n", kind.token_name())); @@ -789,7 +805,10 @@ fn emit_highlights_scm() -> String { } // Statement-scoped dual-use glyphs → keyword out.push_str( - "(struct_statement leader: \"%\" @keyword)\n\ + "(bind_statement leader: \"~\" @keyword)\n\ + (return_statement leader: \"^\" @keyword)\n\ + (effect_block_statement leader: \"&\" @keyword)\n\ + (struct_statement leader: \"%\" @keyword)\n\ (match_arm leader: \"%\" @keyword)\n\ (else_if_statement leader: \":\" @keyword)\n\ (else_statement leader: \":\" @keyword)\n\ @@ -834,18 +853,7 @@ fn emit_highlights_scm() -> String { (false_atom) @constant.builtin\n\ (receiver) @variable.builtin\n\ (self_field field: (ident) @property)\n\ - (width_cast type: (ident) @type)\n\n\ - ; Operators / punctuation (expression dual-use surface)\n\ - ; Listed before more-specific leader captures win via query order in editors\n\ - ; that last-match-wins; leaders above already mark statement glyphs.\n\ - [\n\ - \"=\" \"==\" \"!=\" \"===\" \"!==\"\n\ - \"<\" \">\" \"<=\" \">=\" \"<<\" \">>\"\n\ - \"+\" \"-\" \"*\" \"/\" \"%\"\n\ - \"&&\" \"||\" \"&\" \"^\" \"|\" \"~\" \"!\" \"..\"\n\ - \".\" \",\" \":\"\n\ - \"(\" \")\" \"[\" \"]\" \"{\" \"}\"\n\ - ] @operator\n", + (width_cast type: (ident) @type)\n", ); out } @@ -1017,6 +1025,38 @@ mod tests { assert!(h.contains("(comment) @comment")); } + /// Consumers take the last capture on a range, so the generic operator list + /// must precede every statement-scoped anonymous leader capture. Otherwise + /// the loop leader `*` renders as an operator. + #[test] + fn highlights_leaders_follow_operator_list() { + let h = emit_highlights_scm(); + let operators = h.find("] @operator").expect("operator block"); + let mut checked = 0; + for line in h.lines().filter(|l| l.contains("leader: \"")) { + let at = h.find(line).expect("leader line"); + assert!( + at > operators, + "leader capture `{line}` precedes the operator list and would be overridden" + ); + checked += 1; + } + assert!( + checked >= 10, + "expected the statement-scoped leader captures, got {checked}" + ); + assert!(h.contains("(loop_statement leader: \"*\" @keyword)")); + // Every dual-use glyph is an anonymous token, so each needs its own + // statement-scoped capture or it renders as an operator. + for capture in [ + "(bind_statement leader: \"~\" @keyword)", + "(return_statement leader: \"^\" @keyword)", + "(effect_block_statement leader: \"&\" @keyword)", + ] { + assert!(h.contains(capture), "missing {capture}"); + } + } + #[test] fn leaders_match_echo_syntax_table() { let names = leader_token_names(); diff --git a/crates/echo_wasm/src/lib.rs b/crates/echo_wasm/src/lib.rs index 0ccdbaf1..c3bbeef5 100644 --- a/crates/echo_wasm/src/lib.rs +++ b/crates/echo_wasm/src/lib.rs @@ -279,6 +279,19 @@ io.print("sum={sum}") assert_eq!(result.text.as_deref(), Some("$ x = 1\n")); } + /// The Try page Format button rewrites the editor buffer, so it must keep + /// comments and refuse (not drop) one it cannot place. + #[test] + fn format_keeps_comments_and_refuses_unplaceable_ones() { + let kept = format_source_text("; note\n$ x=1 ; tail\n"); + assert!(kept.ok, "{kept:?}"); + assert_eq!(kept.text.as_deref(), Some("; note\n$ x = 1 ; tail\n")); + + let refused = format_source_text("$ xs = [\n 1, ; one\n 2\n]\n"); + assert!(!refused.ok); + assert!(refused.text.is_none()); + } + #[test] fn format_reports_parse_errors() { let result = format_source_text("$ = \n"); diff --git a/crates/xo/src/main.rs b/crates/xo/src/main.rs index 97bc6b00..01e5f467 100644 --- a/crates/xo/src/main.rs +++ b/crates/xo/src/main.rs @@ -622,7 +622,8 @@ fn cmd_fmt(path: &Path, write: bool, check: bool) -> ExitCode { let code = d.code.as_deref().unwrap_or("fmt-error"); eprintln!("error[{code}] {loc}: {}", d.message); } - eprintln!("xo fmt: failed (parse errors)"); + // Parse errors and unplaceable comments both leave the file untouched. + eprintln!("xo fmt: failed, {} left unchanged", path.display()); ExitCode::from(1) } } diff --git a/docs/pipeline.md b/docs/pipeline.md index aec41832..b3047a3b 100644 --- a/docs/pipeline.md +++ b/docs/pipeline.md @@ -261,6 +261,20 @@ Remaining language work is honesty slices on already-locked surface (see - Pretty-print canonical form from `syntax.md` (leaders, braces, no trailing commas). - **Idempotent:** `fmt(fmt(x)) == fmt(x)`. - Must **not** change program meaning. +- **Comments and blank lines** (rules chosen for `xo fmt`, not inherited from + `syntax.md`): + - Every `;` comment is kept, in source order. The lexer records comment spans + (`Lexed::comments`) so a `;` inside a string is never mistaken for one. + - A comment on its own line stays on its own line at the indent of the next + item. A comment on the same line as a statement stays on that line, one + space after the statement. + - One blank line is kept wherever the source has one or more. Runs collapse to + one. None is added, and none starts or ends a block. + - Comments are placed between statements, between match arms, before the + closing `}`, and inside empty blocks. A comment inside an expression has no + safe place: `fmt-comment-in-expression` is an error and nothing is written. +- The one entry point is `echo_parser::format_source`; `xo fmt`, `echo_lsp`, and + `echo_wasm` all call it, so none of them can drop a comment on its own. - Optional: range format; still shared pipeline. ### Language server (`echo_lsp`) diff --git a/docs/roadmap.md b/docs/roadmap.md index 59111d84..534d0ecf 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -256,6 +256,8 @@ without a roadmap update): | `std/fs` | **Done** | paths, whole-file, copy/rename, `% meta`, streaming `% file` | e26 `run/fs` + `xo test` + `examples/misc/fs.echo` | | `std/net` (tcp/, udp/ folders) | **TCP/UDP I/O done** | `std/net/tcp/{conn,listener,socket}`, `udp/socket` | e26 `run/net` | | `std/net/http` | parse + format + **serve** + `handle_connection` | `std/net/http.echo` | e26 `run/http` + app | +| `std/json` JSON values | **Open design.** Values are untagged ints, so true/false/null parse to 1/0/0 and top-level `0`/`false`/`null` fail to parse. Needs a tagged JSON value (bool, null) and its `?` / `==` rules. | [`stdlib.md`](stdlib.md) § JSON value gap | e26 `run/json/003` pins today's lossy mapping | +| `std/git` pack verification | **Partial.** `pack_valid` / `index_pack` check only the header (a pack with destroyed object data still reports valid), and `index_pack().objects` is always empty. Needs trailer verification and oid enumeration. | [`stdlib.md`](stdlib.md), `crates/echo_runtime/src/git.rs` | e26 `run/git/001`; runtime tests pin today's behavior | | App HTTP demo | Finite dispatch + live TCP smoke | [`examples/app/main.echo`](../examples/app/main.echo) | run | | App HTTP server | Long-running `http.serve` | [`examples/app/server.echo`](../examples/app/server.echo) | manual | | App surface tour | Surface exercise | [`examples/app/surface.echo`](../examples/app/surface.echo) | — | @@ -273,7 +275,7 @@ are the public API shape. | Import / export syntax | Locked | `syntax.md` | | Closed compilation graph | Locked (ADR) | [ADR 0006](adr/0006-closed-compilation-graph.md) | | `%` / `@` merge across files | Locked | `syntax.md` | -| Module identity / optional package | **Locked** (ADR 0014) | [`modules.md`](modules.md) · store + `xo get` to implement | +| Module identity / optional package | **Locked** (ADR 0014) | [`modules.md`](modules.md) · `xo get` / `xo home` implemented (package cache) | | Reserved `std` | Specified in samples | `stdlib.md` | Multi-file **syntax** is locked; **resolver policy details** fill in with diff --git a/docs/stdlib.md b/docs/stdlib.md index f338c5d7..654d350a 100644 --- a/docs/stdlib.md +++ b/docs/stdlib.md @@ -264,7 +264,7 @@ See also [`runtime-abi.md`](runtime-abi.md). | **Math** | `math_*` f64 | `std/math` | min/max/abs pure ints | | **Encoding** | — or thin | `std/encoding/hex`, `base64`, `utf8` | hex/base64 roundtrip; strict utf8 valid/decode | | **Path** | `locator_class` + `fs_join` | `std/path` | class/is_abs/is_uri; other helpers; locators | -| **JSON** | `json_parse`, `json_stringify` | `std/json` | product types only | +| **JSON** | `json_parse`, `json_stringify` | `std/json` | product types only; true/false/null are untagged ints (see gap below) | | **Random** | `random_*` | `std/random` | **non-crypto** unless `crypto/random` | | **Log** | — | `std/log` | pure over `io` | | **OS** | `os_*` | `std/os` | pid/cwd/hostname/platform | @@ -448,7 +448,7 @@ Exports must match the `\ ` line in each module. Status of expansive rows is in | `std/encoding/base64` | `encode`, `decode` | suite | | `std/encoding/utf8` | `valid`, `decode` | suite; strict; `str.from_bytes` stays lossy | | `std/path` | `join`, `class`, `is_abs`, `is_uri`, `file_name`, `parent`, `extension`, `clean`, `rel`, `walk` | suite; class 0/1/2 on string or locator; walk is shallow | -| `std/json` | `parse`, `stringify` | suite; product types only | +| `std/json` | `parse`, `stringify` | suite; product types only; true→1, false/null→0 (lossy, see below) | | `std/random` | `seed`, `u64`, `float` | suite; **not** CSPRNG — use `std/crypto/random` | | `std/log` | `emit`, `debug`, `info`, `warn`, `error`, `kv`, `info_kv` | suite; caller passes `min_level` (no global `set_level`) | | `std/os` | `pid`, `cwd`, `chdir`, `hostname`, `platform` | suite | @@ -472,7 +472,7 @@ decision, recorded on the `\ ` line and in this inventory when durable. | `std/net/udp/` | **Done** — folder: `% socket` + free reify surface (struct by ref) | | `std/net/http` serve / handle_connection | **Done** — accept loop + `+ handle_connection`; **Content-Length body** via `http_request_complete`; **stream** via `read_headers` / `handle_connection_stream` / chunked `write_*` | | `std/store` | **Done** — memory + S3-compatible get/put/head/CAS/range | -| `std/git` | **Done** — pack valid/count/index + receive-pack split / upload-pack wants | +| `std/git` | **Partial** — header check, count, receive-pack split, upload-pack wants. **Gaps:** `pack_valid` / `index_pack` read only the header (no trailer or object verification), and `index_pack().objects` is always empty. e26 `run/git/001`; runtime tests pin both. | | `std/str` | **Done** — conversions + text ops + byte `get`/`slice` | | `std/bytes` | **Done** — `get`/`slice`/`cat`/`from_int`/`from_str` / `contains`/`starts_with`/`ends_with` | | `std/list` | **Done** — `len` / `is_empty` / result `get` / `contains` / `sum_ints` / `sort_ints` / `map` / `filter` / `fold` | @@ -507,7 +507,7 @@ or suite failures remain. | `std/str` growth | **Done** (thin) | trim/split/replace/case; e26 `013_trim_split` + `014_parse_float` / `015_parse_float_fail` / `016_from_debug` / `017_from_bytes` / `018_contains`; suite; examples `str_text.echo` / `str_parse.echo` / `str_debug.echo` / `str_from_bytes.echo` / `str_search.echo` | | `std/bytes` growth | **Done** (thin) | contains/starts_with/ends_with; `from_int` LE e26 `007_from_int`; `from_str` UTF-8 e26 `008_from_str`; `slice` e26 `009_slice`; encoding under `std/encoding/*` | | `std/path` | **Done** (thin) | class/is_uri/is_abs on string or locator; e26 `locator/002_class` + suite | -| `std/json` | **Done** (thin) | e26 parse/stringify; product types | +| `std/json` | **Partial** (thin) | e26 parse/stringify (`run/json/003`); product types; **gap:** no tagged bool/null | | `std/random` | **Done** (thin) | seeded e26; **not** CSPRNG | | `std/log` | **Done** (thin) | e26 level filter + `002_kv`; caller-supplied min level | | `std/os` | **Done** (thin) | e26 `001_pid` + `002_platform` + `003_cwd_chdir` / `004_chdir_fail` / `005_hostname`; suite | @@ -554,3 +554,24 @@ strings after `fs.create_dir_all` / other result-returning callees. [ ] scripts/gate echo26 (or filter) green [ ] No userland / runtime; no std/task ``` + +## JSON value gap + +Echo values are untagged integers at runtime, so `std/json` cannot tell JSON +`true`, `false`, `null`, `1`, and `0` apart. Behavior today (e26 +`run/json/003_zero_bool_null_map`): + +| JSON in | Echo value | `stringify` out | +|---------|------------|-----------------| +| `true` | `1` | `1` | +| `false` | `0` | `0` | +| `null` | `0` | `0` | +| `0` | `0` | `0` | + +`{"n":0,"f":false,"t":true}` therefore stringifies as `{"f":0,"n":0,"t":1}`. +A top-level `0`, `false`, or `null` document fails to parse because `0` also +signals failure in `std/json.parse`. + +A faithful round trip needs a tagged JSON value (bool, null) and a rule for how +it behaves under `?` and `==`. That is a language decision, tracked in +[`roadmap.md`](roadmap.md). Until it lands, treat booleans and null as lossy. diff --git a/docs/testing.md b/docs/testing.md index 85c2f973..2f9ae9e6 100644 --- a/docs/testing.md +++ b/docs/testing.md @@ -156,7 +156,7 @@ language form: | semantics | Crate tests for the rule, and `.check` (omit the file when no `sem-*`). Add a reject fixture when the feature is a hard error. | | HIR / MIR / codegen / runtime | Crate tests for lowering / ABI / values, and opt-in `.run` / `.runexit` when we claim Run. | | CLI | `xo` flags used by `e26` (`lex` / `ast` / `check` / `run --diag-codes`). | -| fmt | `echo_ast` pretty unit tests (idempotence). No echo26 fmt stage yet. | +| fmt | `echo_parser` unit tests for comment and blank-line rules, plus `crates/echo_parser/tests/fmt_corpus.rs`: every `.echo` under `examples/`, `echo26/`, and `std/` must format to the same AST, keep every comment, and be idempotent. No echo26 fmt stage yet. | | LSP | `echo_lsp` crate tests over `echo_pipeline::analyze`. | | REPL | `crates/xo/tests/repl_forms.rs` (JIT). Language meaning stays in e26 AOT. | | wasm / www | `cargo test -p echo_wasm`; `scripts/gate web`. Playground run is a host demo. | diff --git a/echo26/run/git/001_pack_and_request_bodies.ast b/echo26/run/git/001_pack_and_request_bodies.ast new file mode 100644 index 00000000..afc9d264 --- /dev/null +++ b/echo26/run/git/001_pack_and_request_bodies.ast @@ -0,0 +1,135 @@ +file + import + seg std + seg io + import + seg std + seg str + import + seg std + seg bytes + import + seg std + seg list + import + seg std + seg git + bind_dollar + name show + fn + param label + param n + bind_dollar + name text + call + field from_int + name str + name n + expr_stmt + call + field print + name io + string_rich + expr_stmt + call + name show + string_rich + call + field pack_valid + name git + call + field from_str + name bytes + string_rich + expr_stmt + call + name show + string_rich + call + field pack_count + name git + call + field from_str + name bytes + string_rich + bind_dollar + name idx + call + field index_pack + name git + call + field from_str + name bytes + string_rich + expr_stmt + call + name show + string_rich + field ok + name idx + expr_stmt + call + name show + string_rich + call + field len + name list + field objects + name idx + bind_dollar + name oid + string_rich + bind_dollar + name old + string_rich + bind_dollar + name wants + call + field upload_pack_wants + name git + string_rich + expr_stmt + call + name show + string_rich + call + field len + name list + name wants + bind_dollar + name cmd + string_rich + bind_dollar + name rp + call + field receive_pack_split + name git + call + field cat + name bytes + call + field from_str + name bytes + name cmd + call + field from_str + name bytes + string_rich + bind_dollar + name name + field ref_name + name rp + expr_stmt + call + field print + name io + name name + expr_stmt + call + name show + string_rich + call + field len + name bytes + field pack + name rp diff --git a/echo26/run/git/001_pack_and_request_bodies.echo b/echo26/run/git/001_pack_and_request_bodies.echo new file mode 100644 index 00000000..c3f9758d --- /dev/null +++ b/echo26/run/git/001_pack_and_request_bodies.echo @@ -0,0 +1,28 @@ +; std/git reads headers and splits request bodies. A header-less buffer is not a pack. +/ std/io +/ std/str +/ std/bytes +/ std/list +/ std/git + +$ show = (label, n) { + $ text = str.from_int(n) + io.print("{label}={text}") +} + +show("valid", git.pack_valid(bytes.from_str("nope"))) +show("count", git.pack_count(bytes.from_str("nope"))) +$ idx = git.index_pack(bytes.from_str("nope")) +show("ok", idx.ok) +show("objects", list.len(idx.objects)) + +$ oid = "0123456789abcdef0123456789abcdef01234567" +$ old = "0000000000000000000000000000000000000000" +$ wants = git.upload_pack_wants("want {oid}\n") +show("wants", list.len(wants)) + +$ cmd = "{old} {oid} refs/heads/main" +$ rp = git.receive_pack_split(bytes.cat(bytes.from_str(cmd), bytes.from_str("PACKrest"))) +$ name = rp.ref_name +io.print(name) +show("pack_len", bytes.len(rp.pack)) diff --git a/echo26/run/git/001_pack_and_request_bodies.lex b/echo26/run/git/001_pack_and_request_bodies.lex new file mode 100644 index 00000000..a88b49cd --- /dev/null +++ b/echo26/run/git/001_pack_and_request_bodies.lex @@ -0,0 +1,196 @@ +leader_slash +ident +slash +ident +leader_slash +ident +slash +ident +leader_slash +ident +slash +ident +leader_slash +ident +slash +ident +leader_slash +ident +slash +ident +leader_dollar +ident +eq +l_paren +ident +comma +ident +r_paren +l_brace +leader_dollar +ident +eq +ident +dot +ident +l_paren +ident +r_paren +ident +dot +ident +l_paren +string_rich +r_paren +r_brace +ident +l_paren +string_rich +comma +ident +dot +ident +l_paren +ident +dot +ident +l_paren +string_rich +r_paren +r_paren +r_paren +ident +l_paren +string_rich +comma +ident +dot +ident +l_paren +ident +dot +ident +l_paren +string_rich +r_paren +r_paren +r_paren +leader_dollar +ident +eq +ident +dot +ident +l_paren +ident +dot +ident +l_paren +string_rich +r_paren +r_paren +ident +l_paren +string_rich +comma +ident +dot +ident +r_paren +ident +l_paren +string_rich +comma +ident +dot +ident +l_paren +ident +dot +ident +r_paren +r_paren +leader_dollar +ident +eq +string_rich +leader_dollar +ident +eq +string_rich +leader_dollar +ident +eq +ident +dot +ident +l_paren +string_rich +r_paren +ident +l_paren +string_rich +comma +ident +dot +ident +l_paren +ident +r_paren +r_paren +leader_dollar +ident +eq +string_rich +leader_dollar +ident +eq +ident +dot +ident +l_paren +ident +dot +ident +l_paren +ident +dot +ident +l_paren +ident +r_paren +comma +ident +dot +ident +l_paren +string_rich +r_paren +r_paren +r_paren +leader_dollar +ident +eq +ident +dot +ident +ident +dot +ident +l_paren +ident +r_paren +ident +l_paren +string_rich +comma +ident +dot +ident +l_paren +ident +dot +ident +r_paren +r_paren +eof diff --git a/echo26/run/git/001_pack_and_request_bodies.run b/echo26/run/git/001_pack_and_request_bodies.run new file mode 100644 index 00000000..51fa7a95 --- /dev/null +++ b/echo26/run/git/001_pack_and_request_bodies.run @@ -0,0 +1,7 @@ +valid=0 +count=-1 +ok=0 +objects=0 +wants=1 +refs/heads/main +pack_len=8 diff --git a/echo26/run/git/001_pack_and_request_bodies.runexit b/echo26/run/git/001_pack_and_request_bodies.runexit new file mode 100644 index 00000000..573541ac --- /dev/null +++ b/echo26/run/git/001_pack_and_request_bodies.runexit @@ -0,0 +1 @@ +0 diff --git a/echo26/run/json/003_zero_bool_null_map.ast b/echo26/run/json/003_zero_bool_null_map.ast new file mode 100644 index 00000000..b28cb801 --- /dev/null +++ b/echo26/run/json/003_zero_bool_null_map.ast @@ -0,0 +1,36 @@ +file + import + seg std + seg io + import + seg std + seg json + match + call + field parse + name json + string_pure + arm_ok v + match + call + field stringify + name json + name v + arm_ok s + expr_stmt + call + field print + name io + name s + arm_err e + expr_stmt + call + field print + name io + name e + arm_err e + expr_stmt + call + field print + name io + name e diff --git a/echo26/run/json/003_zero_bool_null_map.echo b/echo26/run/json/003_zero_bool_null_map.echo new file mode 100644 index 00000000..38a98c7e --- /dev/null +++ b/echo26/run/json/003_zero_bool_null_map.echo @@ -0,0 +1,20 @@ +; JSON 0 stringifies as 0. null and false parse to 0, true parses to 1 +; (Echo values are untagged integers, see docs/stdlib.md std/json). +/ std/io +/ std/json + +| json.parse('{"a":0,"f":false,"n":null,"t":true}') { + $ v { + | json.stringify(v) { + $ s { + io.print(s) + } + ! e { + io.print(e) + } + } + } + ! e { + io.print(e) + } +} diff --git a/echo26/run/json/003_zero_bool_null_map.lex b/echo26/run/json/003_zero_bool_null_map.lex new file mode 100644 index 00000000..b8d4a560 --- /dev/null +++ b/echo26/run/json/003_zero_bool_null_map.lex @@ -0,0 +1,61 @@ +leader_slash +ident +slash +ident +leader_slash +ident +slash +ident +leader_pipe +ident +dot +ident +l_paren +string_pure +r_paren +l_brace +leader_dollar +ident +l_brace +leader_pipe +ident +dot +ident +l_paren +ident +r_paren +l_brace +leader_dollar +ident +l_brace +ident +dot +ident +l_paren +ident +r_paren +r_brace +leader_bang +ident +l_brace +ident +dot +ident +l_paren +ident +r_paren +r_brace +r_brace +r_brace +leader_bang +ident +l_brace +ident +dot +ident +l_paren +ident +r_paren +r_brace +r_brace +eof diff --git a/echo26/run/json/003_zero_bool_null_map.run b/echo26/run/json/003_zero_bool_null_map.run new file mode 100644 index 00000000..e53f1b65 --- /dev/null +++ b/echo26/run/json/003_zero_bool_null_map.run @@ -0,0 +1 @@ +{"a":0,"f":0,"n":0,"t":1} diff --git a/echo26/run/json/003_zero_bool_null_map.runexit b/echo26/run/json/003_zero_bool_null_map.runexit new file mode 100644 index 00000000..573541ac --- /dev/null +++ b/echo26/run/json/003_zero_bool_null_map.runexit @@ -0,0 +1 @@ +0 diff --git a/examples/misc/json.echo b/examples/misc/json.echo index 7432132b..df40bf62 100644 --- a/examples/misc/json.echo +++ b/examples/misc/json.echo @@ -1,10 +1,12 @@ ; JSON parse/stringify demo. ; Run: xo run examples/misc/json.echo +; Echo values are untagged integers: true parses to 1, false and null to 0, +; and all of them stringify back as numbers. / std/io / std/json -| json.parse('{"ok":true}') { +| json.parse('{"n":0,"ok":true}') { $ v { | json.stringify(v) { $ s { diff --git a/examples/misc/result_match.echo b/examples/misc/result_match.echo new file mode 100644 index 00000000..1820eede --- /dev/null +++ b/examples/misc/result_match.echo @@ -0,0 +1,26 @@ +/ std/io +/ std/str + +$ half = (n) { + ? n % 2 != 0 { + ! "odd" + } + ^ n / 2 +} + +| half(10) { + $ v { + io.print(str.from_int(v)) + } + ! e { + io.print(e) + } +} +| half(7) { + $ v { + io.print(str.from_int(v)) + } + ! e { + io.print(e) + } +} diff --git a/grammars/tree-sitter-echo/README.md b/grammars/tree-sitter-echo/README.md index ca9a619a..1bd7fafa 100644 --- a/grammars/tree-sitter-echo/README.md +++ b/grammars/tree-sitter-echo/README.md @@ -16,7 +16,7 @@ cargo build -p xo Do not treat hand edits to this tree as language authority — re-run the generator after leader or lexer surface changes. -## Leaders (17) +## Leaders (18) | Token | Glyph | Dual-use | |-------|-------|----------| @@ -35,10 +35,11 @@ generator after leader or lexer surface changes. | `leader_pipe` | `|` | yes | | `leader_plus` | `+` | yes | | `leader_minus` | `-` | yes | +| `leader_ampersand` | `&` | yes | | `leader_slash` | `/` | yes | | `leader_backslash` | `\` | no | -- **Dual-use glyphs** (leader at statement start; operator/token in expressions): `~` (bit-not), `%`, `:`, `!`, `^` (bit-xor), `*`, `<`, `>`, `|` (true atom / bit-or), `+`, `-`, `/` +- **Dual-use glyphs** (leader at statement start; operator/token in expressions): `~` (leader_tilde), `%` (leader_percent), `:` (leader_colon), `!` (leader_bang), `^` (leader_caret), `*` (leader_star), `<` (leader_lt), `>` (leader_gt), `|` (leader_pipe), `+` (leader_plus), `-` (leader_minus), `&` (leader_ampersand), `/` (leader_slash) - **Leader-only** (statement introducers; invalid as free expression glyphs in the real lexer): `$` (leader_dollar), `#` (leader_hash), `@` (leader_at), `?` (leader_question), `\` (leader_backslash) Dual-use is modeled by **grammar context**: `leader_*` tokens only appear as diff --git a/grammars/tree-sitter-echo/grammar.js b/grammars/tree-sitter-echo/grammar.js index 85260750..9ebf6abb 100644 --- a/grammars/tree-sitter-echo/grammar.js +++ b/grammars/tree-sitter-echo/grammar.js @@ -64,6 +64,7 @@ module.exports = grammar({ $.match_statement, $.task_spawn_statement, $.task_join_statement, + $.effect_block_statement, $.import_statement, $.export_statement, // Not full _expression: top-level unary !/-/+ would steal dual-use leaders. @@ -72,8 +73,6 @@ module.exports = grammar({ // ── Statement leaders (full set from echo_syntax::LEADERS) ── // Leader-only glyphs: dedicated tokens (invalid as free expr atoms in echo_lexer). - // leader_tilde: mutable bind - leader_tilde: _ => '~', // leader_dollar: immutable bind leader_dollar: _ => '$', // leader_hash: compile-time constant @@ -82,30 +81,31 @@ module.exports = grammar({ leader_at: _ => '@', // leader_question: if leader_question: _ => '?', - // leader_caret: return - leader_caret: _ => '^', // leader_backslash: export leader_backslash: _ => '\\', // Dual-use glyphs (* / ! < > | + - % :) are anonymous terminals shared by // statement introducers and expression operators — one token per char // (docs/lexer.md). Statement rules reference them as string literals; // token names still appear in comments + highlights for the full set. + // leader_tilde (mutable bind) dual-use — glyph ~ in statements and expressions // leader_percent (struct shape) dual-use — glyph % in statements and expressions // leader_colon (else-if / else / match default) dual-use — glyph : in statements and expressions // leader_bang (error return) dual-use — glyph ! in statements and expressions + // leader_caret (return) dual-use — glyph ^ in statements and expressions // leader_star (loop) dual-use — glyph * in statements and expressions // leader_lt (break) dual-use — glyph < in statements and expressions // leader_gt (continue) dual-use — glyph > in statements and expressions // leader_pipe (match) dual-use — glyph | in statements and expressions // leader_plus (task spawn) dual-use — glyph + in statements and expressions // leader_minus (task join) dual-use — glyph - in statements and expressions + // leader_ampersand (effect block) dual-use — glyph & in statements and expressions // leader_slash (import) dual-use — glyph / in statements and expressions // ── Statements (leaders only at statement start via grammar context) ── // Multi bind: `~ a = 1, b = 2`. Targets may be paths: `~ p.x =`, `~ xs[i] =`. bind_statement: $ => seq( - field('leader', choice($.leader_tilde, $.leader_dollar, $.leader_hash)), + field('leader', choice('~', $.leader_dollar, $.leader_hash)), commaSep1($.bind_clause), ), @@ -131,7 +131,7 @@ module.exports = grammar({ $.ident, repeat(choice( seq('.', field('field', $.ident)), - seq('[', field('index', $._expression), ']'), + seq('[', optional(field('index', $._expression)), ']'), )), ), )), @@ -179,10 +179,10 @@ module.exports = grammar({ // Prefer including an optional value (`^ expr`) over bare `^` before next item. return_statement: $ => choice( prec.right(2, seq( - field('leader', $.leader_caret), + field('leader', '^'), field('value', $._expression), )), - prec(1, field('leader', $.leader_caret)), + prec(1, field('leader', '^')), ), // prec.right inside; item-level prec(15) beats unary (8) / expression_statement (-1). @@ -330,6 +330,15 @@ module.exports = grammar({ ), )), + // `& { … }` / `& name = { … }` — effect block (auto-unwrap result/option). + effect_block_statement: $ => prec.right(seq( + field('leader', '&'), + optional(seq(field('name', $.ident), '=')), + '{', + repeat(choice($._item, '\n')), + '}', + )), + import_statement: $ => seq( field('leader', '/'), field('path', $.import_path), @@ -567,22 +576,23 @@ function commaSep1(rule) { } /* Dual-use leaders (glyph also expression token): + * leader_tilde (~) * leader_percent (%) * leader_colon (:) * leader_bang (!) + * leader_caret (^) * leader_star (*) * leader_lt (<) * leader_gt (>) * leader_pipe (|) * leader_plus (+) * leader_minus (-) + * leader_ampersand (&) * leader_slash (/) * Leader-only (error outside statement start in echo_lexer): - * leader_tilde (~) * leader_dollar ($) * leader_hash (#) * leader_at (@) * leader_question (?) - * leader_caret (^) * leader_backslash (\) */ diff --git a/grammars/tree-sitter-echo/queries/highlights.scm b/grammars/tree-sitter-echo/queries/highlights.scm index 97ba3fce..9ddfb2ba 100644 --- a/grammars/tree-sitter-echo/queries/highlights.scm +++ b/grammars/tree-sitter-echo/queries/highlights.scm @@ -4,26 +4,41 @@ ; Line comments (; → EOL) (comment) @comment +; Operators / punctuation (expression dual-use surface) +; Keep before the leader captures: later patterns win on the same range. +[ +"=" "==" "!=" "===" "!==" +"<" ">" "<=" ">=" "<<" ">>" +"+" "-" "*" "/" "%" +"&&" "||" "&" "^" "|" "~" "!" ".." +"." "," ":" +"(" ")" "[" "]" "{" "}" +] @operator + ; Leader-only tokens (named rules) -(leader_tilde) @keyword (leader_dollar) @keyword (leader_hash) @keyword (leader_at) @keyword (leader_question) @keyword -(leader_caret) @keyword (leader_backslash) @keyword ; Dual-use leaders as statement introducers (anonymous glyph in context) +; leader_tilde (~) ; leader_percent (%) ; leader_colon (:) ; leader_bang (!) +; leader_caret (^) ; leader_star (*) ; leader_lt (<) ; leader_gt (>) ; leader_pipe (|) ; leader_plus (+) ; leader_minus (-) +; leader_ampersand (&) ; leader_slash (/) +(bind_statement leader: "~" @keyword) +(return_statement leader: "^" @keyword) +(effect_block_statement leader: "&" @keyword) (struct_statement leader: "%" @keyword) (match_arm leader: "%" @keyword) (else_if_statement leader: ":" @keyword) @@ -70,15 +85,3 @@ (receiver) @variable.builtin (self_field field: (ident) @property) (width_cast type: (ident) @type) - -; Operators / punctuation (expression dual-use surface) -; Listed before more-specific leader captures win via query order in editors -; that last-match-wins; leaders above already mark statement glyphs. -[ -"=" "==" "!=" "===" "!==" -"<" ">" "<=" ">=" -"+" "-" "*" "/" "%" -"&&" "||" "!" ".." -"." "," ":" -"(" ")" "[" "]" "{" "}" -] @operator diff --git a/grammars/tree-sitter-echo/src/grammar.json b/grammars/tree-sitter-echo/src/grammar.json index 4dd5cf59..9b1280bd 100644 --- a/grammars/tree-sitter-echo/src/grammar.json +++ b/grammars/tree-sitter-echo/src/grammar.json @@ -94,6 +94,10 @@ "type": "SYMBOL", "name": "task_join_statement" }, + { + "type": "SYMBOL", + "name": "effect_block_statement" + }, { "type": "SYMBOL", "name": "import_statement" @@ -108,10 +112,6 @@ } ] }, - "leader_tilde": { - "type": "STRING", - "value": "~" - }, "leader_dollar": { "type": "STRING", "value": "$" @@ -128,10 +128,6 @@ "type": "STRING", "value": "?" }, - "leader_caret": { - "type": "STRING", - "value": "^" - }, "leader_backslash": { "type": "STRING", "value": "\\" @@ -146,8 +142,8 @@ "type": "CHOICE", "members": [ { - "type": "SYMBOL", - "name": "leader_tilde" + "type": "STRING", + "value": "~" }, { "type": "SYMBOL", @@ -305,12 +301,20 @@ "value": "[" }, { - "type": "FIELD", - "name": "index", - "content": { - "type": "SYMBOL", - "name": "_expression" - } + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "index", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + }, + { + "type": "BLANK" + } + ] }, { "type": "STRING", @@ -564,8 +568,8 @@ "type": "FIELD", "name": "leader", "content": { - "type": "SYMBOL", - "name": "leader_caret" + "type": "STRING", + "value": "^" } }, { @@ -586,8 +590,8 @@ "type": "FIELD", "name": "leader", "content": { - "type": "SYMBOL", - "name": "leader_caret" + "type": "STRING", + "value": "^" } } } @@ -1533,6 +1537,72 @@ ] } }, + "effect_block_statement": { + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "leader", + "content": { + "type": "STRING", + "value": "&" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "ident" + } + }, + { + "type": "STRING", + "value": "=" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_item" + }, + { + "type": "STRING", + "value": "\n" + } + ] + } + }, + { + "type": "STRING", + "value": "}" + } + ] + } + }, "import_statement": { "type": "SEQ", "members": [ @@ -1773,7 +1843,7 @@ }, "unary_expression": { "type": "PREC", - "value": 8, + "value": 11, "content": { "type": "SEQ", "members": [ @@ -1794,6 +1864,10 @@ { "type": "STRING", "value": "+" + }, + { + "type": "STRING", + "value": "~" } ] } @@ -1881,6 +1955,105 @@ { "type": "PREC_LEFT", "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "|" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 4, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "^" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 5, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "STRING", + "value": "&" + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 6, "content": { "type": "SEQ", "members": [ @@ -1946,7 +2119,49 @@ }, { "type": "PREC_LEFT", - "value": 4, + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "left", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + }, + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "<<" + }, + { + "type": "STRING", + "value": ">>" + } + ] + } + }, + { + "type": "FIELD", + "name": "right", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 9, "content": { "type": "SEQ", "members": [ @@ -1988,7 +2203,7 @@ }, { "type": "PREC_LEFT", - "value": 5, + "value": 10, "content": { "type": "SEQ", "members": [ @@ -2036,7 +2251,7 @@ }, "range_expression": { "type": "PREC_LEFT", - "value": 6, + "value": 7, "content": { "type": "SEQ", "members": [ @@ -2065,7 +2280,7 @@ }, "width_cast": { "type": "PREC", - "value": 8, + "value": 11, "content": { "type": "SEQ", "members": [ @@ -2985,6 +3200,10 @@ [ "match_arm", "_struct_field_list" + ], + [ + "bind_lhs", + "self_field" ] ], "precedences": [], diff --git a/grammars/tree-sitter-echo/src/node-types.json b/grammars/tree-sitter-echo/src/node-types.json index 873b2391..0558accb 100644 --- a/grammars/tree-sitter-echo/src/node-types.json +++ b/grammars/tree-sitter-echo/src/node-types.json @@ -121,6 +121,10 @@ "type": "%", "named": false }, + { + "type": "&", + "named": false + }, { "type": "&&", "named": false @@ -145,6 +149,10 @@ "type": "<", "named": false }, + { + "type": "<<", + "named": false + }, { "type": "<=", "named": false @@ -165,6 +173,18 @@ "type": ">=", "named": false }, + { + "type": ">>", + "named": false + }, + { + "type": "^", + "named": false + }, + { + "type": "|", + "named": false + }, { "type": "||", "named": false @@ -538,8 +558,8 @@ "named": true }, { - "type": "leader_tilde", - "named": true + "type": "~", + "named": false } ] } @@ -793,6 +813,110 @@ } } }, + { + "type": "effect_block_statement", + "named": true, + "fields": { + "leader": { + "multiple": false, + "required": true, + "types": [ + { + "type": "&", + "named": false + } + ] + }, + "name": { + "multiple": false, + "required": false, + "types": [ + { + "type": "ident", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "bind_statement", + "named": true + }, + { + "type": "break_statement", + "named": true + }, + { + "type": "continue_statement", + "named": true + }, + { + "type": "effect_block_statement", + "named": true + }, + { + "type": "else_if_statement", + "named": true + }, + { + "type": "else_statement", + "named": true + }, + { + "type": "error_return_statement", + "named": true + }, + { + "type": "export_statement", + "named": true + }, + { + "type": "expression_statement", + "named": true + }, + { + "type": "if_statement", + "named": true + }, + { + "type": "import_statement", + "named": true + }, + { + "type": "loop_statement", + "named": true + }, + { + "type": "match_statement", + "named": true + }, + { + "type": "return_statement", + "named": true + }, + { + "type": "struct_extend_statement", + "named": true + }, + { + "type": "struct_statement", + "named": true + }, + { + "type": "task_join_statement", + "named": true + }, + { + "type": "task_spawn_statement", + "named": true + } + ] + } + }, { "type": "else_if_statement", "named": true, @@ -926,6 +1050,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -1016,6 +1144,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -1578,6 +1710,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -1774,6 +1910,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -2465,6 +2605,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -2667,6 +2811,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -3209,8 +3357,8 @@ "required": true, "types": [ { - "type": "leader_caret", - "named": true + "type": "^", + "named": false } ] }, @@ -3355,6 +3503,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -3455,6 +3607,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -3585,6 +3741,10 @@ "type": "continue_statement", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -3705,6 +3865,10 @@ "type": "duration", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -3901,6 +4065,10 @@ "type": "duration", "named": true }, + { + "type": "effect_block_statement", + "named": true + }, { "type": "else_if_statement", "named": true @@ -4036,6 +4204,11 @@ ] } }, + { + "type": "true_atom", + "named": true, + "fields": {} + }, { "type": "unary_expression", "named": true, @@ -4157,6 +4330,10 @@ { "type": "-", "named": false + }, + { + "type": "~", + "named": false } ] } @@ -4300,6 +4477,10 @@ "type": "%", "named": false }, + { + "type": "&", + "named": false + }, { "type": "&&", "named": false @@ -4348,6 +4529,10 @@ "type": "<", "named": false }, + { + "type": "<<", + "named": false + }, { "type": "<=", "named": false @@ -4372,6 +4557,10 @@ "type": ">=", "named": false }, + { + "type": ">>", + "named": false + }, { "type": "[", "named": false @@ -4380,6 +4569,10 @@ "type": "]", "named": false }, + { + "type": "^", + "named": false + }, { "type": "bytes_pure", "named": true @@ -4417,10 +4610,6 @@ "type": "leader_backslash", "named": true }, - { - "type": "leader_caret", - "named": true - }, { "type": "leader_dollar", "named": true @@ -4433,10 +4622,6 @@ "type": "leader_question", "named": true }, - { - "type": "leader_tilde", - "named": true - }, { "type": "locator_pure", "named": true @@ -4462,11 +4647,11 @@ "named": true }, { - "type": "true_atom", - "named": true + "type": "{", + "named": false }, { - "type": "{", + "type": "|", "named": false }, { @@ -4476,5 +4661,9 @@ { "type": "}", "named": false + }, + { + "type": "~", + "named": false } ] \ No newline at end of file diff --git a/grammars/tree-sitter-echo/src/parser.c b/grammars/tree-sitter-echo/src/parser.c index be7873a2..dd942203 100644 --- a/grammars/tree-sitter-echo/src/parser.c +++ b/grammars/tree-sitter-echo/src/parser.c @@ -7,11 +7,11 @@ #endif #define LANGUAGE_VERSION 15 -#define STATE_COUNT 345 -#define LARGE_STATE_COUNT 52 -#define SYMBOL_COUNT 103 +#define STATE_COUNT 470 +#define LARGE_STATE_COUNT 70 +#define SYMBOL_COUNT 108 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 50 +#define TOKEN_COUNT 53 #define EXTERNAL_TOKEN_COUNT 0 #define FIELD_COUNT 23 #define MAX_ALIAS_SEQUENCE_LENGTH 11 @@ -23,22 +23,22 @@ enum ts_symbol_identifiers { sym_ident = 1, anon_sym_LF = 2, sym_comment = 3, - sym_leader_tilde = 4, - sym_leader_dollar = 5, - sym_leader_hash = 6, - sym_leader_at = 7, - sym_leader_question = 8, - sym_leader_caret = 9, - sym_leader_backslash = 10, - anon_sym_COMMA = 11, - anon_sym_EQ = 12, - anon_sym_DOT = 13, - anon_sym_LBRACK = 14, - anon_sym_RBRACK = 15, - anon_sym_PERCENT = 16, - anon_sym_LBRACE = 17, - anon_sym_RBRACE = 18, - anon_sym_COLON = 19, + sym_leader_dollar = 4, + sym_leader_hash = 5, + sym_leader_at = 6, + sym_leader_question = 7, + sym_leader_backslash = 8, + anon_sym_TILDE = 9, + anon_sym_COMMA = 10, + anon_sym_EQ = 11, + anon_sym_DOT = 12, + anon_sym_LBRACK = 13, + anon_sym_RBRACK = 14, + anon_sym_PERCENT = 15, + anon_sym_LBRACE = 16, + anon_sym_RBRACE = 17, + anon_sym_COLON = 18, + anon_sym_CARET = 19, anon_sym_BANG = 20, anon_sym_STAR = 21, anon_sym_LPAREN = 22, @@ -49,79 +49,84 @@ enum ts_symbol_identifiers { anon_sym_DOT_DOT = 27, anon_sym_PLUS = 28, anon_sym_DASH = 29, - anon_sym_SLASH = 30, - sym_import_path = 31, - sym_true_atom = 32, - sym_false_atom = 33, - anon_sym_PIPE_PIPE = 34, - anon_sym_AMP_AMP = 35, - anon_sym_EQ_EQ = 36, - anon_sym_BANG_EQ = 37, - anon_sym_EQ_EQ_EQ = 38, - anon_sym_BANG_EQ_EQ = 39, - anon_sym_LT_EQ = 40, - anon_sym_GT_EQ = 41, - sym_number = 42, - sym_duration = 43, - sym_string_pure = 44, - sym_string_rich = 45, - sym_bytes_pure = 46, - sym_bytes_rich = 47, - sym_locator_pure = 48, - sym_locator_rich = 49, - sym_source_file = 50, - sym__item = 51, - sym_bind_statement = 52, - sym_bind_clause = 53, - sym_bind_lhs = 54, - sym_struct_statement = 55, - sym_struct_extend_statement = 56, - sym_if_statement = 57, - sym_else_if_statement = 58, - sym_else_statement = 59, - sym_return_statement = 60, - sym_error_return_statement = 61, - sym_loop_statement = 62, - sym__loop_header_expr = 63, - sym_break_statement = 64, - sym_continue_statement = 65, - sym_match_statement = 66, - sym__match_scrutinee = 67, - sym_match_arm = 68, - sym__match_pattern = 69, - sym_task_spawn_statement = 70, - sym_task_join_statement = 71, - sym_import_statement = 72, - sym_export_statement = 73, - sym_expression_statement = 74, - sym__expression = 75, - sym__expr_non_unary = 76, - sym_receiver = 77, - sym_self_field = 78, - sym_unary_expression = 79, - sym_binary_expression = 80, - sym_range_expression = 81, - sym_width_cast = 82, - sym_call_expression = 83, - sym_field_expression = 84, - sym_index_expression = 85, - sym_list_expression = 86, - sym_struct_literal = 87, - sym__struct_field_list = 88, - sym_field_initializer = 89, - sym_fn_expression = 90, - sym_parenthesized_expression = 91, - aux_sym_source_file_repeat1 = 92, - aux_sym_bind_statement_repeat1 = 93, - aux_sym_bind_lhs_repeat1 = 94, - aux_sym_bind_lhs_repeat2 = 95, - aux_sym__loop_header_expr_repeat1 = 96, - aux_sym__loop_header_expr_repeat2 = 97, - aux_sym_match_statement_repeat1 = 98, - aux_sym_match_arm_repeat1 = 99, - aux_sym_export_statement_repeat1 = 100, - aux_sym_list_expression_repeat1 = 101, - aux_sym__struct_field_list_repeat1 = 102, + anon_sym_AMP = 30, + anon_sym_SLASH = 31, + sym_import_path = 32, + anon_sym_PIPE = 33, + sym_false_atom = 34, + anon_sym_PIPE_PIPE = 35, + anon_sym_AMP_AMP = 36, + anon_sym_EQ_EQ = 37, + anon_sym_BANG_EQ = 38, + anon_sym_EQ_EQ_EQ = 39, + anon_sym_BANG_EQ_EQ = 40, + anon_sym_LT_EQ = 41, + anon_sym_GT_EQ = 42, + anon_sym_LT_LT = 43, + anon_sym_GT_GT = 44, + sym_number = 45, + sym_duration = 46, + sym_string_pure = 47, + sym_string_rich = 48, + sym_bytes_pure = 49, + sym_bytes_rich = 50, + sym_locator_pure = 51, + sym_locator_rich = 52, + sym_source_file = 53, + sym__item = 54, + sym_bind_statement = 55, + sym_bind_clause = 56, + sym_bind_lhs = 57, + sym_struct_statement = 58, + sym_struct_extend_statement = 59, + sym_if_statement = 60, + sym_else_if_statement = 61, + sym_else_statement = 62, + sym_return_statement = 63, + sym_error_return_statement = 64, + sym_loop_statement = 65, + sym__loop_header_expr = 66, + sym_break_statement = 67, + sym_continue_statement = 68, + sym_match_statement = 69, + sym__match_scrutinee = 70, + sym_match_arm = 71, + sym__match_pattern = 72, + sym_task_spawn_statement = 73, + sym_task_join_statement = 74, + sym_effect_block_statement = 75, + sym_import_statement = 76, + sym_export_statement = 77, + sym_expression_statement = 78, + sym__expression = 79, + sym__expr_non_unary = 80, + sym_receiver = 81, + sym_self_field = 82, + sym_true_atom = 83, + sym_unary_expression = 84, + sym_binary_expression = 85, + sym_range_expression = 86, + sym_width_cast = 87, + sym_call_expression = 88, + sym_field_expression = 89, + sym_index_expression = 90, + sym_list_expression = 91, + sym_struct_literal = 92, + sym__struct_field_list = 93, + sym_field_initializer = 94, + sym_fn_expression = 95, + sym_parenthesized_expression = 96, + aux_sym_source_file_repeat1 = 97, + aux_sym_bind_statement_repeat1 = 98, + aux_sym_bind_lhs_repeat1 = 99, + aux_sym_bind_lhs_repeat2 = 100, + aux_sym__loop_header_expr_repeat1 = 101, + aux_sym__loop_header_expr_repeat2 = 102, + aux_sym_match_statement_repeat1 = 103, + aux_sym_match_arm_repeat1 = 104, + aux_sym_export_statement_repeat1 = 105, + aux_sym_list_expression_repeat1 = 106, + aux_sym__struct_field_list_repeat1 = 107, }; static const char * const ts_symbol_names[] = { @@ -129,13 +134,12 @@ static const char * const ts_symbol_names[] = { [sym_ident] = "ident", [anon_sym_LF] = "\n", [sym_comment] = "comment", - [sym_leader_tilde] = "leader_tilde", [sym_leader_dollar] = "leader_dollar", [sym_leader_hash] = "leader_hash", [sym_leader_at] = "leader_at", [sym_leader_question] = "leader_question", - [sym_leader_caret] = "leader_caret", [sym_leader_backslash] = "leader_backslash", + [anon_sym_TILDE] = "~", [anon_sym_COMMA] = ",", [anon_sym_EQ] = "=", [anon_sym_DOT] = ".", @@ -145,6 +149,7 @@ static const char * const ts_symbol_names[] = { [anon_sym_LBRACE] = "{", [anon_sym_RBRACE] = "}", [anon_sym_COLON] = ":", + [anon_sym_CARET] = "^", [anon_sym_BANG] = "!", [anon_sym_STAR] = "*", [anon_sym_LPAREN] = "(", @@ -155,9 +160,10 @@ static const char * const ts_symbol_names[] = { [anon_sym_DOT_DOT] = "..", [anon_sym_PLUS] = "+", [anon_sym_DASH] = "-", + [anon_sym_AMP] = "&", [anon_sym_SLASH] = "/", [sym_import_path] = "import_path", - [sym_true_atom] = "true_atom", + [anon_sym_PIPE] = "|", [sym_false_atom] = "false_atom", [anon_sym_PIPE_PIPE] = "||", [anon_sym_AMP_AMP] = "&&", @@ -167,6 +173,8 @@ static const char * const ts_symbol_names[] = { [anon_sym_BANG_EQ_EQ] = "!==", [anon_sym_LT_EQ] = "<=", [anon_sym_GT_EQ] = ">=", + [anon_sym_LT_LT] = "<<", + [anon_sym_GT_GT] = ">>", [sym_number] = "number", [sym_duration] = "duration", [sym_string_pure] = "string_pure", @@ -197,6 +205,7 @@ static const char * const ts_symbol_names[] = { [sym__match_pattern] = "_match_pattern", [sym_task_spawn_statement] = "task_spawn_statement", [sym_task_join_statement] = "task_join_statement", + [sym_effect_block_statement] = "effect_block_statement", [sym_import_statement] = "import_statement", [sym_export_statement] = "export_statement", [sym_expression_statement] = "expression_statement", @@ -204,6 +213,7 @@ static const char * const ts_symbol_names[] = { [sym__expr_non_unary] = "_expr_non_unary", [sym_receiver] = "receiver", [sym_self_field] = "self_field", + [sym_true_atom] = "true_atom", [sym_unary_expression] = "unary_expression", [sym_binary_expression] = "binary_expression", [sym_range_expression] = "range_expression", @@ -235,13 +245,12 @@ static const TSSymbol ts_symbol_map[] = { [sym_ident] = sym_ident, [anon_sym_LF] = anon_sym_LF, [sym_comment] = sym_comment, - [sym_leader_tilde] = sym_leader_tilde, [sym_leader_dollar] = sym_leader_dollar, [sym_leader_hash] = sym_leader_hash, [sym_leader_at] = sym_leader_at, [sym_leader_question] = sym_leader_question, - [sym_leader_caret] = sym_leader_caret, [sym_leader_backslash] = sym_leader_backslash, + [anon_sym_TILDE] = anon_sym_TILDE, [anon_sym_COMMA] = anon_sym_COMMA, [anon_sym_EQ] = anon_sym_EQ, [anon_sym_DOT] = anon_sym_DOT, @@ -251,6 +260,7 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_LBRACE] = anon_sym_LBRACE, [anon_sym_RBRACE] = anon_sym_RBRACE, [anon_sym_COLON] = anon_sym_COLON, + [anon_sym_CARET] = anon_sym_CARET, [anon_sym_BANG] = anon_sym_BANG, [anon_sym_STAR] = anon_sym_STAR, [anon_sym_LPAREN] = anon_sym_LPAREN, @@ -261,9 +271,10 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_DOT_DOT] = anon_sym_DOT_DOT, [anon_sym_PLUS] = anon_sym_PLUS, [anon_sym_DASH] = anon_sym_DASH, + [anon_sym_AMP] = anon_sym_AMP, [anon_sym_SLASH] = anon_sym_SLASH, [sym_import_path] = sym_import_path, - [sym_true_atom] = sym_true_atom, + [anon_sym_PIPE] = anon_sym_PIPE, [sym_false_atom] = sym_false_atom, [anon_sym_PIPE_PIPE] = anon_sym_PIPE_PIPE, [anon_sym_AMP_AMP] = anon_sym_AMP_AMP, @@ -273,6 +284,8 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_BANG_EQ_EQ] = anon_sym_BANG_EQ_EQ, [anon_sym_LT_EQ] = anon_sym_LT_EQ, [anon_sym_GT_EQ] = anon_sym_GT_EQ, + [anon_sym_LT_LT] = anon_sym_LT_LT, + [anon_sym_GT_GT] = anon_sym_GT_GT, [sym_number] = sym_number, [sym_duration] = sym_duration, [sym_string_pure] = sym_string_pure, @@ -303,6 +316,7 @@ static const TSSymbol ts_symbol_map[] = { [sym__match_pattern] = sym__match_pattern, [sym_task_spawn_statement] = sym_task_spawn_statement, [sym_task_join_statement] = sym_task_join_statement, + [sym_effect_block_statement] = sym_effect_block_statement, [sym_import_statement] = sym_import_statement, [sym_export_statement] = sym_export_statement, [sym_expression_statement] = sym_expression_statement, @@ -310,6 +324,7 @@ static const TSSymbol ts_symbol_map[] = { [sym__expr_non_unary] = sym__expr_non_unary, [sym_receiver] = sym_receiver, [sym_self_field] = sym_self_field, + [sym_true_atom] = sym_true_atom, [sym_unary_expression] = sym_unary_expression, [sym_binary_expression] = sym_binary_expression, [sym_range_expression] = sym_range_expression, @@ -353,10 +368,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_leader_tilde] = { - .visible = true, - .named = true, - }, [sym_leader_dollar] = { .visible = true, .named = true, @@ -373,13 +384,13 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_leader_caret] = { + [sym_leader_backslash] = { .visible = true, .named = true, }, - [sym_leader_backslash] = { + [anon_sym_TILDE] = { .visible = true, - .named = true, + .named = false, }, [anon_sym_COMMA] = { .visible = true, @@ -417,6 +428,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_CARET] = { + .visible = true, + .named = false, + }, [anon_sym_BANG] = { .visible = true, .named = false, @@ -457,6 +472,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_AMP] = { + .visible = true, + .named = false, + }, [anon_sym_SLASH] = { .visible = true, .named = false, @@ -465,9 +484,9 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_true_atom] = { + [anon_sym_PIPE] = { .visible = true, - .named = true, + .named = false, }, [sym_false_atom] = { .visible = true, @@ -505,6 +524,14 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_LT_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT] = { + .visible = true, + .named = false, + }, [sym_number] = { .visible = true, .named = true, @@ -625,6 +652,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_effect_block_statement] = { + .visible = true, + .named = true, + }, [sym_import_statement] = { .visible = true, .named = true, @@ -653,6 +684,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_true_atom] = { + .visible = true, + .named = true, + }, [sym_unary_expression] = { .visible = true, .named = true, @@ -845,16 +880,16 @@ static const TSFieldMapEntry ts_field_map_entries[] = { [1] = {field_target, 0}, [2] = - {field_leader, 0}, - {field_value, 1}, - [4] = {field_leader, 0}, {field_names, 1}, + [4] = + {field_argument, 1}, + {field_operator, 0}, [6] = {field_field, 1}, [7] = - {field_argument, 1}, - {field_operator, 0}, + {field_leader, 0}, + {field_value, 1}, [9] = {field_leader, 0}, {field_path, 1}, @@ -991,7 +1026,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [43] = 43, [44] = 44, [45] = 45, - [46] = 46, + [46] = 9, [47] = 47, [48] = 48, [49] = 49, @@ -1000,20 +1035,20 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [52] = 52, [53] = 53, [54] = 54, - [55] = 55, - [56] = 56, - [57] = 57, - [58] = 58, - [59] = 59, - [60] = 60, - [61] = 61, - [62] = 62, + [55] = 16, + [56] = 25, + [57] = 26, + [58] = 31, + [59] = 32, + [60] = 38, + [61] = 39, + [62] = 45, [63] = 63, - [64] = 64, - [65] = 65, - [66] = 66, - [67] = 67, - [68] = 68, + [64] = 50, + [65] = 51, + [66] = 52, + [67] = 53, + [68] = 54, [69] = 69, [70] = 70, [71] = 71, @@ -1096,12 +1131,12 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [148] = 148, [149] = 149, [150] = 150, - [151] = 151, - [152] = 152, - [153] = 153, + [151] = 150, + [152] = 147, + [153] = 148, [154] = 154, [155] = 155, - [156] = 156, + [156] = 149, [157] = 157, [158] = 158, [159] = 159, @@ -1112,19 +1147,19 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [164] = 164, [165] = 165, [166] = 166, - [167] = 167, + [167] = 159, [168] = 168, [169] = 169, [170] = 170, - [171] = 165, - [172] = 172, - [173] = 173, + [171] = 171, + [172] = 158, + [173] = 163, [174] = 174, - [175] = 175, - [176] = 176, - [177] = 177, - [178] = 178, - [179] = 179, + [175] = 171, + [176] = 174, + [177] = 161, + [178] = 162, + [179] = 166, [180] = 180, [181] = 181, [182] = 182, @@ -1132,25 +1167,25 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [184] = 184, [185] = 185, [186] = 186, - [187] = 181, + [187] = 187, [188] = 188, [189] = 189, [190] = 190, - [191] = 170, + [191] = 191, [192] = 192, - [193] = 173, - [194] = 174, - [195] = 177, + [193] = 193, + [194] = 194, + [195] = 195, [196] = 196, - [197] = 185, - [198] = 181, - [199] = 196, - [200] = 89, - [201] = 91, - [202] = 84, - [203] = 87, - [204] = 88, - [205] = 90, + [197] = 197, + [198] = 198, + [199] = 181, + [200] = 200, + [201] = 201, + [202] = 202, + [203] = 203, + [204] = 204, + [205] = 205, [206] = 206, [207] = 207, [208] = 208, @@ -1161,23 +1196,23 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [213] = 213, [214] = 214, [215] = 215, - [216] = 216, + [216] = 184, [217] = 217, - [218] = 59, + [218] = 218, [219] = 219, [220] = 220, - [221] = 221, - [222] = 222, + [221] = 206, + [222] = 214, [223] = 223, - [224] = 224, - [225] = 225, - [226] = 226, - [227] = 227, - [228] = 228, + [224] = 186, + [225] = 187, + [226] = 193, + [227] = 198, + [228] = 219, [229] = 229, - [230] = 230, - [231] = 230, - [232] = 232, + [230] = 229, + [231] = 231, + [232] = 223, [233] = 233, [234] = 234, [235] = 235, @@ -1192,61 +1227,61 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [244] = 244, [245] = 245, [246] = 246, - [247] = 247, - [248] = 248, + [247] = 220, + [248] = 229, [249] = 249, - [250] = 250, - [251] = 251, + [250] = 200, + [251] = 208, [252] = 252, - [253] = 253, - [254] = 254, - [255] = 255, - [256] = 256, - [257] = 257, - [258] = 258, - [259] = 259, - [260] = 260, - [261] = 261, - [262] = 262, - [263] = 263, - [264] = 264, - [265] = 265, - [266] = 266, - [267] = 267, - [268] = 268, - [269] = 269, - [270] = 270, - [271] = 271, - [272] = 272, - [273] = 273, - [274] = 274, - [275] = 275, - [276] = 276, - [277] = 277, - [278] = 278, - [279] = 279, - [280] = 280, - [281] = 281, - [282] = 282, - [283] = 283, - [284] = 284, - [285] = 285, - [286] = 286, - [287] = 287, - [288] = 288, - [289] = 289, - [290] = 290, - [291] = 291, - [292] = 292, - [293] = 293, + [253] = 114, + [254] = 83, + [255] = 116, + [256] = 95, + [257] = 73, + [258] = 96, + [259] = 97, + [260] = 98, + [261] = 99, + [262] = 100, + [263] = 101, + [264] = 103, + [265] = 106, + [266] = 107, + [267] = 108, + [268] = 109, + [269] = 110, + [270] = 90, + [271] = 112, + [272] = 94, + [273] = 102, + [274] = 104, + [275] = 105, + [276] = 92, + [277] = 93, + [278] = 75, + [279] = 76, + [280] = 77, + [281] = 113, + [282] = 78, + [283] = 79, + [284] = 80, + [285] = 81, + [286] = 82, + [287] = 89, + [288] = 84, + [289] = 85, + [290] = 86, + [291] = 87, + [292] = 88, + [293] = 111, [294] = 294, - [295] = 295, + [295] = 294, [296] = 296, [297] = 297, [298] = 298, [299] = 299, - [300] = 300, - [301] = 301, + [300] = 298, + [301] = 297, [302] = 302, [303] = 303, [304] = 304, @@ -1254,21 +1289,21 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [306] = 306, [307] = 307, [308] = 308, - [309] = 309, + [309] = 307, [310] = 310, [311] = 311, - [312] = 312, + [312] = 95, [313] = 313, [314] = 314, [315] = 315, [316] = 316, [317] = 317, - [318] = 318, - [319] = 319, + [318] = 313, + [319] = 317, [320] = 320, [321] = 321, [322] = 322, - [323] = 323, + [323] = 322, [324] = 324, [325] = 325, [326] = 326, @@ -1284,12 +1319,137 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [336] = 336, [337] = 337, [338] = 338, - [339] = 321, - [340] = 340, - [341] = 321, - [342] = 306, - [343] = 306, + [339] = 339, + [340] = 339, + [341] = 341, + [342] = 341, + [343] = 343, [344] = 344, + [345] = 345, + [346] = 346, + [347] = 347, + [348] = 348, + [349] = 347, + [350] = 350, + [351] = 351, + [352] = 352, + [353] = 353, + [354] = 354, + [355] = 355, + [356] = 356, + [357] = 357, + [358] = 355, + [359] = 359, + [360] = 360, + [361] = 361, + [362] = 362, + [363] = 363, + [364] = 364, + [365] = 365, + [366] = 366, + [367] = 367, + [368] = 368, + [369] = 369, + [370] = 370, + [371] = 371, + [372] = 372, + [373] = 373, + [374] = 374, + [375] = 375, + [376] = 376, + [377] = 377, + [378] = 378, + [379] = 379, + [380] = 380, + [381] = 381, + [382] = 360, + [383] = 383, + [384] = 384, + [385] = 385, + [386] = 386, + [387] = 387, + [388] = 388, + [389] = 385, + [390] = 377, + [391] = 372, + [392] = 373, + [393] = 362, + [394] = 363, + [395] = 361, + [396] = 396, + [397] = 397, + [398] = 398, + [399] = 399, + [400] = 400, + [401] = 401, + [402] = 402, + [403] = 403, + [404] = 403, + [405] = 400, + [406] = 399, + [407] = 407, + [408] = 408, + [409] = 409, + [410] = 398, + [411] = 411, + [412] = 407, + [413] = 409, + [414] = 114, + [415] = 415, + [416] = 416, + [417] = 417, + [418] = 418, + [419] = 419, + [420] = 420, + [421] = 421, + [422] = 422, + [423] = 423, + [424] = 424, + [425] = 425, + [426] = 418, + [427] = 427, + [428] = 428, + [429] = 429, + [430] = 430, + [431] = 431, + [432] = 432, + [433] = 433, + [434] = 434, + [435] = 435, + [436] = 436, + [437] = 437, + [438] = 438, + [439] = 439, + [440] = 440, + [441] = 441, + [442] = 442, + [443] = 443, + [444] = 431, + [445] = 445, + [446] = 422, + [447] = 447, + [448] = 448, + [449] = 449, + [450] = 450, + [451] = 443, + [452] = 452, + [453] = 424, + [454] = 454, + [455] = 429, + [456] = 452, + [457] = 422, + [458] = 458, + [459] = 459, + [460] = 460, + [461] = 431, + [462] = 462, + [463] = 439, + [464] = 464, + [465] = 465, + [466] = 466, + [467] = 454, + [468] = 468, + [469] = 459, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -1297,581 +1457,598 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (eof) ADVANCE(26); + if (eof) ADVANCE(24); ADVANCE_MAP( - '\n', 27, - '!', 48, + '\n', 25, + '!', 46, '"', 4, - '#', 31, - '$', 30, - '%', 43, - '&', 7, - '\'', 8, - '(', 50, - ')', 51, - '*', 49, - '+', 58, - ',', 36, - '-', 59, - '.', 40, + '#', 28, + '$', 27, + '%', 40, + '&', 59, + '\'', 7, + '(', 48, + ')', 49, + '*', 47, + '+', 56, + ',', 33, + '-', 57, + '.', 37, '/', 60, - '0', 76, - ':', 46, - ';', 28, - '<', 53, - '=', 38, - '>', 55, - '?', 33, - '@', 32, - '[', 41, - '\\', 35, - ']', 42, - '^', 34, - 'b', 73, - 'p', 74, - '{', 44, - '|', 63, - '}', 45, - '~', 29, + '0', 79, + ':', 43, + ';', 26, + '<', 51, + '=', 35, + '>', 53, + '?', 30, + '@', 29, + '[', 38, + '\\', 31, + ']', 39, + '^', 44, + 'b', 76, + 'p', 77, + '{', 41, + '|', 64, + '}', 42, + '~', 32, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(0); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(78); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(81); if (('A' <= lookahead && lookahead <= '_') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(75); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(78); END_STATE(); case 1: ADVANCE_MAP( - '\n', 27, - '!', 47, + '\n', 25, + '!', 45, '"', 4, - '$', 30, - '%', 43, - '\'', 8, - '(', 50, - '.', 39, - '0', 77, - ':', 46, - ';', 28, - '<', 52, + '$', 27, + '%', 40, + '\'', 7, + '(', 48, + '.', 36, + '0', 80, + ':', 43, + ';', 26, + '<', 50, '|', 62, - '}', 45, + '}', 42, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(1); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(79); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(82); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(75); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(78); END_STATE(); case 2: ADVANCE_MAP( - '\n', 27, - '!', 47, + '\n', 25, + '!', 45, '"', 4, - '\'', 8, - '(', 50, - ')', 51, - '+', 58, - '-', 59, - '.', 39, - '0', 76, - ';', 28, - '<', 52, - '[', 41, - ']', 42, - 'b', 73, - 'p', 74, - '{', 44, + '\'', 7, + '(', 48, + ')', 49, + '+', 56, + '-', 57, + '.', 36, + '0', 79, + ';', 26, + '<', 50, + '[', 38, + ']', 39, + 'b', 76, + 'p', 77, + '{', 41, '|', 62, + '~', 32, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(2); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(78); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(81); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(75); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(78); END_STATE(); case 3: ADVANCE_MAP( - '\n', 27, - '!', 13, - '%', 43, - '&', 7, - '(', 50, - ')', 51, - '*', 49, - '+', 58, - ',', 36, - '-', 59, - '.', 40, + '\n', 25, + '!', 12, + '%', 40, + '&', 59, + '(', 48, + ')', 49, + '*', 47, + '+', 56, + ',', 33, + '-', 57, + '.', 37, '/', 60, - '0', 77, - ';', 28, - '<', 53, - '=', 14, - '>', 55, - '[', 41, - ']', 42, - '{', 44, - '|', 15, - '}', 45, + '0', 80, + ':', 43, + ';', 26, + '<', 51, + '=', 13, + '>', 53, + '[', 38, + ']', 39, + '^', 44, + '{', 41, + '|', 63, + '}', 42, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(3); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(79); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(82); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(75); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(78); END_STATE(); case 4: - if (lookahead == '"') ADVANCE(90); - if (lookahead == '\\') ADVANCE(22); + if (lookahead == '"') ADVANCE(93); + if (lookahead == '\\') ADVANCE(20); if (lookahead != 0) ADVANCE(4); END_STATE(); case 5: - if (lookahead == '"') ADVANCE(92); - if (lookahead == '\\') ADVANCE(23); + if (lookahead == '"') ADVANCE(95); + if (lookahead == '\\') ADVANCE(21); if (lookahead != 0) ADVANCE(5); END_STATE(); case 6: - if (lookahead == '"') ADVANCE(94); - if (lookahead == '\\') ADVANCE(24); + if (lookahead == '"') ADVANCE(97); + if (lookahead == '\\') ADVANCE(22); if (lookahead != 0) ADVANCE(6); END_STATE(); case 7: - if (lookahead == '&') ADVANCE(66); + if (lookahead == '\'') ADVANCE(92); + if (lookahead != 0) ADVANCE(7); END_STATE(); case 8: - if (lookahead == '\'') ADVANCE(89); + if (lookahead == '\'') ADVANCE(94); if (lookahead != 0) ADVANCE(8); END_STATE(); case 9: - if (lookahead == '\'') ADVANCE(91); + if (lookahead == '\'') ADVANCE(96); if (lookahead != 0) ADVANCE(9); END_STATE(); case 10: - if (lookahead == '\'') ADVANCE(93); - if (lookahead != 0) ADVANCE(10); - END_STATE(); - case 11: - if (lookahead == '.') ADVANCE(12); - if (lookahead == ';') ADVANCE(28); + if (lookahead == '.') ADVANCE(11); + if (lookahead == ';') ADVANCE(26); if (lookahead == '\t' || (0x0b <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(11); + lookahead == ' ') SKIP(10); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || ('a' <= lookahead && lookahead <= 'z')) ADVANCE(61); END_STATE(); + case 11: + if (lookahead == '/') ADVANCE(19); + END_STATE(); case 12: - if (lookahead == '/') ADVANCE(21); + if (lookahead == '=') ADVANCE(69); END_STATE(); case 13: if (lookahead == '=') ADVANCE(68); END_STATE(); case 14: - if (lookahead == '=') ADVANCE(67); - END_STATE(); - case 15: - if (lookahead == '|') ADVANCE(65); - END_STATE(); - case 16: if (lookahead == '+' || - lookahead == '-') ADVANCE(19); + lookahead == '-') ADVANCE(17); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(82); + lookahead == '_') ADVANCE(85); END_STATE(); - case 17: + case 15: if (lookahead == '0' || lookahead == '1' || - lookahead == '_') ADVANCE(81); + lookahead == '_') ADVANCE(84); END_STATE(); - case 18: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(80); + case 16: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(83); END_STATE(); - case 19: + case 17: if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(82); + lookahead == '_') ADVANCE(85); END_STATE(); - case 20: + case 18: if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(84); + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(87); END_STATE(); - case 21: + case 19: if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || ('a' <= lookahead && lookahead <= 'z')) ADVANCE(61); END_STATE(); - case 22: + case 20: if (lookahead != 0 && lookahead != '\n') ADVANCE(4); END_STATE(); - case 23: + case 21: if (lookahead != 0 && lookahead != '\n') ADVANCE(5); END_STATE(); - case 24: + case 22: if (lookahead != 0 && lookahead != '\n') ADVANCE(6); END_STATE(); - case 25: - if (eof) ADVANCE(26); + case 23: + if (eof) ADVANCE(24); ADVANCE_MAP( - '\n', 27, - '!', 47, + '\n', 25, + '!', 45, '"', 4, - '#', 31, - '$', 30, - '%', 43, - '\'', 8, - '(', 50, - ')', 51, - '*', 49, - '+', 58, - ',', 36, - '-', 59, - '.', 39, + '#', 28, + '$', 27, + '%', 40, + '&', 58, + '\'', 7, + '(', 48, + ')', 49, + '*', 47, + '+', 56, + ',', 33, + '-', 57, + '.', 36, '/', 60, - '0', 76, - ':', 46, - ';', 28, - '<', 52, - '=', 37, - '>', 54, - '?', 33, - '@', 32, - '[', 41, - '\\', 35, - ']', 42, - '^', 34, - 'b', 73, - 'p', 74, - '{', 44, - '|', 64, - '}', 45, - '~', 29, + '0', 79, + ':', 43, + ';', 26, + '<', 50, + '=', 34, + '>', 52, + '?', 30, + '@', 29, + '[', 38, + '\\', 31, + ']', 39, + '^', 44, + 'b', 76, + 'p', 77, + '{', 41, + '|', 65, + '}', 42, + '~', 32, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(25); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(78); + lookahead == ' ') SKIP(23); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(81); if (('A' <= lookahead && lookahead <= '_') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(75); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(78); END_STATE(); - case 26: + case 24: ACCEPT_TOKEN(ts_builtin_sym_end); END_STATE(); - case 27: + case 25: ACCEPT_TOKEN(anon_sym_LF); END_STATE(); - case 28: + case 26: ACCEPT_TOKEN(sym_comment); if (lookahead != 0 && - lookahead != '\n') ADVANCE(28); + lookahead != '\n') ADVANCE(26); + END_STATE(); + case 27: + ACCEPT_TOKEN(sym_leader_dollar); + END_STATE(); + case 28: + ACCEPT_TOKEN(sym_leader_hash); END_STATE(); case 29: - ACCEPT_TOKEN(sym_leader_tilde); + ACCEPT_TOKEN(sym_leader_at); END_STATE(); case 30: - ACCEPT_TOKEN(sym_leader_dollar); + ACCEPT_TOKEN(sym_leader_question); END_STATE(); case 31: - ACCEPT_TOKEN(sym_leader_hash); + ACCEPT_TOKEN(sym_leader_backslash); END_STATE(); case 32: - ACCEPT_TOKEN(sym_leader_at); + ACCEPT_TOKEN(anon_sym_TILDE); END_STATE(); case 33: - ACCEPT_TOKEN(sym_leader_question); + ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); case 34: - ACCEPT_TOKEN(sym_leader_caret); + ACCEPT_TOKEN(anon_sym_EQ); END_STATE(); case 35: - ACCEPT_TOKEN(sym_leader_backslash); + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(68); END_STATE(); case 36: - ACCEPT_TOKEN(anon_sym_COMMA); + ACCEPT_TOKEN(anon_sym_DOT); END_STATE(); case 37: - ACCEPT_TOKEN(anon_sym_EQ); + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(55); END_STATE(); case 38: - ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '=') ADVANCE(67); + ACCEPT_TOKEN(anon_sym_LBRACK); END_STATE(); case 39: - ACCEPT_TOKEN(anon_sym_DOT); + ACCEPT_TOKEN(anon_sym_RBRACK); END_STATE(); case 40: - ACCEPT_TOKEN(anon_sym_DOT); - if (lookahead == '.') ADVANCE(57); + ACCEPT_TOKEN(anon_sym_PERCENT); END_STATE(); case 41: - ACCEPT_TOKEN(anon_sym_LBRACK); + ACCEPT_TOKEN(anon_sym_LBRACE); END_STATE(); case 42: - ACCEPT_TOKEN(anon_sym_RBRACK); + ACCEPT_TOKEN(anon_sym_RBRACE); END_STATE(); case 43: - ACCEPT_TOKEN(anon_sym_PERCENT); + ACCEPT_TOKEN(anon_sym_COLON); END_STATE(); case 44: - ACCEPT_TOKEN(anon_sym_LBRACE); + ACCEPT_TOKEN(anon_sym_CARET); END_STATE(); case 45: - ACCEPT_TOKEN(anon_sym_RBRACE); + ACCEPT_TOKEN(anon_sym_BANG); END_STATE(); case 46: - ACCEPT_TOKEN(anon_sym_COLON); + ACCEPT_TOKEN(anon_sym_BANG); + if (lookahead == '=') ADVANCE(69); END_STATE(); case 47: - ACCEPT_TOKEN(anon_sym_BANG); + ACCEPT_TOKEN(anon_sym_STAR); END_STATE(); case 48: - ACCEPT_TOKEN(anon_sym_BANG); - if (lookahead == '=') ADVANCE(68); + ACCEPT_TOKEN(anon_sym_LPAREN); END_STATE(); case 49: - ACCEPT_TOKEN(anon_sym_STAR); + ACCEPT_TOKEN(anon_sym_RPAREN); END_STATE(); case 50: - ACCEPT_TOKEN(anon_sym_LPAREN); + ACCEPT_TOKEN(anon_sym_LT); END_STATE(); case 51: - ACCEPT_TOKEN(anon_sym_RPAREN); + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(74); + if (lookahead == '=') ADVANCE(72); END_STATE(); case 52: - ACCEPT_TOKEN(anon_sym_LT); + ACCEPT_TOKEN(anon_sym_GT); END_STATE(); case 53: - ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '=') ADVANCE(71); + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(73); + if (lookahead == '>') ADVANCE(75); END_STATE(); case 54: - ACCEPT_TOKEN(anon_sym_GT); + ACCEPT_TOKEN(sym_match_leader); + if (lookahead == '\t' || + lookahead == ' ') ADVANCE(54); END_STATE(); case 55: - ACCEPT_TOKEN(anon_sym_GT); - if (lookahead == '=') ADVANCE(72); + ACCEPT_TOKEN(anon_sym_DOT_DOT); END_STATE(); case 56: - ACCEPT_TOKEN(sym_match_leader); - if (lookahead == '\t' || - lookahead == ' ') ADVANCE(56); + ACCEPT_TOKEN(anon_sym_PLUS); END_STATE(); case 57: - ACCEPT_TOKEN(anon_sym_DOT_DOT); + ACCEPT_TOKEN(anon_sym_DASH); END_STATE(); case 58: - ACCEPT_TOKEN(anon_sym_PLUS); + ACCEPT_TOKEN(anon_sym_AMP); END_STATE(); case 59: - ACCEPT_TOKEN(anon_sym_DASH); + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '&') ADVANCE(67); END_STATE(); case 60: ACCEPT_TOKEN(anon_sym_SLASH); END_STATE(); case 61: ACCEPT_TOKEN(sym_import_path); - if (lookahead == '/') ADVANCE(21); + if (lookahead == '/') ADVANCE(19); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || ('a' <= lookahead && lookahead <= 'z')) ADVANCE(61); END_STATE(); case 62: - ACCEPT_TOKEN(sym_true_atom); + ACCEPT_TOKEN(anon_sym_PIPE); END_STATE(); case 63: - ACCEPT_TOKEN(sym_true_atom); - if (lookahead == '|') ADVANCE(65); - if (lookahead == '\t' || - lookahead == ' ') ADVANCE(56); + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '|') ADVANCE(66); END_STATE(); case 64: - ACCEPT_TOKEN(sym_true_atom); + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '|') ADVANCE(66); if (lookahead == '\t' || - lookahead == ' ') ADVANCE(56); + lookahead == ' ') ADVANCE(54); END_STATE(); case 65: - ACCEPT_TOKEN(anon_sym_PIPE_PIPE); + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '\t' || + lookahead == ' ') ADVANCE(54); END_STATE(); case 66: - ACCEPT_TOKEN(anon_sym_AMP_AMP); + ACCEPT_TOKEN(anon_sym_PIPE_PIPE); END_STATE(); case 67: - ACCEPT_TOKEN(anon_sym_EQ_EQ); - if (lookahead == '=') ADVANCE(69); + ACCEPT_TOKEN(anon_sym_AMP_AMP); END_STATE(); case 68: - ACCEPT_TOKEN(anon_sym_BANG_EQ); + ACCEPT_TOKEN(anon_sym_EQ_EQ); if (lookahead == '=') ADVANCE(70); END_STATE(); case 69: - ACCEPT_TOKEN(anon_sym_EQ_EQ_EQ); + ACCEPT_TOKEN(anon_sym_BANG_EQ); + if (lookahead == '=') ADVANCE(71); END_STATE(); case 70: - ACCEPT_TOKEN(anon_sym_BANG_EQ_EQ); + ACCEPT_TOKEN(anon_sym_EQ_EQ_EQ); END_STATE(); case 71: - ACCEPT_TOKEN(anon_sym_LT_EQ); + ACCEPT_TOKEN(anon_sym_BANG_EQ_EQ); END_STATE(); case 72: - ACCEPT_TOKEN(anon_sym_GT_EQ); + ACCEPT_TOKEN(anon_sym_LT_EQ); END_STATE(); case 73: + ACCEPT_TOKEN(anon_sym_GT_EQ); + END_STATE(); + case 74: + ACCEPT_TOKEN(anon_sym_LT_LT); + END_STATE(); + case 75: + ACCEPT_TOKEN(anon_sym_GT_GT); + END_STATE(); + case 76: ACCEPT_TOKEN(sym_ident); if (lookahead == '"') ADVANCE(5); - if (lookahead == '\'') ADVANCE(9); + if (lookahead == '\'') ADVANCE(8); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(75); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(78); END_STATE(); - case 74: + case 77: ACCEPT_TOKEN(sym_ident); if (lookahead == '"') ADVANCE(6); - if (lookahead == '\'') ADVANCE(10); + if (lookahead == '\'') ADVANCE(9); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(75); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(78); END_STATE(); - case 75: + case 78: ACCEPT_TOKEN(sym_ident); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(75); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(78); END_STATE(); - case 76: + case 79: ACCEPT_TOKEN(sym_number); - if (lookahead == '.') ADVANCE(18); + if (lookahead == '.') ADVANCE(16); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(86); + lookahead == 'b') ADVANCE(89); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(85); + lookahead == 'e') ADVANCE(88); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(87); + lookahead == 'x') ADVANCE(90); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(78); + lookahead == '_') ADVANCE(81); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); END_STATE(); - case 77: + case 80: ACCEPT_TOKEN(sym_number); - if (lookahead == '.') ADVANCE(18); + if (lookahead == '.') ADVANCE(16); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(17); + lookahead == 'b') ADVANCE(15); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(16); + lookahead == 'e') ADVANCE(14); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(20); + lookahead == 'x') ADVANCE(18); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(79); + lookahead == '_') ADVANCE(82); END_STATE(); - case 78: + case 81: ACCEPT_TOKEN(sym_number); - if (lookahead == '.') ADVANCE(18); + if (lookahead == '.') ADVANCE(16); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(85); + lookahead == 'e') ADVANCE(88); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(78); + lookahead == '_') ADVANCE(81); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); END_STATE(); - case 79: + case 82: ACCEPT_TOKEN(sym_number); - if (lookahead == '.') ADVANCE(18); + if (lookahead == '.') ADVANCE(16); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(16); + lookahead == 'e') ADVANCE(14); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(79); + lookahead == '_') ADVANCE(82); END_STATE(); - case 80: + case 83: ACCEPT_TOKEN(sym_number); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(16); + lookahead == 'e') ADVANCE(14); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(80); + lookahead == '_') ADVANCE(83); END_STATE(); - case 81: + case 84: ACCEPT_TOKEN(sym_number); if (lookahead == '0' || lookahead == '1' || - lookahead == '_') ADVANCE(81); + lookahead == '_') ADVANCE(84); END_STATE(); - case 82: + case 85: ACCEPT_TOKEN(sym_number); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(82); + lookahead == '_') ADVANCE(85); END_STATE(); - case 83: + case 86: ACCEPT_TOKEN(sym_number); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(84); + lookahead == '_') ADVANCE(87); if (('A' <= lookahead && lookahead <= 'F') || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(83); + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(86); if (('G' <= lookahead && lookahead <= 'Z') || - ('g' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('g' <= lookahead && lookahead <= 'z')) ADVANCE(91); END_STATE(); - case 84: + case 87: ACCEPT_TOKEN(sym_number); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(84); + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(87); END_STATE(); - case 85: + case 88: ACCEPT_TOKEN(sym_duration); if (lookahead == '+' || - lookahead == '-') ADVANCE(19); + lookahead == '-') ADVANCE(17); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(82); + lookahead == '_') ADVANCE(85); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); END_STATE(); - case 86: + case 89: ACCEPT_TOKEN(sym_duration); if (lookahead == '0' || lookahead == '1' || - lookahead == '_') ADVANCE(81); + lookahead == '_') ADVANCE(84); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); END_STATE(); - case 87: + case 90: ACCEPT_TOKEN(sym_duration); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(84); + lookahead == '_') ADVANCE(87); if (('A' <= lookahead && lookahead <= 'F') || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(83); + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(86); if (('G' <= lookahead && lookahead <= 'Z') || - ('g' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('g' <= lookahead && lookahead <= 'z')) ADVANCE(91); END_STATE(); - case 88: + case 91: ACCEPT_TOKEN(sym_duration); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(88); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); END_STATE(); - case 89: + case 92: ACCEPT_TOKEN(sym_string_pure); END_STATE(); - case 90: + case 93: ACCEPT_TOKEN(sym_string_rich); END_STATE(); - case 91: + case 94: ACCEPT_TOKEN(sym_bytes_pure); END_STATE(); - case 92: + case 95: ACCEPT_TOKEN(sym_bytes_rich); END_STATE(); - case 93: + case 96: ACCEPT_TOKEN(sym_locator_pure); END_STATE(); - case 94: + case 97: ACCEPT_TOKEN(sym_locator_rich); END_STATE(); default: @@ -1899,76 +2076,76 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [0] = {.lex_state = 0}, - [1] = {.lex_state = 25}, - [2] = {.lex_state = 25}, - [3] = {.lex_state = 25}, - [4] = {.lex_state = 25}, - [5] = {.lex_state = 25}, - [6] = {.lex_state = 25}, - [7] = {.lex_state = 25}, - [8] = {.lex_state = 25}, - [9] = {.lex_state = 25}, - [10] = {.lex_state = 25}, - [11] = {.lex_state = 25}, - [12] = {.lex_state = 25}, - [13] = {.lex_state = 25}, - [14] = {.lex_state = 25}, - [15] = {.lex_state = 25}, - [16] = {.lex_state = 25}, - [17] = {.lex_state = 25}, - [18] = {.lex_state = 25}, - [19] = {.lex_state = 25}, - [20] = {.lex_state = 25}, - [21] = {.lex_state = 25}, - [22] = {.lex_state = 25}, - [23] = {.lex_state = 25}, - [24] = {.lex_state = 25}, - [25] = {.lex_state = 25}, - [26] = {.lex_state = 25}, - [27] = {.lex_state = 25}, - [28] = {.lex_state = 25}, - [29] = {.lex_state = 25}, - [30] = {.lex_state = 25}, - [31] = {.lex_state = 25}, - [32] = {.lex_state = 25}, - [33] = {.lex_state = 25}, - [34] = {.lex_state = 25}, - [35] = {.lex_state = 25}, - [36] = {.lex_state = 25}, - [37] = {.lex_state = 25}, - [38] = {.lex_state = 25}, - [39] = {.lex_state = 25}, - [40] = {.lex_state = 25}, - [41] = {.lex_state = 25}, - [42] = {.lex_state = 25}, - [43] = {.lex_state = 25}, - [44] = {.lex_state = 25}, - [45] = {.lex_state = 25}, - [46] = {.lex_state = 25}, - [47] = {.lex_state = 25}, - [48] = {.lex_state = 25}, - [49] = {.lex_state = 25}, - [50] = {.lex_state = 25}, - [51] = {.lex_state = 25}, - [52] = {.lex_state = 25}, - [53] = {.lex_state = 0}, - [54] = {.lex_state = 0}, - [55] = {.lex_state = 0}, - [56] = {.lex_state = 0}, - [57] = {.lex_state = 0}, - [58] = {.lex_state = 0}, - [59] = {.lex_state = 0}, - [60] = {.lex_state = 0}, - [61] = {.lex_state = 0}, - [62] = {.lex_state = 0}, - [63] = {.lex_state = 0}, - [64] = {.lex_state = 0}, - [65] = {.lex_state = 0}, - [66] = {.lex_state = 0}, - [67] = {.lex_state = 0}, - [68] = {.lex_state = 0}, - [69] = {.lex_state = 0}, - [70] = {.lex_state = 0}, + [1] = {.lex_state = 23}, + [2] = {.lex_state = 23}, + [3] = {.lex_state = 23}, + [4] = {.lex_state = 23}, + [5] = {.lex_state = 23}, + [6] = {.lex_state = 23}, + [7] = {.lex_state = 23}, + [8] = {.lex_state = 23}, + [9] = {.lex_state = 23}, + [10] = {.lex_state = 23}, + [11] = {.lex_state = 23}, + [12] = {.lex_state = 23}, + [13] = {.lex_state = 23}, + [14] = {.lex_state = 23}, + [15] = {.lex_state = 23}, + [16] = {.lex_state = 23}, + [17] = {.lex_state = 23}, + [18] = {.lex_state = 23}, + [19] = {.lex_state = 23}, + [20] = {.lex_state = 23}, + [21] = {.lex_state = 23}, + [22] = {.lex_state = 23}, + [23] = {.lex_state = 23}, + [24] = {.lex_state = 23}, + [25] = {.lex_state = 23}, + [26] = {.lex_state = 23}, + [27] = {.lex_state = 23}, + [28] = {.lex_state = 23}, + [29] = {.lex_state = 23}, + [30] = {.lex_state = 23}, + [31] = {.lex_state = 23}, + [32] = {.lex_state = 23}, + [33] = {.lex_state = 23}, + [34] = {.lex_state = 23}, + [35] = {.lex_state = 23}, + [36] = {.lex_state = 23}, + [37] = {.lex_state = 23}, + [38] = {.lex_state = 23}, + [39] = {.lex_state = 23}, + [40] = {.lex_state = 23}, + [41] = {.lex_state = 23}, + [42] = {.lex_state = 23}, + [43] = {.lex_state = 23}, + [44] = {.lex_state = 23}, + [45] = {.lex_state = 23}, + [46] = {.lex_state = 23}, + [47] = {.lex_state = 23}, + [48] = {.lex_state = 23}, + [49] = {.lex_state = 23}, + [50] = {.lex_state = 23}, + [51] = {.lex_state = 23}, + [52] = {.lex_state = 23}, + [53] = {.lex_state = 23}, + [54] = {.lex_state = 23}, + [55] = {.lex_state = 23}, + [56] = {.lex_state = 23}, + [57] = {.lex_state = 23}, + [58] = {.lex_state = 23}, + [59] = {.lex_state = 23}, + [60] = {.lex_state = 23}, + [61] = {.lex_state = 23}, + [62] = {.lex_state = 23}, + [63] = {.lex_state = 23}, + [64] = {.lex_state = 23}, + [65] = {.lex_state = 23}, + [66] = {.lex_state = 23}, + [67] = {.lex_state = 23}, + [68] = {.lex_state = 23}, + [69] = {.lex_state = 23}, + [70] = {.lex_state = 23}, [71] = {.lex_state = 0}, [72] = {.lex_state = 0}, [73] = {.lex_state = 0}, @@ -2004,69 +2181,69 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [103] = {.lex_state = 0}, [104] = {.lex_state = 0}, [105] = {.lex_state = 0}, - [106] = {.lex_state = 25}, - [107] = {.lex_state = 25}, - [108] = {.lex_state = 25}, - [109] = {.lex_state = 25}, - [110] = {.lex_state = 25}, - [111] = {.lex_state = 25}, - [112] = {.lex_state = 25}, - [113] = {.lex_state = 25}, - [114] = {.lex_state = 25}, - [115] = {.lex_state = 25}, - [116] = {.lex_state = 25}, - [117] = {.lex_state = 25}, - [118] = {.lex_state = 25}, - [119] = {.lex_state = 25}, - [120] = {.lex_state = 25}, - [121] = {.lex_state = 25}, - [122] = {.lex_state = 25}, - [123] = {.lex_state = 25}, - [124] = {.lex_state = 2}, - [125] = {.lex_state = 2}, - [126] = {.lex_state = 2}, - [127] = {.lex_state = 2}, - [128] = {.lex_state = 25}, - [129] = {.lex_state = 25}, - [130] = {.lex_state = 25}, - [131] = {.lex_state = 25}, - [132] = {.lex_state = 2}, - [133] = {.lex_state = 2}, - [134] = {.lex_state = 25}, - [135] = {.lex_state = 25}, - [136] = {.lex_state = 25}, - [137] = {.lex_state = 25}, - [138] = {.lex_state = 25}, - [139] = {.lex_state = 2}, - [140] = {.lex_state = 25}, - [141] = {.lex_state = 25}, - [142] = {.lex_state = 25}, - [143] = {.lex_state = 25}, - [144] = {.lex_state = 2}, - [145] = {.lex_state = 2}, + [106] = {.lex_state = 0}, + [107] = {.lex_state = 0}, + [108] = {.lex_state = 0}, + [109] = {.lex_state = 0}, + [110] = {.lex_state = 0}, + [111] = {.lex_state = 0}, + [112] = {.lex_state = 0}, + [113] = {.lex_state = 0}, + [114] = {.lex_state = 0}, + [115] = {.lex_state = 0}, + [116] = {.lex_state = 0}, + [117] = {.lex_state = 0}, + [118] = {.lex_state = 0}, + [119] = {.lex_state = 0}, + [120] = {.lex_state = 0}, + [121] = {.lex_state = 0}, + [122] = {.lex_state = 0}, + [123] = {.lex_state = 0}, + [124] = {.lex_state = 0}, + [125] = {.lex_state = 0}, + [126] = {.lex_state = 0}, + [127] = {.lex_state = 0}, + [128] = {.lex_state = 0}, + [129] = {.lex_state = 0}, + [130] = {.lex_state = 0}, + [131] = {.lex_state = 23}, + [132] = {.lex_state = 23}, + [133] = {.lex_state = 23}, + [134] = {.lex_state = 23}, + [135] = {.lex_state = 23}, + [136] = {.lex_state = 23}, + [137] = {.lex_state = 23}, + [138] = {.lex_state = 23}, + [139] = {.lex_state = 23}, + [140] = {.lex_state = 23}, + [141] = {.lex_state = 23}, + [142] = {.lex_state = 23}, + [143] = {.lex_state = 23}, + [144] = {.lex_state = 23}, + [145] = {.lex_state = 23}, [146] = {.lex_state = 2}, - [147] = {.lex_state = 25}, - [148] = {.lex_state = 25}, + [147] = {.lex_state = 2}, + [148] = {.lex_state = 2}, [149] = {.lex_state = 2}, - [150] = {.lex_state = 25}, + [150] = {.lex_state = 2}, [151] = {.lex_state = 2}, - [152] = {.lex_state = 25}, + [152] = {.lex_state = 2}, [153] = {.lex_state = 2}, - [154] = {.lex_state = 25}, - [155] = {.lex_state = 2}, - [156] = {.lex_state = 25}, - [157] = {.lex_state = 25}, - [158] = {.lex_state = 25}, + [154] = {.lex_state = 23}, + [155] = {.lex_state = 23}, + [156] = {.lex_state = 2}, + [157] = {.lex_state = 23}, + [158] = {.lex_state = 2}, [159] = {.lex_state = 2}, - [160] = {.lex_state = 25}, - [161] = {.lex_state = 25}, + [160] = {.lex_state = 2}, + [161] = {.lex_state = 2}, [162] = {.lex_state = 2}, - [163] = {.lex_state = 25}, + [163] = {.lex_state = 2}, [164] = {.lex_state = 2}, [165] = {.lex_state = 2}, [166] = {.lex_state = 2}, [167] = {.lex_state = 2}, - [168] = {.lex_state = 2}, + [168] = {.lex_state = 23}, [169] = {.lex_state = 2}, [170] = {.lex_state = 2}, [171] = {.lex_state = 2}, @@ -2080,169 +2257,294 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [179] = {.lex_state = 2}, [180] = {.lex_state = 2}, [181] = {.lex_state = 2}, - [182] = {.lex_state = 2}, - [183] = {.lex_state = 2}, + [182] = {.lex_state = 23}, + [183] = {.lex_state = 23}, [184] = {.lex_state = 2}, - [185] = {.lex_state = 2}, + [185] = {.lex_state = 23}, [186] = {.lex_state = 2}, [187] = {.lex_state = 2}, - [188] = {.lex_state = 2}, + [188] = {.lex_state = 23}, [189] = {.lex_state = 2}, [190] = {.lex_state = 2}, [191] = {.lex_state = 2}, - [192] = {.lex_state = 2}, + [192] = {.lex_state = 23}, [193] = {.lex_state = 2}, - [194] = {.lex_state = 2}, - [195] = {.lex_state = 2}, + [194] = {.lex_state = 23}, + [195] = {.lex_state = 23}, [196] = {.lex_state = 2}, - [197] = {.lex_state = 2}, + [197] = {.lex_state = 23}, [198] = {.lex_state = 2}, [199] = {.lex_state = 2}, - [200] = {.lex_state = 3}, - [201] = {.lex_state = 0}, - [202] = {.lex_state = 0}, - [203] = {.lex_state = 0}, - [204] = {.lex_state = 0}, - [205] = {.lex_state = 0}, - [206] = {.lex_state = 0}, - [207] = {.lex_state = 0}, - [208] = {.lex_state = 0}, - [209] = {.lex_state = 0}, - [210] = {.lex_state = 0}, - [211] = {.lex_state = 0}, - [212] = {.lex_state = 0}, - [213] = {.lex_state = 0}, - [214] = {.lex_state = 0}, - [215] = {.lex_state = 0}, - [216] = {.lex_state = 0}, - [217] = {.lex_state = 0}, - [218] = {.lex_state = 0}, - [219] = {.lex_state = 0}, - [220] = {.lex_state = 0}, - [221] = {.lex_state = 1}, - [222] = {.lex_state = 0}, - [223] = {.lex_state = 1}, - [224] = {.lex_state = 0}, - [225] = {.lex_state = 0}, - [226] = {.lex_state = 1}, - [227] = {.lex_state = 0}, - [228] = {.lex_state = 0}, - [229] = {.lex_state = 0}, - [230] = {.lex_state = 0}, - [231] = {.lex_state = 0}, - [232] = {.lex_state = 1}, - [233] = {.lex_state = 1}, - [234] = {.lex_state = 1}, - [235] = {.lex_state = 1}, - [236] = {.lex_state = 1}, - [237] = {.lex_state = 1}, - [238] = {.lex_state = 1}, - [239] = {.lex_state = 1}, - [240] = {.lex_state = 1}, - [241] = {.lex_state = 1}, - [242] = {.lex_state = 1}, - [243] = {.lex_state = 1}, - [244] = {.lex_state = 3}, - [245] = {.lex_state = 3}, - [246] = {.lex_state = 25}, - [247] = {.lex_state = 0}, - [248] = {.lex_state = 0}, - [249] = {.lex_state = 3}, - [250] = {.lex_state = 0}, - [251] = {.lex_state = 3}, - [252] = {.lex_state = 0}, - [253] = {.lex_state = 1}, - [254] = {.lex_state = 0}, - [255] = {.lex_state = 0}, - [256] = {.lex_state = 1}, - [257] = {.lex_state = 0}, + [200] = {.lex_state = 2}, + [201] = {.lex_state = 23}, + [202] = {.lex_state = 23}, + [203] = {.lex_state = 23}, + [204] = {.lex_state = 23}, + [205] = {.lex_state = 23}, + [206] = {.lex_state = 2}, + [207] = {.lex_state = 23}, + [208] = {.lex_state = 2}, + [209] = {.lex_state = 23}, + [210] = {.lex_state = 23}, + [211] = {.lex_state = 2}, + [212] = {.lex_state = 23}, + [213] = {.lex_state = 2}, + [214] = {.lex_state = 2}, + [215] = {.lex_state = 2}, + [216] = {.lex_state = 2}, + [217] = {.lex_state = 2}, + [218] = {.lex_state = 23}, + [219] = {.lex_state = 2}, + [220] = {.lex_state = 2}, + [221] = {.lex_state = 2}, + [222] = {.lex_state = 2}, + [223] = {.lex_state = 2}, + [224] = {.lex_state = 2}, + [225] = {.lex_state = 2}, + [226] = {.lex_state = 2}, + [227] = {.lex_state = 2}, + [228] = {.lex_state = 2}, + [229] = {.lex_state = 2}, + [230] = {.lex_state = 2}, + [231] = {.lex_state = 2}, + [232] = {.lex_state = 2}, + [233] = {.lex_state = 23}, + [234] = {.lex_state = 23}, + [235] = {.lex_state = 23}, + [236] = {.lex_state = 2}, + [237] = {.lex_state = 2}, + [238] = {.lex_state = 2}, + [239] = {.lex_state = 23}, + [240] = {.lex_state = 2}, + [241] = {.lex_state = 23}, + [242] = {.lex_state = 23}, + [243] = {.lex_state = 23}, + [244] = {.lex_state = 23}, + [245] = {.lex_state = 2}, + [246] = {.lex_state = 2}, + [247] = {.lex_state = 2}, + [248] = {.lex_state = 2}, + [249] = {.lex_state = 23}, + [250] = {.lex_state = 2}, + [251] = {.lex_state = 2}, + [252] = {.lex_state = 23}, + [253] = {.lex_state = 3}, + [254] = {.lex_state = 3}, + [255] = {.lex_state = 3}, + [256] = {.lex_state = 3}, + [257] = {.lex_state = 3}, [258] = {.lex_state = 3}, - [259] = {.lex_state = 0}, - [260] = {.lex_state = 25}, - [261] = {.lex_state = 25}, - [262] = {.lex_state = 0}, - [263] = {.lex_state = 0}, + [259] = {.lex_state = 3}, + [260] = {.lex_state = 3}, + [261] = {.lex_state = 3}, + [262] = {.lex_state = 3}, + [263] = {.lex_state = 3}, [264] = {.lex_state = 3}, - [265] = {.lex_state = 0}, - [266] = {.lex_state = 0}, - [267] = {.lex_state = 0}, + [265] = {.lex_state = 3}, + [266] = {.lex_state = 3}, + [267] = {.lex_state = 3}, [268] = {.lex_state = 3}, [269] = {.lex_state = 3}, - [270] = {.lex_state = 0}, - [271] = {.lex_state = 0}, - [272] = {.lex_state = 0}, - [273] = {.lex_state = 0}, - [274] = {.lex_state = 0}, - [275] = {.lex_state = 25}, - [276] = {.lex_state = 0}, - [277] = {.lex_state = 25}, + [270] = {.lex_state = 3}, + [271] = {.lex_state = 3}, + [272] = {.lex_state = 3}, + [273] = {.lex_state = 3}, + [274] = {.lex_state = 3}, + [275] = {.lex_state = 3}, + [276] = {.lex_state = 3}, + [277] = {.lex_state = 3}, [278] = {.lex_state = 3}, [279] = {.lex_state = 3}, [280] = {.lex_state = 3}, - [281] = {.lex_state = 0}, + [281] = {.lex_state = 3}, [282] = {.lex_state = 3}, - [283] = {.lex_state = 0}, - [284] = {.lex_state = 25}, - [285] = {.lex_state = 0}, - [286] = {.lex_state = 0}, - [287] = {.lex_state = 0}, - [288] = {.lex_state = 0}, + [283] = {.lex_state = 3}, + [284] = {.lex_state = 3}, + [285] = {.lex_state = 3}, + [286] = {.lex_state = 3}, + [287] = {.lex_state = 3}, + [288] = {.lex_state = 3}, [289] = {.lex_state = 3}, [290] = {.lex_state = 3}, [291] = {.lex_state = 3}, [292] = {.lex_state = 3}, - [293] = {.lex_state = 0}, - [294] = {.lex_state = 0}, + [293] = {.lex_state = 3}, + [294] = {.lex_state = 3}, [295] = {.lex_state = 3}, - [296] = {.lex_state = 0}, - [297] = {.lex_state = 0}, + [296] = {.lex_state = 3}, + [297] = {.lex_state = 3}, [298] = {.lex_state = 3}, - [299] = {.lex_state = 0}, - [300] = {.lex_state = 25}, - [301] = {.lex_state = 0}, - [302] = {.lex_state = 0}, - [303] = {.lex_state = 0}, - [304] = {.lex_state = 11}, + [299] = {.lex_state = 3}, + [300] = {.lex_state = 3}, + [301] = {.lex_state = 3}, + [302] = {.lex_state = 3}, + [303] = {.lex_state = 3}, + [304] = {.lex_state = 3}, [305] = {.lex_state = 3}, [306] = {.lex_state = 3}, [307] = {.lex_state = 3}, [308] = {.lex_state = 3}, - [309] = {.lex_state = 0}, - [310] = {.lex_state = 0}, + [309] = {.lex_state = 3}, + [310] = {.lex_state = 3}, [311] = {.lex_state = 3}, - [312] = {.lex_state = 0}, - [313] = {.lex_state = 0}, - [314] = {.lex_state = 0}, - [315] = {.lex_state = 0}, - [316] = {.lex_state = 0}, + [312] = {.lex_state = 3}, + [313] = {.lex_state = 3}, + [314] = {.lex_state = 3}, + [315] = {.lex_state = 3}, + [316] = {.lex_state = 3}, [317] = {.lex_state = 3}, - [318] = {.lex_state = 0}, + [318] = {.lex_state = 3}, [319] = {.lex_state = 3}, - [320] = {.lex_state = 0}, - [321] = {.lex_state = 0}, + [320] = {.lex_state = 3}, + [321] = {.lex_state = 3}, [322] = {.lex_state = 3}, [323] = {.lex_state = 3}, - [324] = {.lex_state = 0}, - [325] = {.lex_state = 3}, - [326] = {.lex_state = 3}, - [327] = {.lex_state = 0}, - [328] = {.lex_state = 3}, - [329] = {.lex_state = 0}, - [330] = {.lex_state = 0}, - [331] = {.lex_state = 3}, - [332] = {.lex_state = 3}, - [333] = {.lex_state = 0}, - [334] = {.lex_state = 0}, - [335] = {.lex_state = 0}, - [336] = {.lex_state = 0}, - [337] = {.lex_state = 0}, - [338] = {.lex_state = 0}, - [339] = {.lex_state = 0}, - [340] = {.lex_state = 0}, - [341] = {.lex_state = 0}, + [324] = {.lex_state = 1}, + [325] = {.lex_state = 1}, + [326] = {.lex_state = 1}, + [327] = {.lex_state = 1}, + [328] = {.lex_state = 1}, + [329] = {.lex_state = 1}, + [330] = {.lex_state = 1}, + [331] = {.lex_state = 1}, + [332] = {.lex_state = 1}, + [333] = {.lex_state = 1}, + [334] = {.lex_state = 1}, + [335] = {.lex_state = 1}, + [336] = {.lex_state = 1}, + [337] = {.lex_state = 1}, + [338] = {.lex_state = 1}, + [339] = {.lex_state = 3}, + [340] = {.lex_state = 3}, + [341] = {.lex_state = 3}, [342] = {.lex_state = 3}, - [343] = {.lex_state = 3}, - [344] = {.lex_state = 3}, + [343] = {.lex_state = 0}, + [344] = {.lex_state = 0}, + [345] = {.lex_state = 3}, + [346] = {.lex_state = 3}, + [347] = {.lex_state = 0}, + [348] = {.lex_state = 0}, + [349] = {.lex_state = 0}, + [350] = {.lex_state = 1}, + [351] = {.lex_state = 1}, + [352] = {.lex_state = 0}, + [353] = {.lex_state = 23}, + [354] = {.lex_state = 3}, + [355] = {.lex_state = 0}, + [356] = {.lex_state = 0}, + [357] = {.lex_state = 0}, + [358] = {.lex_state = 0}, + [359] = {.lex_state = 3}, + [360] = {.lex_state = 0}, + [361] = {.lex_state = 0}, + [362] = {.lex_state = 0}, + [363] = {.lex_state = 0}, + [364] = {.lex_state = 3}, + [365] = {.lex_state = 3}, + [366] = {.lex_state = 23}, + [367] = {.lex_state = 0}, + [368] = {.lex_state = 3}, + [369] = {.lex_state = 23}, + [370] = {.lex_state = 3}, + [371] = {.lex_state = 0}, + [372] = {.lex_state = 0}, + [373] = {.lex_state = 0}, + [374] = {.lex_state = 23}, + [375] = {.lex_state = 23}, + [376] = {.lex_state = 0}, + [377] = {.lex_state = 0}, + [378] = {.lex_state = 0}, + [379] = {.lex_state = 0}, + [380] = {.lex_state = 0}, + [381] = {.lex_state = 0}, + [382] = {.lex_state = 0}, + [383] = {.lex_state = 3}, + [384] = {.lex_state = 0}, + [385] = {.lex_state = 0}, + [386] = {.lex_state = 23}, + [387] = {.lex_state = 0}, + [388] = {.lex_state = 3}, + [389] = {.lex_state = 0}, + [390] = {.lex_state = 0}, + [391] = {.lex_state = 0}, + [392] = {.lex_state = 0}, + [393] = {.lex_state = 0}, + [394] = {.lex_state = 0}, + [395] = {.lex_state = 0}, + [396] = {.lex_state = 0}, + [397] = {.lex_state = 0}, + [398] = {.lex_state = 3}, + [399] = {.lex_state = 0}, + [400] = {.lex_state = 0}, + [401] = {.lex_state = 23}, + [402] = {.lex_state = 3}, + [403] = {.lex_state = 0}, + [404] = {.lex_state = 0}, + [405] = {.lex_state = 0}, + [406] = {.lex_state = 0}, + [407] = {.lex_state = 3}, + [408] = {.lex_state = 3}, + [409] = {.lex_state = 3}, + [410] = {.lex_state = 3}, + [411] = {.lex_state = 3}, + [412] = {.lex_state = 3}, + [413] = {.lex_state = 3}, + [414] = {.lex_state = 3}, + [415] = {.lex_state = 3}, + [416] = {.lex_state = 3}, + [417] = {.lex_state = 0}, + [418] = {.lex_state = 0}, + [419] = {.lex_state = 0}, + [420] = {.lex_state = 3}, + [421] = {.lex_state = 0}, + [422] = {.lex_state = 3}, + [423] = {.lex_state = 0}, + [424] = {.lex_state = 0}, + [425] = {.lex_state = 0}, + [426] = {.lex_state = 0}, + [427] = {.lex_state = 0}, + [428] = {.lex_state = 3}, + [429] = {.lex_state = 0}, + [430] = {.lex_state = 3}, + [431] = {.lex_state = 23}, + [432] = {.lex_state = 3}, + [433] = {.lex_state = 3}, + [434] = {.lex_state = 10}, + [435] = {.lex_state = 0}, + [436] = {.lex_state = 3}, + [437] = {.lex_state = 3}, + [438] = {.lex_state = 0}, + [439] = {.lex_state = 3}, + [440] = {.lex_state = 0}, + [441] = {.lex_state = 3}, + [442] = {.lex_state = 3}, + [443] = {.lex_state = 0}, + [444] = {.lex_state = 23}, + [445] = {.lex_state = 0}, + [446] = {.lex_state = 3}, + [447] = {.lex_state = 0}, + [448] = {.lex_state = 0}, + [449] = {.lex_state = 0}, + [450] = {.lex_state = 3}, + [451] = {.lex_state = 0}, + [452] = {.lex_state = 0}, + [453] = {.lex_state = 0}, + [454] = {.lex_state = 0}, + [455] = {.lex_state = 0}, + [456] = {.lex_state = 0}, + [457] = {.lex_state = 3}, + [458] = {.lex_state = 0}, + [459] = {.lex_state = 0}, + [460] = {.lex_state = 0}, + [461] = {.lex_state = 23}, + [462] = {.lex_state = 3}, + [463] = {.lex_state = 3}, + [464] = {.lex_state = 0}, + [465] = {.lex_state = 0}, + [466] = {.lex_state = 3}, + [467] = {.lex_state = 0}, + [468] = {.lex_state = 0}, + [469] = {.lex_state = 0}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -2251,13 +2553,12 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_ident] = ACTIONS(1), [anon_sym_LF] = ACTIONS(1), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(1), [sym_leader_dollar] = ACTIONS(1), [sym_leader_hash] = ACTIONS(1), [sym_leader_at] = ACTIONS(1), [sym_leader_question] = ACTIONS(1), - [sym_leader_caret] = ACTIONS(1), [sym_leader_backslash] = ACTIONS(1), + [anon_sym_TILDE] = ACTIONS(1), [anon_sym_COMMA] = ACTIONS(1), [anon_sym_EQ] = ACTIONS(1), [anon_sym_DOT] = ACTIONS(1), @@ -2267,6 +2568,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_LBRACE] = ACTIONS(1), [anon_sym_RBRACE] = ACTIONS(1), [anon_sym_COLON] = ACTIONS(1), + [anon_sym_CARET] = ACTIONS(1), [anon_sym_BANG] = ACTIONS(1), [anon_sym_STAR] = ACTIONS(1), [anon_sym_LPAREN] = ACTIONS(1), @@ -2277,8 +2579,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DOT_DOT] = ACTIONS(1), [anon_sym_PLUS] = ACTIONS(1), [anon_sym_DASH] = ACTIONS(1), + [anon_sym_AMP] = ACTIONS(1), [anon_sym_SLASH] = ACTIONS(1), - [sym_true_atom] = ACTIONS(1), + [anon_sym_PIPE] = ACTIONS(1), [sym_false_atom] = ACTIONS(1), [anon_sym_PIPE_PIPE] = ACTIONS(1), [anon_sym_AMP_AMP] = ACTIONS(1), @@ -2288,6 +2591,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG_EQ_EQ] = ACTIONS(1), [anon_sym_LT_EQ] = ACTIONS(1), [anon_sym_GT_EQ] = ACTIONS(1), + [anon_sym_LT_LT] = ACTIONS(1), + [anon_sym_GT_GT] = ACTIONS(1), [sym_number] = ACTIONS(1), [sym_duration] = ACTIONS(1), [sym_string_pure] = ACTIONS(1), @@ -2298,297 +2603,157 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_locator_rich] = ACTIONS(1), }, [STATE(1)] = { - [sym_source_file] = STATE(314), - [sym__item] = STATE(11), - [sym_bind_statement] = STATE(11), - [sym_struct_statement] = STATE(11), - [sym_struct_extend_statement] = STATE(11), - [sym_if_statement] = STATE(11), - [sym_else_if_statement] = STATE(11), - [sym_else_statement] = STATE(11), - [sym_return_statement] = STATE(11), - [sym_error_return_statement] = STATE(11), - [sym_loop_statement] = STATE(11), - [sym_break_statement] = STATE(11), - [sym_continue_statement] = STATE(11), - [sym_match_statement] = STATE(11), - [sym_task_spawn_statement] = STATE(11), - [sym_task_join_statement] = STATE(11), - [sym_import_statement] = STATE(11), - [sym_export_statement] = STATE(11), - [sym_expression_statement] = STATE(11), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(11), + [sym_source_file] = STATE(445), + [sym__item] = STATE(29), + [sym_bind_statement] = STATE(29), + [sym_struct_statement] = STATE(29), + [sym_struct_extend_statement] = STATE(29), + [sym_if_statement] = STATE(29), + [sym_else_if_statement] = STATE(29), + [sym_else_statement] = STATE(29), + [sym_return_statement] = STATE(29), + [sym_error_return_statement] = STATE(29), + [sym_loop_statement] = STATE(29), + [sym_break_statement] = STATE(29), + [sym_continue_statement] = STATE(29), + [sym_match_statement] = STATE(29), + [sym_task_spawn_statement] = STATE(29), + [sym_task_join_statement] = STATE(29), + [sym_effect_block_statement] = STATE(29), + [sym_import_statement] = STATE(29), + [sym_export_statement] = STATE(29), + [sym_expression_statement] = STATE(29), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(29), [ts_builtin_sym_end] = ACTIONS(5), [sym_ident] = ACTIONS(7), [anon_sym_LF] = ACTIONS(9), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(2)] = { - [sym__item] = STATE(33), - [sym_bind_statement] = STATE(33), - [sym_struct_statement] = STATE(33), - [sym_struct_extend_statement] = STATE(33), - [sym_if_statement] = STATE(33), - [sym_else_if_statement] = STATE(33), - [sym_else_statement] = STATE(33), - [sym_return_statement] = STATE(33), - [sym_error_return_statement] = STATE(33), - [sym_loop_statement] = STATE(33), - [sym_break_statement] = STATE(33), - [sym_continue_statement] = STATE(33), - [sym_match_statement] = STATE(33), - [sym_task_spawn_statement] = STATE(33), - [sym_task_join_statement] = STATE(33), - [sym_import_statement] = STATE(33), - [sym_export_statement] = STATE(33), - [sym_expression_statement] = STATE(33), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym__struct_field_list] = STATE(338), - [sym_field_initializer] = STATE(255), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(33), - [sym_ident] = ACTIONS(53), - [anon_sym_LF] = ACTIONS(55), + [sym__item] = STATE(12), + [sym_bind_statement] = STATE(12), + [sym_struct_statement] = STATE(12), + [sym_struct_extend_statement] = STATE(12), + [sym_if_statement] = STATE(12), + [sym_else_if_statement] = STATE(12), + [sym_else_statement] = STATE(12), + [sym_return_statement] = STATE(12), + [sym_error_return_statement] = STATE(12), + [sym_loop_statement] = STATE(12), + [sym_break_statement] = STATE(12), + [sym_continue_statement] = STATE(12), + [sym_match_statement] = STATE(12), + [sym_task_spawn_statement] = STATE(12), + [sym_task_join_statement] = STATE(12), + [sym_effect_block_statement] = STATE(12), + [sym_import_statement] = STATE(12), + [sym_export_statement] = STATE(12), + [sym_expression_statement] = STATE(12), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym__struct_field_list] = STATE(459), + [sym_field_initializer] = STATE(357), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(12), + [sym_ident] = ACTIONS(59), + [anon_sym_LF] = ACTIONS(61), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(57), + [anon_sym_RBRACE] = ACTIONS(63), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(3)] = { - [sym__item] = STATE(20), - [sym_bind_statement] = STATE(20), - [sym_struct_statement] = STATE(20), - [sym_struct_extend_statement] = STATE(20), - [sym_if_statement] = STATE(20), - [sym_else_if_statement] = STATE(20), - [sym_else_statement] = STATE(20), - [sym_return_statement] = STATE(20), - [sym_error_return_statement] = STATE(20), - [sym_loop_statement] = STATE(20), - [sym_break_statement] = STATE(20), - [sym_continue_statement] = STATE(20), - [sym_match_statement] = STATE(20), - [sym_task_spawn_statement] = STATE(20), - [sym_task_join_statement] = STATE(20), - [sym_import_statement] = STATE(20), - [sym_export_statement] = STATE(20), - [sym_expression_statement] = STATE(20), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym__struct_field_list] = STATE(338), - [sym_field_initializer] = STATE(255), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(20), - [sym_ident] = ACTIONS(53), - [anon_sym_LF] = ACTIONS(55), - [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), - [sym_leader_dollar] = ACTIONS(11), - [sym_leader_hash] = ACTIONS(11), - [sym_leader_at] = ACTIONS(13), - [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), - [anon_sym_DOT] = ACTIONS(21), - [anon_sym_LBRACK] = ACTIONS(23), - [anon_sym_PERCENT] = ACTIONS(25), - [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(59), - [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), - }, - [STATE(4)] = { - [sym__item] = STATE(15), - [sym_bind_statement] = STATE(15), - [sym_struct_statement] = STATE(15), - [sym_struct_extend_statement] = STATE(15), - [sym_if_statement] = STATE(15), - [sym_else_if_statement] = STATE(15), - [sym_else_statement] = STATE(15), - [sym_return_statement] = STATE(15), - [sym_error_return_statement] = STATE(15), - [sym_loop_statement] = STATE(15), - [sym_break_statement] = STATE(15), - [sym_continue_statement] = STATE(15), - [sym_match_statement] = STATE(15), - [sym_task_spawn_statement] = STATE(15), - [sym_task_join_statement] = STATE(15), - [sym_import_statement] = STATE(15), - [sym_export_statement] = STATE(15), - [sym_expression_statement] = STATE(15), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym__struct_field_list] = STATE(338), - [sym_field_initializer] = STATE(255), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(15), - [sym_ident] = ACTIONS(53), - [anon_sym_LF] = ACTIONS(55), - [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), - [sym_leader_dollar] = ACTIONS(11), - [sym_leader_hash] = ACTIONS(11), - [sym_leader_at] = ACTIONS(13), - [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), - [anon_sym_DOT] = ACTIONS(21), - [anon_sym_LBRACK] = ACTIONS(23), - [anon_sym_PERCENT] = ACTIONS(25), - [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(61), - [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), - }, - [STATE(5)] = { [sym__item] = STATE(17), [sym_bind_statement] = STATE(17), [sym_struct_statement] = STATE(17), @@ -2604,353 +2769,371 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(17), [sym_task_spawn_statement] = STATE(17), [sym_task_join_statement] = STATE(17), + [sym_effect_block_statement] = STATE(17), [sym_import_statement] = STATE(17), [sym_export_statement] = STATE(17), [sym_expression_statement] = STATE(17), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym__struct_field_list] = STATE(338), - [sym_field_initializer] = STATE(255), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym__struct_field_list] = STATE(469), + [sym_field_initializer] = STATE(357), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(17), - [sym_ident] = ACTIONS(53), - [anon_sym_LF] = ACTIONS(55), + [sym_ident] = ACTIONS(59), + [anon_sym_LF] = ACTIONS(61), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(63), + [anon_sym_RBRACE] = ACTIONS(65), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(6)] = { - [sym__item] = STATE(21), - [sym_bind_statement] = STATE(21), - [sym_struct_statement] = STATE(21), - [sym_struct_extend_statement] = STATE(21), - [sym_if_statement] = STATE(21), - [sym_else_if_statement] = STATE(21), - [sym_else_statement] = STATE(21), - [sym_return_statement] = STATE(21), - [sym_error_return_statement] = STATE(21), - [sym_loop_statement] = STATE(21), - [sym_break_statement] = STATE(21), - [sym_continue_statement] = STATE(21), - [sym_match_statement] = STATE(21), - [sym_task_spawn_statement] = STATE(21), - [sym_task_join_statement] = STATE(21), - [sym_import_statement] = STATE(21), - [sym_export_statement] = STATE(21), - [sym_expression_statement] = STATE(21), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym__struct_field_list] = STATE(338), - [sym_field_initializer] = STATE(255), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(21), - [sym_ident] = ACTIONS(53), - [anon_sym_LF] = ACTIONS(55), + [STATE(4)] = { + [sym__item] = STATE(14), + [sym_bind_statement] = STATE(14), + [sym_struct_statement] = STATE(14), + [sym_struct_extend_statement] = STATE(14), + [sym_if_statement] = STATE(14), + [sym_else_if_statement] = STATE(14), + [sym_else_statement] = STATE(14), + [sym_return_statement] = STATE(14), + [sym_error_return_statement] = STATE(14), + [sym_loop_statement] = STATE(14), + [sym_break_statement] = STATE(14), + [sym_continue_statement] = STATE(14), + [sym_match_statement] = STATE(14), + [sym_task_spawn_statement] = STATE(14), + [sym_task_join_statement] = STATE(14), + [sym_effect_block_statement] = STATE(14), + [sym_import_statement] = STATE(14), + [sym_export_statement] = STATE(14), + [sym_expression_statement] = STATE(14), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym__struct_field_list] = STATE(459), + [sym_field_initializer] = STATE(357), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(14), + [sym_ident] = ACTIONS(59), + [anon_sym_LF] = ACTIONS(61), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(65), + [anon_sym_RBRACE] = ACTIONS(67), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(7)] = { - [sym__item] = STATE(32), - [sym_bind_statement] = STATE(32), - [sym_struct_statement] = STATE(32), - [sym_struct_extend_statement] = STATE(32), - [sym_if_statement] = STATE(32), - [sym_else_if_statement] = STATE(32), - [sym_else_statement] = STATE(32), - [sym_return_statement] = STATE(32), - [sym_error_return_statement] = STATE(32), - [sym_loop_statement] = STATE(32), - [sym_break_statement] = STATE(32), - [sym_continue_statement] = STATE(32), - [sym_match_statement] = STATE(32), - [sym_task_spawn_statement] = STATE(32), - [sym_task_join_statement] = STATE(32), - [sym_import_statement] = STATE(32), - [sym_export_statement] = STATE(32), - [sym_expression_statement] = STATE(32), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym__struct_field_list] = STATE(338), - [sym_field_initializer] = STATE(255), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(32), - [sym_ident] = ACTIONS(53), - [anon_sym_LF] = ACTIONS(55), + [STATE(5)] = { + [sym__item] = STATE(69), + [sym_bind_statement] = STATE(69), + [sym_struct_statement] = STATE(69), + [sym_struct_extend_statement] = STATE(69), + [sym_if_statement] = STATE(69), + [sym_else_if_statement] = STATE(69), + [sym_else_statement] = STATE(69), + [sym_return_statement] = STATE(69), + [sym_error_return_statement] = STATE(69), + [sym_loop_statement] = STATE(69), + [sym_break_statement] = STATE(69), + [sym_continue_statement] = STATE(69), + [sym_match_statement] = STATE(69), + [sym_task_spawn_statement] = STATE(69), + [sym_task_join_statement] = STATE(69), + [sym_effect_block_statement] = STATE(69), + [sym_import_statement] = STATE(69), + [sym_export_statement] = STATE(69), + [sym_expression_statement] = STATE(69), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym__struct_field_list] = STATE(469), + [sym_field_initializer] = STATE(357), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(69), + [sym_ident] = ACTIONS(59), + [anon_sym_LF] = ACTIONS(61), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(67), + [anon_sym_RBRACE] = ACTIONS(69), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(8)] = { - [sym__item] = STATE(8), - [sym_bind_statement] = STATE(8), - [sym_struct_statement] = STATE(8), - [sym_struct_extend_statement] = STATE(8), - [sym_if_statement] = STATE(8), - [sym_else_if_statement] = STATE(8), - [sym_else_statement] = STATE(8), - [sym_return_statement] = STATE(8), - [sym_error_return_statement] = STATE(8), - [sym_loop_statement] = STATE(8), - [sym_break_statement] = STATE(8), - [sym_continue_statement] = STATE(8), - [sym_match_statement] = STATE(8), - [sym_task_spawn_statement] = STATE(8), - [sym_task_join_statement] = STATE(8), - [sym_import_statement] = STATE(8), - [sym_export_statement] = STATE(8), - [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(8), - [ts_builtin_sym_end] = ACTIONS(69), - [sym_ident] = ACTIONS(71), - [anon_sym_LF] = ACTIONS(74), + [STATE(6)] = { + [sym__item] = STATE(18), + [sym_bind_statement] = STATE(18), + [sym_struct_statement] = STATE(18), + [sym_struct_extend_statement] = STATE(18), + [sym_if_statement] = STATE(18), + [sym_else_if_statement] = STATE(18), + [sym_else_statement] = STATE(18), + [sym_return_statement] = STATE(18), + [sym_error_return_statement] = STATE(18), + [sym_loop_statement] = STATE(18), + [sym_break_statement] = STATE(18), + [sym_continue_statement] = STATE(18), + [sym_match_statement] = STATE(18), + [sym_task_spawn_statement] = STATE(18), + [sym_task_join_statement] = STATE(18), + [sym_effect_block_statement] = STATE(18), + [sym_import_statement] = STATE(18), + [sym_export_statement] = STATE(18), + [sym_expression_statement] = STATE(18), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym__struct_field_list] = STATE(469), + [sym_field_initializer] = STATE(357), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(18), + [sym_ident] = ACTIONS(59), + [anon_sym_LF] = ACTIONS(61), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(77), - [sym_leader_dollar] = ACTIONS(77), - [sym_leader_hash] = ACTIONS(77), - [sym_leader_at] = ACTIONS(80), - [sym_leader_question] = ACTIONS(83), - [sym_leader_caret] = ACTIONS(86), - [sym_leader_backslash] = ACTIONS(89), - [anon_sym_DOT] = ACTIONS(92), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_PERCENT] = ACTIONS(98), - [anon_sym_LBRACE] = ACTIONS(101), - [anon_sym_RBRACE] = ACTIONS(69), - [anon_sym_COLON] = ACTIONS(104), - [anon_sym_BANG] = ACTIONS(107), - [anon_sym_STAR] = ACTIONS(110), - [anon_sym_LPAREN] = ACTIONS(113), - [anon_sym_LT] = ACTIONS(116), - [anon_sym_GT] = ACTIONS(119), - [sym_match_leader] = ACTIONS(122), - [anon_sym_PLUS] = ACTIONS(125), - [anon_sym_DASH] = ACTIONS(128), - [anon_sym_SLASH] = ACTIONS(131), - [sym_true_atom] = ACTIONS(134), - [sym_false_atom] = ACTIONS(134), - [sym_number] = ACTIONS(134), - [sym_duration] = ACTIONS(134), - [sym_string_pure] = ACTIONS(137), - [sym_string_rich] = ACTIONS(137), - [sym_bytes_pure] = ACTIONS(137), - [sym_bytes_rich] = ACTIONS(137), - [sym_locator_pure] = ACTIONS(137), - [sym_locator_rich] = ACTIONS(137), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(71), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(9)] = { - [sym__item] = STATE(8), - [sym_bind_statement] = STATE(8), - [sym_struct_statement] = STATE(8), - [sym_struct_extend_statement] = STATE(8), - [sym_if_statement] = STATE(8), - [sym_else_if_statement] = STATE(8), - [sym_else_statement] = STATE(8), - [sym_return_statement] = STATE(8), - [sym_error_return_statement] = STATE(8), - [sym_loop_statement] = STATE(8), - [sym_break_statement] = STATE(8), - [sym_continue_statement] = STATE(8), - [sym_match_statement] = STATE(8), - [sym_task_spawn_statement] = STATE(8), - [sym_task_join_statement] = STATE(8), - [sym_import_statement] = STATE(8), - [sym_export_statement] = STATE(8), - [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(8), - [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [STATE(7)] = { + [sym__item] = STATE(35), + [sym_bind_statement] = STATE(35), + [sym_struct_statement] = STATE(35), + [sym_struct_extend_statement] = STATE(35), + [sym_if_statement] = STATE(35), + [sym_else_if_statement] = STATE(35), + [sym_else_statement] = STATE(35), + [sym_return_statement] = STATE(35), + [sym_error_return_statement] = STATE(35), + [sym_loop_statement] = STATE(35), + [sym_break_statement] = STATE(35), + [sym_continue_statement] = STATE(35), + [sym_match_statement] = STATE(35), + [sym_task_spawn_statement] = STATE(35), + [sym_task_join_statement] = STATE(35), + [sym_effect_block_statement] = STATE(35), + [sym_import_statement] = STATE(35), + [sym_export_statement] = STATE(35), + [sym_expression_statement] = STATE(35), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym__struct_field_list] = STATE(469), + [sym_field_initializer] = STATE(357), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(35), + [sym_ident] = ACTIONS(59), + [anon_sym_LF] = ACTIONS(61), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(142), + [anon_sym_RBRACE] = ACTIONS(73), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(10)] = { + [STATE(8)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -2966,133 +3149,214 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), + [ts_builtin_sym_end] = ACTIONS(75), + [sym_ident] = ACTIONS(77), + [anon_sym_LF] = ACTIONS(80), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(83), + [sym_leader_hash] = ACTIONS(83), + [sym_leader_at] = ACTIONS(86), + [sym_leader_question] = ACTIONS(89), + [sym_leader_backslash] = ACTIONS(92), + [anon_sym_TILDE] = ACTIONS(95), + [anon_sym_DOT] = ACTIONS(98), + [anon_sym_LBRACK] = ACTIONS(101), + [anon_sym_PERCENT] = ACTIONS(104), + [anon_sym_LBRACE] = ACTIONS(107), + [anon_sym_RBRACE] = ACTIONS(75), + [anon_sym_COLON] = ACTIONS(110), + [anon_sym_CARET] = ACTIONS(113), + [anon_sym_BANG] = ACTIONS(116), + [anon_sym_STAR] = ACTIONS(119), + [anon_sym_LPAREN] = ACTIONS(122), + [anon_sym_LT] = ACTIONS(125), + [anon_sym_GT] = ACTIONS(128), + [sym_match_leader] = ACTIONS(131), + [anon_sym_PLUS] = ACTIONS(134), + [anon_sym_DASH] = ACTIONS(137), + [anon_sym_AMP] = ACTIONS(140), + [anon_sym_SLASH] = ACTIONS(143), + [anon_sym_PIPE] = ACTIONS(146), + [sym_false_atom] = ACTIONS(149), + [sym_number] = ACTIONS(149), + [sym_duration] = ACTIONS(149), + [sym_string_pure] = ACTIONS(152), + [sym_string_rich] = ACTIONS(152), + [sym_bytes_pure] = ACTIONS(152), + [sym_bytes_rich] = ACTIONS(152), + [sym_locator_pure] = ACTIONS(152), + [sym_locator_rich] = ACTIONS(152), + }, + [STATE(9)] = { + [sym__item] = STATE(64), + [sym_bind_statement] = STATE(64), + [sym_struct_statement] = STATE(64), + [sym_struct_extend_statement] = STATE(64), + [sym_if_statement] = STATE(64), + [sym_else_if_statement] = STATE(64), + [sym_else_statement] = STATE(64), + [sym_return_statement] = STATE(64), + [sym_error_return_statement] = STATE(64), + [sym_loop_statement] = STATE(64), + [sym_break_statement] = STATE(64), + [sym_continue_statement] = STATE(64), + [sym_match_statement] = STATE(64), + [sym_task_spawn_statement] = STATE(64), + [sym_task_join_statement] = STATE(64), + [sym_effect_block_statement] = STATE(64), + [sym_import_statement] = STATE(64), + [sym_export_statement] = STATE(64), + [sym_expression_statement] = STATE(64), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(64), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(155), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(144), + [anon_sym_RBRACE] = ACTIONS(157), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(11)] = { - [sym__item] = STATE(8), - [sym_bind_statement] = STATE(8), - [sym_struct_statement] = STATE(8), - [sym_struct_extend_statement] = STATE(8), - [sym_if_statement] = STATE(8), - [sym_else_if_statement] = STATE(8), - [sym_else_statement] = STATE(8), - [sym_return_statement] = STATE(8), - [sym_error_return_statement] = STATE(8), - [sym_loop_statement] = STATE(8), - [sym_break_statement] = STATE(8), - [sym_continue_statement] = STATE(8), - [sym_match_statement] = STATE(8), - [sym_task_spawn_statement] = STATE(8), - [sym_task_join_statement] = STATE(8), - [sym_import_statement] = STATE(8), - [sym_export_statement] = STATE(8), - [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(8), - [ts_builtin_sym_end] = ACTIONS(146), + [STATE(10)] = { + [sym__item] = STATE(21), + [sym_bind_statement] = STATE(21), + [sym_struct_statement] = STATE(21), + [sym_struct_extend_statement] = STATE(21), + [sym_if_statement] = STATE(21), + [sym_else_if_statement] = STATE(21), + [sym_else_statement] = STATE(21), + [sym_return_statement] = STATE(21), + [sym_error_return_statement] = STATE(21), + [sym_loop_statement] = STATE(21), + [sym_break_statement] = STATE(21), + [sym_continue_statement] = STATE(21), + [sym_match_statement] = STATE(21), + [sym_task_spawn_statement] = STATE(21), + [sym_task_join_statement] = STATE(21), + [sym_effect_block_statement] = STATE(21), + [sym_import_statement] = STATE(21), + [sym_export_statement] = STATE(21), + [sym_expression_statement] = STATE(21), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(21), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(159), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(161), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(12)] = { + [STATE(11)] = { [sym__item] = STATE(22), [sym_bind_statement] = STATE(22), [sym_struct_statement] = STATE(22), @@ -3108,133 +3372,139 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(22), [sym_task_spawn_statement] = STATE(22), [sym_task_join_statement] = STATE(22), + [sym_effect_block_statement] = STATE(22), [sym_import_statement] = STATE(22), [sym_export_statement] = STATE(22), [sym_expression_statement] = STATE(22), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(22), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(148), + [anon_sym_LF] = ACTIONS(163), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(150), + [anon_sym_RBRACE] = ACTIONS(165), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(13)] = { - [sym__item] = STATE(51), - [sym_bind_statement] = STATE(51), - [sym_struct_statement] = STATE(51), - [sym_struct_extend_statement] = STATE(51), - [sym_if_statement] = STATE(51), - [sym_else_if_statement] = STATE(51), - [sym_else_statement] = STATE(51), - [sym_return_statement] = STATE(51), - [sym_error_return_statement] = STATE(51), - [sym_loop_statement] = STATE(51), - [sym_break_statement] = STATE(51), - [sym_continue_statement] = STATE(51), - [sym_match_statement] = STATE(51), - [sym_task_spawn_statement] = STATE(51), - [sym_task_join_statement] = STATE(51), - [sym_import_statement] = STATE(51), - [sym_export_statement] = STATE(51), - [sym_expression_statement] = STATE(51), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(51), + [STATE(12)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(152), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(154), + [anon_sym_RBRACE] = ACTIONS(169), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(14)] = { + [STATE(13)] = { [sym__item] = STATE(23), [sym_bind_statement] = STATE(23), [sym_struct_statement] = STATE(23), @@ -3250,62 +3520,65 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(23), [sym_task_spawn_statement] = STATE(23), [sym_task_join_statement] = STATE(23), + [sym_effect_block_statement] = STATE(23), [sym_import_statement] = STATE(23), [sym_export_statement] = STATE(23), [sym_expression_statement] = STATE(23), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(23), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(156), + [anon_sym_LF] = ACTIONS(171), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(158), + [anon_sym_RBRACE] = ACTIONS(173), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(15)] = { + [STATE(14)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -3321,133 +3594,213 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(160), + [anon_sym_RBRACE] = ACTIONS(175), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(16)] = { - [sym__item] = STATE(9), - [sym_bind_statement] = STATE(9), - [sym_struct_statement] = STATE(9), - [sym_struct_extend_statement] = STATE(9), - [sym_if_statement] = STATE(9), - [sym_else_if_statement] = STATE(9), - [sym_else_statement] = STATE(9), - [sym_return_statement] = STATE(9), - [sym_error_return_statement] = STATE(9), - [sym_loop_statement] = STATE(9), - [sym_break_statement] = STATE(9), - [sym_continue_statement] = STATE(9), - [sym_match_statement] = STATE(9), - [sym_task_spawn_statement] = STATE(9), - [sym_task_join_statement] = STATE(9), - [sym_import_statement] = STATE(9), - [sym_export_statement] = STATE(9), - [sym_expression_statement] = STATE(9), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(9), + [STATE(15)] = { + [sym__item] = STATE(24), + [sym_bind_statement] = STATE(24), + [sym_struct_statement] = STATE(24), + [sym_struct_extend_statement] = STATE(24), + [sym_if_statement] = STATE(24), + [sym_else_if_statement] = STATE(24), + [sym_else_statement] = STATE(24), + [sym_return_statement] = STATE(24), + [sym_error_return_statement] = STATE(24), + [sym_loop_statement] = STATE(24), + [sym_break_statement] = STATE(24), + [sym_continue_statement] = STATE(24), + [sym_match_statement] = STATE(24), + [sym_task_spawn_statement] = STATE(24), + [sym_task_join_statement] = STATE(24), + [sym_effect_block_statement] = STATE(24), + [sym_import_statement] = STATE(24), + [sym_export_statement] = STATE(24), + [sym_expression_statement] = STATE(24), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(24), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(162), + [anon_sym_LF] = ACTIONS(177), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(164), + [anon_sym_RBRACE] = ACTIONS(179), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(17)] = { + [STATE(16)] = { + [sym__item] = STATE(25), + [sym_bind_statement] = STATE(25), + [sym_struct_statement] = STATE(25), + [sym_struct_extend_statement] = STATE(25), + [sym_if_statement] = STATE(25), + [sym_else_if_statement] = STATE(25), + [sym_else_statement] = STATE(25), + [sym_return_statement] = STATE(25), + [sym_error_return_statement] = STATE(25), + [sym_loop_statement] = STATE(25), + [sym_break_statement] = STATE(25), + [sym_continue_statement] = STATE(25), + [sym_match_statement] = STATE(25), + [sym_task_spawn_statement] = STATE(25), + [sym_task_join_statement] = STATE(25), + [sym_effect_block_statement] = STATE(25), + [sym_import_statement] = STATE(25), + [sym_export_statement] = STATE(25), + [sym_expression_statement] = STATE(25), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(25), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(181), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(183), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(17)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -3463,202 +3816,211 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(166), + [anon_sym_RBRACE] = ACTIONS(185), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(18)] = { - [sym__item] = STATE(24), - [sym_bind_statement] = STATE(24), - [sym_struct_statement] = STATE(24), - [sym_struct_extend_statement] = STATE(24), - [sym_if_statement] = STATE(24), - [sym_else_if_statement] = STATE(24), - [sym_else_statement] = STATE(24), - [sym_return_statement] = STATE(24), - [sym_error_return_statement] = STATE(24), - [sym_loop_statement] = STATE(24), - [sym_break_statement] = STATE(24), - [sym_continue_statement] = STATE(24), - [sym_match_statement] = STATE(24), - [sym_task_spawn_statement] = STATE(24), - [sym_task_join_statement] = STATE(24), - [sym_import_statement] = STATE(24), - [sym_export_statement] = STATE(24), - [sym_expression_statement] = STATE(24), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(24), + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(168), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(170), + [anon_sym_RBRACE] = ACTIONS(187), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(19)] = { - [sym__item] = STATE(25), - [sym_bind_statement] = STATE(25), - [sym_struct_statement] = STATE(25), - [sym_struct_extend_statement] = STATE(25), - [sym_if_statement] = STATE(25), - [sym_else_if_statement] = STATE(25), - [sym_else_statement] = STATE(25), - [sym_return_statement] = STATE(25), - [sym_error_return_statement] = STATE(25), - [sym_loop_statement] = STATE(25), - [sym_break_statement] = STATE(25), - [sym_continue_statement] = STATE(25), - [sym_match_statement] = STATE(25), - [sym_task_spawn_statement] = STATE(25), - [sym_task_join_statement] = STATE(25), - [sym_import_statement] = STATE(25), - [sym_export_statement] = STATE(25), - [sym_expression_statement] = STATE(25), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(25), + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(172), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(174), + [anon_sym_RBRACE] = ACTIONS(189), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(20)] = { [sym__item] = STATE(8), @@ -3676,60 +4038,63 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(176), + [anon_sym_RBRACE] = ACTIONS(191), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(21)] = { [sym__item] = STATE(8), @@ -3747,60 +4112,63 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(178), + [anon_sym_RBRACE] = ACTIONS(193), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(22)] = { [sym__item] = STATE(8), @@ -3818,60 +4186,63 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(180), + [anon_sym_RBRACE] = ACTIONS(195), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(23)] = { [sym__item] = STATE(8), @@ -3889,60 +4260,63 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(182), + [anon_sym_RBRACE] = ACTIONS(197), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(24)] = { [sym__item] = STATE(8), @@ -3960,60 +4334,63 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(184), + [anon_sym_RBRACE] = ACTIONS(199), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(25)] = { [sym__item] = STATE(8), @@ -4031,273 +4408,285 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(186), + [anon_sym_RBRACE] = ACTIONS(201), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(26)] = { - [sym__item] = STATE(29), - [sym_bind_statement] = STATE(29), - [sym_struct_statement] = STATE(29), - [sym_struct_extend_statement] = STATE(29), - [sym_if_statement] = STATE(29), - [sym_else_if_statement] = STATE(29), - [sym_else_statement] = STATE(29), - [sym_return_statement] = STATE(29), - [sym_error_return_statement] = STATE(29), - [sym_loop_statement] = STATE(29), - [sym_break_statement] = STATE(29), - [sym_continue_statement] = STATE(29), - [sym_match_statement] = STATE(29), - [sym_task_spawn_statement] = STATE(29), - [sym_task_join_statement] = STATE(29), - [sym_import_statement] = STATE(29), - [sym_export_statement] = STATE(29), - [sym_expression_statement] = STATE(29), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(29), + [sym__item] = STATE(32), + [sym_bind_statement] = STATE(32), + [sym_struct_statement] = STATE(32), + [sym_struct_extend_statement] = STATE(32), + [sym_if_statement] = STATE(32), + [sym_else_if_statement] = STATE(32), + [sym_else_statement] = STATE(32), + [sym_return_statement] = STATE(32), + [sym_error_return_statement] = STATE(32), + [sym_loop_statement] = STATE(32), + [sym_break_statement] = STATE(32), + [sym_continue_statement] = STATE(32), + [sym_match_statement] = STATE(32), + [sym_task_spawn_statement] = STATE(32), + [sym_task_join_statement] = STATE(32), + [sym_effect_block_statement] = STATE(32), + [sym_import_statement] = STATE(32), + [sym_export_statement] = STATE(32), + [sym_expression_statement] = STATE(32), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(32), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(188), + [anon_sym_LF] = ACTIONS(203), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(186), + [anon_sym_RBRACE] = ACTIONS(201), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(27)] = { - [sym__item] = STATE(34), - [sym_bind_statement] = STATE(34), - [sym_struct_statement] = STATE(34), - [sym_struct_extend_statement] = STATE(34), - [sym_if_statement] = STATE(34), - [sym_else_if_statement] = STATE(34), - [sym_else_statement] = STATE(34), - [sym_return_statement] = STATE(34), - [sym_error_return_statement] = STATE(34), - [sym_loop_statement] = STATE(34), - [sym_break_statement] = STATE(34), - [sym_continue_statement] = STATE(34), - [sym_match_statement] = STATE(34), - [sym_task_spawn_statement] = STATE(34), - [sym_task_join_statement] = STATE(34), - [sym_import_statement] = STATE(34), - [sym_export_statement] = STATE(34), - [sym_expression_statement] = STATE(34), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(34), + [sym__item] = STATE(19), + [sym_bind_statement] = STATE(19), + [sym_struct_statement] = STATE(19), + [sym_struct_extend_statement] = STATE(19), + [sym_if_statement] = STATE(19), + [sym_else_if_statement] = STATE(19), + [sym_else_statement] = STATE(19), + [sym_return_statement] = STATE(19), + [sym_error_return_statement] = STATE(19), + [sym_loop_statement] = STATE(19), + [sym_break_statement] = STATE(19), + [sym_continue_statement] = STATE(19), + [sym_match_statement] = STATE(19), + [sym_task_spawn_statement] = STATE(19), + [sym_task_join_statement] = STATE(19), + [sym_effect_block_statement] = STATE(19), + [sym_import_statement] = STATE(19), + [sym_export_statement] = STATE(19), + [sym_expression_statement] = STATE(19), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(19), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(190), + [anon_sym_LF] = ACTIONS(205), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(192), + [anon_sym_RBRACE] = ACTIONS(207), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(28)] = { - [sym__item] = STATE(35), - [sym_bind_statement] = STATE(35), - [sym_struct_statement] = STATE(35), - [sym_struct_extend_statement] = STATE(35), - [sym_if_statement] = STATE(35), - [sym_else_if_statement] = STATE(35), - [sym_else_statement] = STATE(35), - [sym_return_statement] = STATE(35), - [sym_error_return_statement] = STATE(35), - [sym_loop_statement] = STATE(35), - [sym_break_statement] = STATE(35), - [sym_continue_statement] = STATE(35), - [sym_match_statement] = STATE(35), - [sym_task_spawn_statement] = STATE(35), - [sym_task_join_statement] = STATE(35), - [sym_import_statement] = STATE(35), - [sym_export_statement] = STATE(35), - [sym_expression_statement] = STATE(35), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(35), + [sym__item] = STATE(36), + [sym_bind_statement] = STATE(36), + [sym_struct_statement] = STATE(36), + [sym_struct_extend_statement] = STATE(36), + [sym_if_statement] = STATE(36), + [sym_else_if_statement] = STATE(36), + [sym_else_statement] = STATE(36), + [sym_return_statement] = STATE(36), + [sym_error_return_statement] = STATE(36), + [sym_loop_statement] = STATE(36), + [sym_break_statement] = STATE(36), + [sym_continue_statement] = STATE(36), + [sym_match_statement] = STATE(36), + [sym_task_spawn_statement] = STATE(36), + [sym_task_join_statement] = STATE(36), + [sym_effect_block_statement] = STATE(36), + [sym_import_statement] = STATE(36), + [sym_export_statement] = STATE(36), + [sym_expression_statement] = STATE(36), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(36), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(194), + [anon_sym_LF] = ACTIONS(209), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(196), + [anon_sym_RBRACE] = ACTIONS(211), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(29)] = { [sym__item] = STATE(8), @@ -4315,202 +4704,211 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), + [ts_builtin_sym_end] = ACTIONS(213), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(196), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(30)] = { - [sym__item] = STATE(39), - [sym_bind_statement] = STATE(39), - [sym_struct_statement] = STATE(39), - [sym_struct_extend_statement] = STATE(39), - [sym_if_statement] = STATE(39), - [sym_else_if_statement] = STATE(39), - [sym_else_statement] = STATE(39), - [sym_return_statement] = STATE(39), - [sym_error_return_statement] = STATE(39), - [sym_loop_statement] = STATE(39), - [sym_break_statement] = STATE(39), - [sym_continue_statement] = STATE(39), - [sym_match_statement] = STATE(39), - [sym_task_spawn_statement] = STATE(39), - [sym_task_join_statement] = STATE(39), - [sym_import_statement] = STATE(39), - [sym_export_statement] = STATE(39), - [sym_expression_statement] = STATE(39), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(39), + [sym__item] = STATE(37), + [sym_bind_statement] = STATE(37), + [sym_struct_statement] = STATE(37), + [sym_struct_extend_statement] = STATE(37), + [sym_if_statement] = STATE(37), + [sym_else_if_statement] = STATE(37), + [sym_else_statement] = STATE(37), + [sym_return_statement] = STATE(37), + [sym_error_return_statement] = STATE(37), + [sym_loop_statement] = STATE(37), + [sym_break_statement] = STATE(37), + [sym_continue_statement] = STATE(37), + [sym_match_statement] = STATE(37), + [sym_task_spawn_statement] = STATE(37), + [sym_task_join_statement] = STATE(37), + [sym_effect_block_statement] = STATE(37), + [sym_import_statement] = STATE(37), + [sym_export_statement] = STATE(37), + [sym_expression_statement] = STATE(37), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(37), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(198), + [anon_sym_LF] = ACTIONS(215), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(200), + [anon_sym_RBRACE] = ACTIONS(217), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(31)] = { - [sym__item] = STATE(40), - [sym_bind_statement] = STATE(40), - [sym_struct_statement] = STATE(40), - [sym_struct_extend_statement] = STATE(40), - [sym_if_statement] = STATE(40), - [sym_else_if_statement] = STATE(40), - [sym_else_statement] = STATE(40), - [sym_return_statement] = STATE(40), - [sym_error_return_statement] = STATE(40), - [sym_loop_statement] = STATE(40), - [sym_break_statement] = STATE(40), - [sym_continue_statement] = STATE(40), - [sym_match_statement] = STATE(40), - [sym_task_spawn_statement] = STATE(40), - [sym_task_join_statement] = STATE(40), - [sym_import_statement] = STATE(40), - [sym_export_statement] = STATE(40), - [sym_expression_statement] = STATE(40), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(40), + [sym__item] = STATE(38), + [sym_bind_statement] = STATE(38), + [sym_struct_statement] = STATE(38), + [sym_struct_extend_statement] = STATE(38), + [sym_if_statement] = STATE(38), + [sym_else_if_statement] = STATE(38), + [sym_else_statement] = STATE(38), + [sym_return_statement] = STATE(38), + [sym_error_return_statement] = STATE(38), + [sym_loop_statement] = STATE(38), + [sym_break_statement] = STATE(38), + [sym_continue_statement] = STATE(38), + [sym_match_statement] = STATE(38), + [sym_task_spawn_statement] = STATE(38), + [sym_task_join_statement] = STATE(38), + [sym_effect_block_statement] = STATE(38), + [sym_import_statement] = STATE(38), + [sym_export_statement] = STATE(38), + [sym_expression_statement] = STATE(38), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(38), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(202), + [anon_sym_LF] = ACTIONS(219), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(204), + [anon_sym_RBRACE] = ACTIONS(221), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(32)] = { [sym__item] = STATE(8), @@ -4528,62 +4926,213 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(206), + [anon_sym_RBRACE] = ACTIONS(221), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, [STATE(33)] = { + [sym__item] = STATE(42), + [sym_bind_statement] = STATE(42), + [sym_struct_statement] = STATE(42), + [sym_struct_extend_statement] = STATE(42), + [sym_if_statement] = STATE(42), + [sym_else_if_statement] = STATE(42), + [sym_else_statement] = STATE(42), + [sym_return_statement] = STATE(42), + [sym_error_return_statement] = STATE(42), + [sym_loop_statement] = STATE(42), + [sym_break_statement] = STATE(42), + [sym_continue_statement] = STATE(42), + [sym_match_statement] = STATE(42), + [sym_task_spawn_statement] = STATE(42), + [sym_task_join_statement] = STATE(42), + [sym_effect_block_statement] = STATE(42), + [sym_import_statement] = STATE(42), + [sym_export_statement] = STATE(42), + [sym_expression_statement] = STATE(42), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(42), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(223), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(225), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(34)] = { + [sym__item] = STATE(43), + [sym_bind_statement] = STATE(43), + [sym_struct_statement] = STATE(43), + [sym_struct_extend_statement] = STATE(43), + [sym_if_statement] = STATE(43), + [sym_else_if_statement] = STATE(43), + [sym_else_statement] = STATE(43), + [sym_return_statement] = STATE(43), + [sym_error_return_statement] = STATE(43), + [sym_loop_statement] = STATE(43), + [sym_break_statement] = STATE(43), + [sym_continue_statement] = STATE(43), + [sym_match_statement] = STATE(43), + [sym_task_spawn_statement] = STATE(43), + [sym_task_join_statement] = STATE(43), + [sym_effect_block_statement] = STATE(43), + [sym_import_statement] = STATE(43), + [sym_export_statement] = STATE(43), + [sym_expression_statement] = STATE(43), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(43), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(227), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(229), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(35)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -4599,62 +5148,65 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(208), + [anon_sym_RBRACE] = ACTIONS(231), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(34)] = { + [STATE(36)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -4670,62 +5222,65 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(210), + [anon_sym_RBRACE] = ACTIONS(233), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(35)] = { + [STATE(37)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -4741,204 +5296,139 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(212), + [anon_sym_RBRACE] = ACTIONS(235), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(36)] = { - [sym__item] = STATE(42), - [sym_bind_statement] = STATE(42), - [sym_struct_statement] = STATE(42), - [sym_struct_extend_statement] = STATE(42), - [sym_if_statement] = STATE(42), - [sym_else_if_statement] = STATE(42), - [sym_else_statement] = STATE(42), - [sym_return_statement] = STATE(42), - [sym_error_return_statement] = STATE(42), - [sym_loop_statement] = STATE(42), - [sym_break_statement] = STATE(42), - [sym_continue_statement] = STATE(42), - [sym_match_statement] = STATE(42), - [sym_task_spawn_statement] = STATE(42), - [sym_task_join_statement] = STATE(42), - [sym_import_statement] = STATE(42), - [sym_export_statement] = STATE(42), - [sym_expression_statement] = STATE(42), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(42), + [STATE(38)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(214), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(212), + [anon_sym_RBRACE] = ACTIONS(237), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(37)] = { - [sym__item] = STATE(44), - [sym_bind_statement] = STATE(44), - [sym_struct_statement] = STATE(44), - [sym_struct_extend_statement] = STATE(44), - [sym_if_statement] = STATE(44), - [sym_else_if_statement] = STATE(44), - [sym_else_statement] = STATE(44), - [sym_return_statement] = STATE(44), - [sym_error_return_statement] = STATE(44), - [sym_loop_statement] = STATE(44), - [sym_break_statement] = STATE(44), - [sym_continue_statement] = STATE(44), - [sym_match_statement] = STATE(44), - [sym_task_spawn_statement] = STATE(44), - [sym_task_join_statement] = STATE(44), - [sym_import_statement] = STATE(44), - [sym_export_statement] = STATE(44), - [sym_expression_statement] = STATE(44), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(44), - [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(216), - [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), - [sym_leader_dollar] = ACTIONS(11), - [sym_leader_hash] = ACTIONS(11), - [sym_leader_at] = ACTIONS(13), - [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), - [anon_sym_DOT] = ACTIONS(21), - [anon_sym_LBRACK] = ACTIONS(23), - [anon_sym_PERCENT] = ACTIONS(25), - [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(218), - [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), - }, - [STATE(38)] = { + [STATE(39)] = { [sym__item] = STATE(45), [sym_bind_statement] = STATE(45), [sym_struct_statement] = STATE(45), @@ -4954,62 +5444,213 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(45), [sym_task_spawn_statement] = STATE(45), [sym_task_join_statement] = STATE(45), + [sym_effect_block_statement] = STATE(45), [sym_import_statement] = STATE(45), [sym_export_statement] = STATE(45), [sym_expression_statement] = STATE(45), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(45), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(220), + [anon_sym_LF] = ACTIONS(239), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(222), + [anon_sym_RBRACE] = ACTIONS(237), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(39)] = { + [STATE(40)] = { + [sym__item] = STATE(47), + [sym_bind_statement] = STATE(47), + [sym_struct_statement] = STATE(47), + [sym_struct_extend_statement] = STATE(47), + [sym_if_statement] = STATE(47), + [sym_else_if_statement] = STATE(47), + [sym_else_statement] = STATE(47), + [sym_return_statement] = STATE(47), + [sym_error_return_statement] = STATE(47), + [sym_loop_statement] = STATE(47), + [sym_break_statement] = STATE(47), + [sym_continue_statement] = STATE(47), + [sym_match_statement] = STATE(47), + [sym_task_spawn_statement] = STATE(47), + [sym_task_join_statement] = STATE(47), + [sym_effect_block_statement] = STATE(47), + [sym_import_statement] = STATE(47), + [sym_export_statement] = STATE(47), + [sym_expression_statement] = STATE(47), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(47), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(241), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(243), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(41)] = { + [sym__item] = STATE(48), + [sym_bind_statement] = STATE(48), + [sym_struct_statement] = STATE(48), + [sym_struct_extend_statement] = STATE(48), + [sym_if_statement] = STATE(48), + [sym_else_if_statement] = STATE(48), + [sym_else_statement] = STATE(48), + [sym_return_statement] = STATE(48), + [sym_error_return_statement] = STATE(48), + [sym_loop_statement] = STATE(48), + [sym_break_statement] = STATE(48), + [sym_continue_statement] = STATE(48), + [sym_match_statement] = STATE(48), + [sym_task_spawn_statement] = STATE(48), + [sym_task_join_statement] = STATE(48), + [sym_effect_block_statement] = STATE(48), + [sym_import_statement] = STATE(48), + [sym_export_statement] = STATE(48), + [sym_expression_statement] = STATE(48), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(48), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(245), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(247), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(42)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5025,62 +5666,65 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(224), + [anon_sym_RBRACE] = ACTIONS(249), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(40)] = { + [STATE(43)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5096,133 +5740,139 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(226), + [anon_sym_RBRACE] = ACTIONS(251), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(41)] = { - [sym__item] = STATE(46), - [sym_bind_statement] = STATE(46), - [sym_struct_statement] = STATE(46), - [sym_struct_extend_statement] = STATE(46), - [sym_if_statement] = STATE(46), - [sym_else_if_statement] = STATE(46), - [sym_else_statement] = STATE(46), - [sym_return_statement] = STATE(46), - [sym_error_return_statement] = STATE(46), - [sym_loop_statement] = STATE(46), - [sym_break_statement] = STATE(46), - [sym_continue_statement] = STATE(46), - [sym_match_statement] = STATE(46), - [sym_task_spawn_statement] = STATE(46), - [sym_task_join_statement] = STATE(46), - [sym_import_statement] = STATE(46), - [sym_export_statement] = STATE(46), - [sym_expression_statement] = STATE(46), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(46), + [STATE(44)] = { + [sym__item] = STATE(49), + [sym_bind_statement] = STATE(49), + [sym_struct_statement] = STATE(49), + [sym_struct_extend_statement] = STATE(49), + [sym_if_statement] = STATE(49), + [sym_else_if_statement] = STATE(49), + [sym_else_statement] = STATE(49), + [sym_return_statement] = STATE(49), + [sym_error_return_statement] = STATE(49), + [sym_loop_statement] = STATE(49), + [sym_break_statement] = STATE(49), + [sym_continue_statement] = STATE(49), + [sym_match_statement] = STATE(49), + [sym_task_spawn_statement] = STATE(49), + [sym_task_join_statement] = STATE(49), + [sym_effect_block_statement] = STATE(49), + [sym_import_statement] = STATE(49), + [sym_export_statement] = STATE(49), + [sym_expression_statement] = STATE(49), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(49), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(228), + [anon_sym_LF] = ACTIONS(253), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(230), + [anon_sym_RBRACE] = ACTIONS(255), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(42)] = { + [STATE(45)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5238,133 +5888,139 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(232), + [anon_sym_RBRACE] = ACTIONS(257), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(43)] = { - [sym__item] = STATE(47), - [sym_bind_statement] = STATE(47), - [sym_struct_statement] = STATE(47), - [sym_struct_extend_statement] = STATE(47), - [sym_if_statement] = STATE(47), - [sym_else_if_statement] = STATE(47), - [sym_else_statement] = STATE(47), - [sym_return_statement] = STATE(47), - [sym_error_return_statement] = STATE(47), - [sym_loop_statement] = STATE(47), - [sym_break_statement] = STATE(47), - [sym_continue_statement] = STATE(47), - [sym_match_statement] = STATE(47), - [sym_task_spawn_statement] = STATE(47), - [sym_task_join_statement] = STATE(47), - [sym_import_statement] = STATE(47), - [sym_export_statement] = STATE(47), - [sym_expression_statement] = STATE(47), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(47), + [STATE(46)] = { + [sym__item] = STATE(50), + [sym_bind_statement] = STATE(50), + [sym_struct_statement] = STATE(50), + [sym_struct_extend_statement] = STATE(50), + [sym_if_statement] = STATE(50), + [sym_else_if_statement] = STATE(50), + [sym_else_statement] = STATE(50), + [sym_return_statement] = STATE(50), + [sym_error_return_statement] = STATE(50), + [sym_loop_statement] = STATE(50), + [sym_break_statement] = STATE(50), + [sym_continue_statement] = STATE(50), + [sym_match_statement] = STATE(50), + [sym_task_spawn_statement] = STATE(50), + [sym_task_join_statement] = STATE(50), + [sym_effect_block_statement] = STATE(50), + [sym_import_statement] = STATE(50), + [sym_export_statement] = STATE(50), + [sym_expression_statement] = STATE(50), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(50), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(234), + [anon_sym_LF] = ACTIONS(259), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(232), + [anon_sym_RBRACE] = ACTIONS(257), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(44)] = { + [STATE(47)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5380,62 +6036,65 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(236), + [anon_sym_RBRACE] = ACTIONS(261), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(45)] = { + [STATE(48)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5451,62 +6110,65 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(238), + [anon_sym_RBRACE] = ACTIONS(263), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(46)] = { + [STATE(49)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5522,62 +6184,65 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(240), + [anon_sym_RBRACE] = ACTIONS(265), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(47)] = { + [STATE(50)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5593,133 +6258,139 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(242), + [anon_sym_RBRACE] = ACTIONS(267), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(48)] = { - [sym__item] = STATE(49), - [sym_bind_statement] = STATE(49), - [sym_struct_statement] = STATE(49), - [sym_struct_extend_statement] = STATE(49), - [sym_if_statement] = STATE(49), - [sym_else_if_statement] = STATE(49), - [sym_else_statement] = STATE(49), - [sym_return_statement] = STATE(49), - [sym_error_return_statement] = STATE(49), - [sym_loop_statement] = STATE(49), - [sym_break_statement] = STATE(49), - [sym_continue_statement] = STATE(49), - [sym_match_statement] = STATE(49), - [sym_task_spawn_statement] = STATE(49), - [sym_task_join_statement] = STATE(49), - [sym_import_statement] = STATE(49), - [sym_export_statement] = STATE(49), - [sym_expression_statement] = STATE(49), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(49), + [STATE(51)] = { + [sym__item] = STATE(52), + [sym_bind_statement] = STATE(52), + [sym_struct_statement] = STATE(52), + [sym_struct_extend_statement] = STATE(52), + [sym_if_statement] = STATE(52), + [sym_else_if_statement] = STATE(52), + [sym_else_statement] = STATE(52), + [sym_return_statement] = STATE(52), + [sym_error_return_statement] = STATE(52), + [sym_loop_statement] = STATE(52), + [sym_break_statement] = STATE(52), + [sym_continue_statement] = STATE(52), + [sym_match_statement] = STATE(52), + [sym_task_spawn_statement] = STATE(52), + [sym_task_join_statement] = STATE(52), + [sym_effect_block_statement] = STATE(52), + [sym_import_statement] = STATE(52), + [sym_export_statement] = STATE(52), + [sym_expression_statement] = STATE(52), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(52), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(244), + [anon_sym_LF] = ACTIONS(269), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(242), + [anon_sym_RBRACE] = ACTIONS(267), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(49)] = { + [STATE(52)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5735,133 +6406,139 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(246), + [anon_sym_RBRACE] = ACTIONS(271), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(50)] = { - [sym__item] = STATE(10), - [sym_bind_statement] = STATE(10), - [sym_struct_statement] = STATE(10), - [sym_struct_extend_statement] = STATE(10), - [sym_if_statement] = STATE(10), - [sym_else_if_statement] = STATE(10), - [sym_else_statement] = STATE(10), - [sym_return_statement] = STATE(10), - [sym_error_return_statement] = STATE(10), - [sym_loop_statement] = STATE(10), - [sym_break_statement] = STATE(10), - [sym_continue_statement] = STATE(10), - [sym_match_statement] = STATE(10), - [sym_task_spawn_statement] = STATE(10), - [sym_task_join_statement] = STATE(10), - [sym_import_statement] = STATE(10), - [sym_export_statement] = STATE(10), - [sym_expression_statement] = STATE(10), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [aux_sym_source_file_repeat1] = STATE(10), + [STATE(53)] = { + [sym__item] = STATE(54), + [sym_bind_statement] = STATE(54), + [sym_struct_statement] = STATE(54), + [sym_struct_extend_statement] = STATE(54), + [sym_if_statement] = STATE(54), + [sym_else_if_statement] = STATE(54), + [sym_else_statement] = STATE(54), + [sym_return_statement] = STATE(54), + [sym_error_return_statement] = STATE(54), + [sym_loop_statement] = STATE(54), + [sym_break_statement] = STATE(54), + [sym_continue_statement] = STATE(54), + [sym_match_statement] = STATE(54), + [sym_task_spawn_statement] = STATE(54), + [sym_task_join_statement] = STATE(54), + [sym_effect_block_statement] = STATE(54), + [sym_import_statement] = STATE(54), + [sym_export_statement] = STATE(54), + [sym_expression_statement] = STATE(54), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(54), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(248), + [anon_sym_LF] = ACTIONS(273), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(246), + [anon_sym_RBRACE] = ACTIONS(271), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, - [STATE(51)] = { + [STATE(54)] = { [sym__item] = STATE(8), [sym_bind_statement] = STATE(8), [sym_struct_statement] = STATE(8), @@ -5877,218 +6554,3937 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_match_statement] = STATE(8), [sym_task_spawn_statement] = STATE(8), [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), [sym_import_statement] = STATE(8), [sym_export_statement] = STATE(8), [sym_expression_statement] = STATE(8), - [sym__expression] = STATE(230), - [sym__expr_non_unary] = STATE(92), - [sym_receiver] = STATE(92), - [sym_self_field] = STATE(92), - [sym_unary_expression] = STATE(230), - [sym_binary_expression] = STATE(92), - [sym_range_expression] = STATE(92), - [sym_width_cast] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_field_expression] = STATE(76), - [sym_index_expression] = STATE(92), - [sym_list_expression] = STATE(92), - [sym_struct_literal] = STATE(92), - [sym_fn_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), [aux_sym_source_file_repeat1] = STATE(8), [sym_ident] = ACTIONS(7), - [anon_sym_LF] = ACTIONS(140), + [anon_sym_LF] = ACTIONS(167), [sym_comment] = ACTIONS(3), - [sym_leader_tilde] = ACTIONS(11), [sym_leader_dollar] = ACTIONS(11), [sym_leader_hash] = ACTIONS(11), [sym_leader_at] = ACTIONS(13), [sym_leader_question] = ACTIONS(15), - [sym_leader_caret] = ACTIONS(17), - [sym_leader_backslash] = ACTIONS(19), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), [anon_sym_DOT] = ACTIONS(21), [anon_sym_LBRACK] = ACTIONS(23), [anon_sym_PERCENT] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(250), + [anon_sym_RBRACE] = ACTIONS(275), [anon_sym_COLON] = ACTIONS(29), - [anon_sym_BANG] = ACTIONS(31), - [anon_sym_STAR] = ACTIONS(33), - [anon_sym_LPAREN] = ACTIONS(35), - [anon_sym_LT] = ACTIONS(37), - [anon_sym_GT] = ACTIONS(39), - [sym_match_leader] = ACTIONS(41), - [anon_sym_PLUS] = ACTIONS(43), - [anon_sym_DASH] = ACTIONS(45), - [anon_sym_SLASH] = ACTIONS(47), - [sym_true_atom] = ACTIONS(49), - [sym_false_atom] = ACTIONS(49), - [sym_number] = ACTIONS(49), - [sym_duration] = ACTIONS(49), - [sym_string_pure] = ACTIONS(51), - [sym_string_rich] = ACTIONS(51), - [sym_bytes_pure] = ACTIONS(51), - [sym_bytes_rich] = ACTIONS(51), - [sym_locator_pure] = ACTIONS(51), - [sym_locator_rich] = ACTIONS(51), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), }, -}; - -static const uint16_t ts_small_parse_table[] = { - [0] = 14, - ACTIONS(3), 1, - sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, - anon_sym_DOT, - ACTIONS(23), 1, - anon_sym_LBRACK, - ACTIONS(27), 1, - anon_sym_LBRACE, - ACTIONS(35), 1, - anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(104), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(258), 4, - sym_true_atom, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 6, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - ACTIONS(252), 16, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_PERCENT, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_GT, - sym_match_leader, - anon_sym_SLASH, - [80] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(264), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - sym_ident, - sym_number, - sym_duration, - ACTIONS(262), 36, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_RPAREN, - sym_match_leader, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - [135] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(268), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - sym_ident, - sym_number, - sym_duration, - ACTIONS(266), 36, + [STATE(55)] = { + [sym__item] = STATE(56), + [sym_bind_statement] = STATE(56), + [sym_struct_statement] = STATE(56), + [sym_struct_extend_statement] = STATE(56), + [sym_if_statement] = STATE(56), + [sym_else_if_statement] = STATE(56), + [sym_else_statement] = STATE(56), + [sym_return_statement] = STATE(56), + [sym_error_return_statement] = STATE(56), + [sym_loop_statement] = STATE(56), + [sym_break_statement] = STATE(56), + [sym_continue_statement] = STATE(56), + [sym_match_statement] = STATE(56), + [sym_task_spawn_statement] = STATE(56), + [sym_task_join_statement] = STATE(56), + [sym_effect_block_statement] = STATE(56), + [sym_import_statement] = STATE(56), + [sym_export_statement] = STATE(56), + [sym_expression_statement] = STATE(56), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(56), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(277), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(279), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(56)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(167), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(281), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(57)] = { + [sym__item] = STATE(59), + [sym_bind_statement] = STATE(59), + [sym_struct_statement] = STATE(59), + [sym_struct_extend_statement] = STATE(59), + [sym_if_statement] = STATE(59), + [sym_else_if_statement] = STATE(59), + [sym_else_statement] = STATE(59), + [sym_return_statement] = STATE(59), + [sym_error_return_statement] = STATE(59), + [sym_loop_statement] = STATE(59), + [sym_break_statement] = STATE(59), + [sym_continue_statement] = STATE(59), + [sym_match_statement] = STATE(59), + [sym_task_spawn_statement] = STATE(59), + [sym_task_join_statement] = STATE(59), + [sym_effect_block_statement] = STATE(59), + [sym_import_statement] = STATE(59), + [sym_export_statement] = STATE(59), + [sym_expression_statement] = STATE(59), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(59), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(283), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(281), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(58)] = { + [sym__item] = STATE(60), + [sym_bind_statement] = STATE(60), + [sym_struct_statement] = STATE(60), + [sym_struct_extend_statement] = STATE(60), + [sym_if_statement] = STATE(60), + [sym_else_if_statement] = STATE(60), + [sym_else_statement] = STATE(60), + [sym_return_statement] = STATE(60), + [sym_error_return_statement] = STATE(60), + [sym_loop_statement] = STATE(60), + [sym_break_statement] = STATE(60), + [sym_continue_statement] = STATE(60), + [sym_match_statement] = STATE(60), + [sym_task_spawn_statement] = STATE(60), + [sym_task_join_statement] = STATE(60), + [sym_effect_block_statement] = STATE(60), + [sym_import_statement] = STATE(60), + [sym_export_statement] = STATE(60), + [sym_expression_statement] = STATE(60), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(60), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(285), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(287), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(59)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(167), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(287), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(60)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(167), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(289), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(61)] = { + [sym__item] = STATE(62), + [sym_bind_statement] = STATE(62), + [sym_struct_statement] = STATE(62), + [sym_struct_extend_statement] = STATE(62), + [sym_if_statement] = STATE(62), + [sym_else_if_statement] = STATE(62), + [sym_else_statement] = STATE(62), + [sym_return_statement] = STATE(62), + [sym_error_return_statement] = STATE(62), + [sym_loop_statement] = STATE(62), + [sym_break_statement] = STATE(62), + [sym_continue_statement] = STATE(62), + [sym_match_statement] = STATE(62), + [sym_task_spawn_statement] = STATE(62), + [sym_task_join_statement] = STATE(62), + [sym_effect_block_statement] = STATE(62), + [sym_import_statement] = STATE(62), + [sym_export_statement] = STATE(62), + [sym_expression_statement] = STATE(62), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(62), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(291), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(289), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(62)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(167), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(157), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(63)] = { + [sym__item] = STATE(20), + [sym_bind_statement] = STATE(20), + [sym_struct_statement] = STATE(20), + [sym_struct_extend_statement] = STATE(20), + [sym_if_statement] = STATE(20), + [sym_else_if_statement] = STATE(20), + [sym_else_statement] = STATE(20), + [sym_return_statement] = STATE(20), + [sym_error_return_statement] = STATE(20), + [sym_loop_statement] = STATE(20), + [sym_break_statement] = STATE(20), + [sym_continue_statement] = STATE(20), + [sym_match_statement] = STATE(20), + [sym_task_spawn_statement] = STATE(20), + [sym_task_join_statement] = STATE(20), + [sym_effect_block_statement] = STATE(20), + [sym_import_statement] = STATE(20), + [sym_export_statement] = STATE(20), + [sym_expression_statement] = STATE(20), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(20), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(293), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(295), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(64)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(167), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(297), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(65)] = { + [sym__item] = STATE(66), + [sym_bind_statement] = STATE(66), + [sym_struct_statement] = STATE(66), + [sym_struct_extend_statement] = STATE(66), + [sym_if_statement] = STATE(66), + [sym_else_if_statement] = STATE(66), + [sym_else_statement] = STATE(66), + [sym_return_statement] = STATE(66), + [sym_error_return_statement] = STATE(66), + [sym_loop_statement] = STATE(66), + [sym_break_statement] = STATE(66), + [sym_continue_statement] = STATE(66), + [sym_match_statement] = STATE(66), + [sym_task_spawn_statement] = STATE(66), + [sym_task_join_statement] = STATE(66), + [sym_effect_block_statement] = STATE(66), + [sym_import_statement] = STATE(66), + [sym_export_statement] = STATE(66), + [sym_expression_statement] = STATE(66), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(66), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(299), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(297), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(66)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(167), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(301), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(67)] = { + [sym__item] = STATE(68), + [sym_bind_statement] = STATE(68), + [sym_struct_statement] = STATE(68), + [sym_struct_extend_statement] = STATE(68), + [sym_if_statement] = STATE(68), + [sym_else_if_statement] = STATE(68), + [sym_else_statement] = STATE(68), + [sym_return_statement] = STATE(68), + [sym_error_return_statement] = STATE(68), + [sym_loop_statement] = STATE(68), + [sym_break_statement] = STATE(68), + [sym_continue_statement] = STATE(68), + [sym_match_statement] = STATE(68), + [sym_task_spawn_statement] = STATE(68), + [sym_task_join_statement] = STATE(68), + [sym_effect_block_statement] = STATE(68), + [sym_import_statement] = STATE(68), + [sym_export_statement] = STATE(68), + [sym_expression_statement] = STATE(68), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(68), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(303), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(301), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(68)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(167), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(305), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, + [STATE(69)] = { + [sym__item] = STATE(8), + [sym_bind_statement] = STATE(8), + [sym_struct_statement] = STATE(8), + [sym_struct_extend_statement] = STATE(8), + [sym_if_statement] = STATE(8), + [sym_else_if_statement] = STATE(8), + [sym_else_statement] = STATE(8), + [sym_return_statement] = STATE(8), + [sym_error_return_statement] = STATE(8), + [sym_loop_statement] = STATE(8), + [sym_break_statement] = STATE(8), + [sym_continue_statement] = STATE(8), + [sym_match_statement] = STATE(8), + [sym_task_spawn_statement] = STATE(8), + [sym_task_join_statement] = STATE(8), + [sym_effect_block_statement] = STATE(8), + [sym_import_statement] = STATE(8), + [sym_export_statement] = STATE(8), + [sym_expression_statement] = STATE(8), + [sym__expression] = STATE(322), + [sym__expr_non_unary] = STATE(122), + [sym_receiver] = STATE(122), + [sym_self_field] = STATE(122), + [sym_true_atom] = STATE(122), + [sym_unary_expression] = STATE(322), + [sym_binary_expression] = STATE(122), + [sym_range_expression] = STATE(122), + [sym_width_cast] = STATE(122), + [sym_call_expression] = STATE(122), + [sym_field_expression] = STATE(93), + [sym_index_expression] = STATE(122), + [sym_list_expression] = STATE(122), + [sym_struct_literal] = STATE(122), + [sym_fn_expression] = STATE(122), + [sym_parenthesized_expression] = STATE(122), + [aux_sym_source_file_repeat1] = STATE(8), + [sym_ident] = ACTIONS(7), + [anon_sym_LF] = ACTIONS(167), + [sym_comment] = ACTIONS(3), + [sym_leader_dollar] = ACTIONS(11), + [sym_leader_hash] = ACTIONS(11), + [sym_leader_at] = ACTIONS(13), + [sym_leader_question] = ACTIONS(15), + [sym_leader_backslash] = ACTIONS(17), + [anon_sym_TILDE] = ACTIONS(19), + [anon_sym_DOT] = ACTIONS(21), + [anon_sym_LBRACK] = ACTIONS(23), + [anon_sym_PERCENT] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(307), + [anon_sym_COLON] = ACTIONS(29), + [anon_sym_CARET] = ACTIONS(31), + [anon_sym_BANG] = ACTIONS(33), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_LT] = ACTIONS(39), + [anon_sym_GT] = ACTIONS(41), + [sym_match_leader] = ACTIONS(43), + [anon_sym_PLUS] = ACTIONS(45), + [anon_sym_DASH] = ACTIONS(47), + [anon_sym_AMP] = ACTIONS(49), + [anon_sym_SLASH] = ACTIONS(51), + [anon_sym_PIPE] = ACTIONS(53), + [sym_false_atom] = ACTIONS(55), + [sym_number] = ACTIONS(55), + [sym_duration] = ACTIONS(55), + [sym_string_pure] = ACTIONS(57), + [sym_string_rich] = ACTIONS(57), + [sym_bytes_pure] = ACTIONS(57), + [sym_bytes_rich] = ACTIONS(57), + [sym_locator_pure] = ACTIONS(57), + [sym_locator_rich] = ACTIONS(57), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(7), 1, + sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, + ACTIONS(23), 1, + anon_sym_LBRACK, + ACTIONS(27), 1, + anon_sym_LBRACE, + ACTIONS(37), 1, + anon_sym_LPAREN, + ACTIONS(53), 1, + anon_sym_PIPE, + ACTIONS(313), 1, + anon_sym_LT, + STATE(93), 1, + sym_field_expression, + STATE(124), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(317), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + ACTIONS(309), 16, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_PERCENT, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_GT, + sym_match_leader, + anon_sym_AMP, + anon_sym_SLASH, + [84] = 8, + ACTIONS(3), 1, + sym_comment, + ACTIONS(323), 1, + anon_sym_DOT, + ACTIONS(325), 1, + anon_sym_LBRACK, + STATE(137), 1, + aux_sym_bind_lhs_repeat2, + ACTIONS(329), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(327), 9, + anon_sym_DOT_DOT, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(321), 10, + anon_sym_EQ, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(319), 26, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [152] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(335), 1, + anon_sym_DOT, + STATE(136), 1, + aux_sym_bind_lhs_repeat1, + ACTIONS(347), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(342), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + ACTIONS(333), 6, + anon_sym_EQ, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(339), 8, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + ACTIONS(345), 9, + anon_sym_DOT_DOT, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(331), 19, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + sym_match_leader, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [222] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(351), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(349), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [278] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(353), 1, + anon_sym_EQ, + ACTIONS(355), 1, + anon_sym_LBRACE, + ACTIONS(329), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(327), 34, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [338] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(359), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(357), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [394] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(363), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(361), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [450] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(367), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(365), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [506] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(371), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(369), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [562] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(375), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [618] = 10, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(375), 7, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_PIPE, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 24, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [688] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(375), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 28, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [752] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(393), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(391), 29, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [814] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(375), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 33, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [872] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(375), 8, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 24, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [940] = 11, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(395), 1, + anon_sym_CARET, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(375), 7, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_PIPE, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 23, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1012] = 13, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(395), 1, + anon_sym_CARET, + ACTIONS(397), 1, + anon_sym_PIPE, + ACTIONS(399), 1, + anon_sym_AMP_AMP, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(375), 6, + anon_sym_DOT, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 22, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_PIPE_PIPE, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1088] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(395), 1, + anon_sym_CARET, + ACTIONS(397), 1, + anon_sym_PIPE, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(375), 6, + anon_sym_DOT, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 23, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1162] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(375), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(373), 31, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1222] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(403), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(401), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1278] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(407), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(405), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1334] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(395), 1, + anon_sym_CARET, + ACTIONS(397), 1, + anon_sym_PIPE, + ACTIONS(399), 1, + anon_sym_AMP_AMP, + ACTIONS(413), 1, + anon_sym_PIPE_PIPE, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(411), 6, + anon_sym_DOT, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(409), 21, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + sym_match_leader, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1412] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(417), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(415), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1468] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(355), 1, + anon_sym_LBRACE, + ACTIONS(329), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(327), 35, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1526] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(421), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(419), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1582] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(425), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(423), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1638] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(429), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(427), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1694] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(433), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(431), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1750] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(437), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(435), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1806] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(441), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(439), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1862] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(445), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(443), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1918] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(449), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(447), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [1974] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(347), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(345), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2030] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(453), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(451), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2086] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(457), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(455), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2142] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(461), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(459), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2198] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(465), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(463), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2254] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(469), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(467), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2310] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(473), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(471), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2366] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(477), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(475), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2422] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(481), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(479), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2478] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(485), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(483), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2534] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(491), 1, + anon_sym_DOT, + ACTIONS(493), 1, + anon_sym_LBRACK, + ACTIONS(495), 1, + anon_sym_LPAREN, + ACTIONS(489), 11, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(487), 34, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2596] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(499), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(497), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2652] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(503), 1, + sym_ident, + ACTIONS(505), 11, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_number, + sym_duration, + ACTIONS(501), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2710] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(355), 1, + anon_sym_LBRACE, + ACTIONS(507), 1, + anon_sym_EQ, + ACTIONS(329), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(327), 34, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2770] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(511), 12, + anon_sym_DOT, + anon_sym_BANG, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + sym_false_atom, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + sym_ident, + sym_number, + sym_duration, + ACTIONS(509), 36, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2826] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(395), 1, + anon_sym_CARET, + ACTIONS(397), 1, + anon_sym_PIPE, + ACTIONS(399), 1, + anon_sym_AMP_AMP, + ACTIONS(413), 1, + anon_sym_PIPE_PIPE, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(515), 6, + anon_sym_DOT, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(513), 20, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + sym_match_leader, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2903] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(395), 1, + anon_sym_CARET, + ACTIONS(397), 1, + anon_sym_PIPE, + ACTIONS(399), 1, + anon_sym_AMP_AMP, + ACTIONS(413), 1, + anon_sym_PIPE_PIPE, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(519), 6, + anon_sym_DOT, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(517), 20, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + sym_match_leader, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [2980] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(523), 5, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(461), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(521), 17, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, + anon_sym_RBRACE, + anon_sym_COLON, + sym_match_leader, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + ACTIONS(459), 18, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, - sym_match_leader, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -6099,47 +10495,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - [190] = 3, + anon_sym_LT_LT, + anon_sym_GT_GT, + [3039] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(272), 11, + ACTIONS(461), 12, anon_sym_DOT, anon_sym_BANG, anon_sym_LT, anon_sym_GT, - sym_true_atom, + anon_sym_AMP, + anon_sym_PIPE, sym_false_atom, anon_sym_EQ_EQ, anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(270), 36, + ACTIONS(459), 35, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, sym_match_leader, anon_sym_DOT_DOT, anon_sym_PLUS, @@ -6151,47 +10541,47 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [245] = 3, + [3094] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(276), 11, + ACTIONS(461), 12, anon_sym_DOT, anon_sym_BANG, anon_sym_LT, anon_sym_GT, - sym_true_atom, + anon_sym_AMP, + anon_sym_PIPE, sym_false_atom, anon_sym_EQ_EQ, anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(274), 36, + ACTIONS(459), 35, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, sym_match_leader, anon_sym_DOT_DOT, anon_sym_PLUS, @@ -6203,48 +10593,94 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [300] = 3, + [3149] = 8, ACTIONS(3), 1, sym_comment, - ACTIONS(280), 11, + ACTIONS(491), 1, anon_sym_DOT, + ACTIONS(493), 1, + anon_sym_LBRACK, + ACTIONS(495), 1, + anon_sym_LPAREN, + ACTIONS(527), 5, anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(278), 36, + ACTIONS(489), 6, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(487), 15, + anon_sym_PERCENT, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(525), 18, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_PERCENT, + anon_sym_TILDE, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + sym_match_leader, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [3214] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(531), 5, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(461), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(459), 17, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, - sym_match_leader, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -6255,48 +10691,111 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(529), 18, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + sym_match_leader, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [355] = 3, + [3273] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(284), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(381), 1, + anon_sym_DOT_DOT, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(395), 1, + anon_sym_CARET, + ACTIONS(397), 1, + anon_sym_PIPE, + ACTIONS(399), 1, + anon_sym_AMP_AMP, + ACTIONS(413), 1, + anon_sym_PIPE_PIPE, + ACTIONS(383), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(379), 4, anon_sym_LT, anon_sym_GT, - sym_true_atom, - sym_false_atom, anon_sym_EQ_EQ, anon_sym_BANG_EQ, + ACTIONS(387), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(535), 6, + anon_sym_DOT, + anon_sym_BANG, + sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(282), 36, + ACTIONS(533), 20, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, - anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, sym_match_leader, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [3350] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(499), 6, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(539), 6, + anon_sym_DOT, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(497), 15, + anon_sym_PERCENT, + anon_sym_CARET, + anon_sym_STAR, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -6307,47 +10806,62 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(537), 20, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + sym_match_leader, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [410] = 3, + [3409] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(288), 11, + ACTIONS(461), 12, anon_sym_DOT, anon_sym_BANG, anon_sym_LT, anon_sym_GT, - sym_true_atom, + anon_sym_AMP, + anon_sym_PIPE, sym_false_atom, anon_sym_EQ_EQ, anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(286), 36, + ACTIONS(459), 35, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, sym_match_leader, anon_sym_DOT_DOT, anon_sym_PLUS, @@ -6359,51 +10873,141 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [465] = 6, + [3464] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(294), 1, + ACTIONS(499), 6, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(543), 6, anon_sym_DOT, - ACTIONS(296), 1, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(497), 15, + anon_sym_PERCENT, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(541), 20, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, anon_sym_LBRACK, - ACTIONS(298), 1, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, anon_sym_LPAREN, - ACTIONS(292), 10, + sym_match_leader, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [3523] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(461), 12, + anon_sym_DOT, anon_sym_BANG, anon_sym_LT, anon_sym_GT, - sym_true_atom, + anon_sym_AMP, + anon_sym_PIPE, sym_false_atom, anon_sym_EQ_EQ, anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(290), 34, + ACTIONS(459), 35, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, - anon_sym_RBRACK, + anon_sym_TILDE, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + sym_match_leader, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + [3578] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(499), 6, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(547), 6, + anon_sym_DOT, + anon_sym_BANG, + sym_false_atom, + sym_ident, + sym_number, + sym_duration, + ACTIONS(497), 15, anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + anon_sym_CARET, anon_sym_STAR, - anon_sym_RPAREN, - sym_match_leader, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -6414,47 +11018,63 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(545), 20, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_LBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + sym_match_leader, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [526] = 3, + [3637] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(302), 11, + ACTIONS(355), 1, + anon_sym_LBRACE, + ACTIONS(549), 1, + anon_sym_COLON, + ACTIONS(329), 12, anon_sym_DOT, anon_sym_BANG, anon_sym_LT, anon_sym_GT, - sym_true_atom, + anon_sym_AMP, + anon_sym_PIPE, sym_false_atom, anon_sym_EQ_EQ, anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(300), 36, - ts_builtin_sym_end, + ACTIONS(327), 32, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, - anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_COLON, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, sym_match_leader, anon_sym_DOT_DOT, anon_sym_PLUS, @@ -6466,2346 +11086,2689 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [581] = 3, + [3695] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(306), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(555), 1, + anon_sym_COMMA, + STATE(131), 1, + aux_sym_export_statement_repeat1, + ACTIONS(553), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(304), 36, + ACTIONS(551), 33, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [636] = 3, + [3747] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(310), 11, + ACTIONS(558), 1, anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + STATE(136), 1, + aux_sym_bind_lhs_repeat1, + ACTIONS(333), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(308), 36, + ACTIONS(331), 32, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_EQ, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [691] = 3, + [3798] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(314), 11, + ACTIONS(564), 1, anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(567), 1, + anon_sym_LBRACK, + STATE(133), 1, + aux_sym_bind_lhs_repeat2, + ACTIONS(562), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(312), 36, + ACTIONS(560), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, + anon_sym_EQ, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [746] = 3, + [3851] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(318), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(553), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(316), 36, + ACTIONS(551), 34, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_DOT, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [801] = 3, + [3898] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(322), 11, + ACTIONS(574), 1, anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + STATE(135), 1, + aux_sym_bind_lhs_repeat1, + ACTIONS(572), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(320), 36, + ACTIONS(570), 32, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_EQ, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [856] = 3, + [3949] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(326), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + STATE(135), 1, + aux_sym_bind_lhs_repeat1, + ACTIONS(579), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(324), 36, + ACTIONS(577), 33, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_EQ, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [911] = 3, + [3998] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(330), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + STATE(133), 1, + aux_sym_bind_lhs_repeat2, + ACTIONS(583), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(328), 36, + ACTIONS(581), 33, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_EQ, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [966] = 3, + [4047] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(334), 11, + ACTIONS(325), 1, + anon_sym_LBRACK, + ACTIONS(585), 1, anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + STATE(137), 1, + aux_sym_bind_lhs_repeat2, + ACTIONS(321), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(332), 36, + ACTIONS(319), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, + anon_sym_EQ, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1021] = 3, + [4100] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(338), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(591), 1, + anon_sym_COMMA, + STATE(145), 1, + aux_sym_bind_statement_repeat1, + ACTIONS(589), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(336), 36, + ACTIONS(587), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1076] = 3, + [4150] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(342), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(595), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(340), 36, + ACTIONS(593), 33, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_EQ, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - [1131] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(346), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + sym_locator_pure, + sym_locator_rich, + [4196] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(601), 1, + anon_sym_COMMA, + STATE(141), 1, + aux_sym_bind_statement_repeat1, + ACTIONS(599), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(344), 36, + ACTIONS(597), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1186] = 3, + [4246] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(350), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(608), 1, + anon_sym_COMMA, + STATE(131), 1, + aux_sym_export_statement_repeat1, + ACTIONS(606), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(348), 36, + ACTIONS(604), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1241] = 3, + [4296] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(354), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(612), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(352), 36, + ACTIONS(610), 33, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_EQ, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1296] = 3, + [4342] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(358), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(616), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(356), 36, + ACTIONS(614), 33, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_EQ, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1351] = 4, + [4388] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(364), 1, - anon_sym_LBRACE, - ACTIONS(362), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(591), 1, + anon_sym_COMMA, + STATE(141), 1, + aux_sym_bind_statement_repeat1, + ACTIONS(620), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(360), 35, + ACTIONS(618), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1408] = 3, + [4438] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(368), 11, + ACTIONS(622), 1, + sym_ident, + ACTIONS(626), 1, anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(636), 1, + anon_sym_PIPE, + STATE(139), 1, + sym_bind_clause, + STATE(155), 1, + sym_bind_lhs, + STATE(277), 1, + sym_field_expression, + STATE(281), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - sym_ident, sym_number, sym_duration, - ACTIONS(366), 36, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [4510] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(644), 1, + anon_sym_LF, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(648), 1, anon_sym_RBRACK, - anon_sym_PERCENT, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [4582] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, - anon_sym_RPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(650), 1, + anon_sym_LF, + ACTIONS(652), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [4654] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(654), 1, + anon_sym_LF, + ACTIONS(656), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(301), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1463] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [4726] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(372), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(370), 36, - ts_builtin_sym_end, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(658), 1, anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, + ACTIONS(660), 1, anon_sym_RBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_RPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1518] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [4798] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(376), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(374), 36, - ts_builtin_sym_end, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(662), 1, anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, + ACTIONS(664), 1, anon_sym_RBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_RPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1573] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [4870] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(380), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(378), 36, - ts_builtin_sym_end, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(666), 1, anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, + ACTIONS(668), 1, anon_sym_RBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_RPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1628] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [4942] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(384), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(382), 36, - ts_builtin_sym_end, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(670), 1, anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, + ACTIONS(672), 1, anon_sym_RBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_RPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1683] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5014] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(388), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(608), 1, + anon_sym_COMMA, + STATE(142), 1, + aux_sym_export_statement_repeat1, + ACTIONS(676), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(386), 36, + ACTIONS(674), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1738] = 5, + [5064] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(364), 1, - anon_sym_LBRACE, - ACTIONS(390), 1, + ACTIONS(682), 1, anon_sym_EQ, - ACTIONS(362), 11, - anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(680), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(360), 32, + ACTIONS(678), 32, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1795] = 8, + [5112] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(402), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(396), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(398), 4, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(404), 4, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(394), 7, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, + ACTIONS(684), 1, + anon_sym_LF, + ACTIONS(686), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(297), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5184] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(690), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(392), 24, + ACTIONS(688), 33, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_COMMA, + anon_sym_EQ, + anon_sym_DOT, anon_sym_LBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, + anon_sym_STAR, anon_sym_LPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1858] = 10, + [5230] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(410), 1, - anon_sym_PIPE_PIPE, - ACTIONS(412), 1, - anon_sym_AMP_AMP, - ACTIONS(402), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(396), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(398), 4, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(404), 4, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(408), 7, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - anon_sym_BANG, - sym_true_atom, + ACTIONS(692), 1, + anon_sym_RPAREN, + STATE(277), 1, + sym_field_expression, + STATE(307), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - sym_ident, sym_number, sym_duration, - ACTIONS(406), 22, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5299] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, anon_sym_LBRACK, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + ACTIONS(632), 1, anon_sym_LPAREN, - sym_match_leader, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(694), 1, + sym_ident, + ACTIONS(696), 1, + anon_sym_RPAREN, + STATE(277), 1, + sym_field_expression, + STATE(319), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1925] = 5, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5368] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(364), 1, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(414), 1, - anon_sym_EQ, - ACTIONS(362), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(698), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(314), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(360), 32, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [1982] = 9, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5437] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(412), 1, - anon_sym_AMP_AMP, - ACTIONS(402), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(396), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(398), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(404), 4, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(394), 7, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - anon_sym_BANG, - sym_true_atom, + ACTIONS(648), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(306), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - sym_ident, sym_number, sym_duration, - ACTIONS(392), 23, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_LPAREN, - sym_match_leader, - anon_sym_PIPE_PIPE, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2047] = 4, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5506] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(394), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(648), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(392), 33, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - sym_match_leader, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2102] = 4, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5575] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(418), 1, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, - ACTIONS(420), 10, + ACTIONS(646), 1, anon_sym_DOT, - anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, - sym_true_atom, + ACTIONS(664), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_number, sym_duration, - ACTIONS(416), 34, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2157] = 6, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5644] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(402), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(396), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(394), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(700), 1, + anon_sym_LF, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(392), 28, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_LPAREN, - sym_match_leader, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2216] = 5, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5713] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(396), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(394), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(638), 1, + sym_duration, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(702), 1, sym_ident, + ACTIONS(704), 1, + anon_sym_LBRACE, + STATE(277), 1, + sym_field_expression, + STATE(421), 1, + sym__loop_header_expr, + ACTIONS(706), 2, + sym_false_atom, sym_number, - sym_duration, - ACTIONS(392), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, + ACTIONS(708), 2, + sym_string_pure, + sym_string_rich, + STATE(323), 2, + sym__expression, + sym_unary_expression, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 4, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(299), 5, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_range_expression, + sym_parenthesized_expression, + STATE(271), 8, + sym__expr_non_unary, + sym_binary_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + [5788] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, anon_sym_LBRACK, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + ACTIONS(632), 1, anon_sym_LPAREN, - sym_match_leader, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(710), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(306), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2273] = 8, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5857] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(294), 1, - anon_sym_DOT, - ACTIONS(296), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(298), 1, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(292), 4, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(424), 6, - anon_sym_BANG, - sym_true_atom, - sym_false_atom, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(712), 1, sym_ident, + ACTIONS(714), 1, + anon_sym_RPAREN, + STATE(277), 1, + sym_field_expression, + STATE(317), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(290), 12, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(422), 19, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - sym_match_leader, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2335] = 5, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [5926] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(322), 4, - anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(428), 7, - anon_sym_DOT, - anon_sym_BANG, - sym_true_atom, + ACTIONS(599), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(320), 12, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(426), 21, + ACTIONS(597), 32, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, + anon_sym_COMMA, + anon_sym_DOT, anon_sym_LBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, + anon_sym_STAR, anon_sym_LPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2391] = 5, + [5971] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(342), 5, - anon_sym_DOT, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(432), 6, - anon_sym_BANG, - sym_true_atom, - sym_false_atom, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(638), 1, + sym_duration, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(716), 1, sym_ident, + STATE(277), 1, + sym_field_expression, + STATE(447), 1, + sym__loop_header_expr, + ACTIONS(706), 2, + sym_false_atom, sym_number, - sym_duration, - ACTIONS(340), 15, + ACTIONS(708), 2, + sym_string_pure, + sym_string_rich, + STATE(323), 2, + sym__expression, + sym_unary_expression, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 4, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(299), 5, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_range_expression, + sym_parenthesized_expression, + STATE(271), 8, + sym__expr_non_unary, + sym_binary_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + [6046] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, - anon_sym_DOT_DOT, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(718), 1, + anon_sym_RPAREN, + STATE(277), 1, + sym_field_expression, + STATE(304), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(430), 18, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_RBRACE, - anon_sym_COLON, - sym_match_leader, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2447] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6115] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(342), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(652), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(340), 33, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2499] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6184] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(342), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(720), 1, + anon_sym_RPAREN, + STATE(277), 1, + sym_field_expression, + STATE(309), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(340), 33, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2551] = 10, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6253] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(410), 1, - anon_sym_PIPE_PIPE, - ACTIONS(412), 1, - anon_sym_AMP_AMP, - ACTIONS(402), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(396), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(398), 4, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(404), 4, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(436), 7, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - anon_sym_BANG, - sym_true_atom, + ACTIONS(660), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - sym_ident, sym_number, sym_duration, - ACTIONS(434), 21, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_LPAREN, - sym_match_leader, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2617] = 5, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6322] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(322), 4, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(440), 7, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - anon_sym_BANG, - sym_true_atom, + ACTIONS(652), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(306), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - sym_ident, sym_number, sym_duration, - ACTIONS(320), 12, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(438), 21, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_LPAREN, - sym_match_leader, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2673] = 5, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6391] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(342), 5, - anon_sym_DOT, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(444), 6, - anon_sym_BANG, - sym_true_atom, - sym_false_atom, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(672), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(340), 14, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(442), 19, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - sym_match_leader, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2729] = 10, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6460] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(410), 1, - anon_sym_PIPE_PIPE, - ACTIONS(412), 1, - anon_sym_AMP_AMP, - ACTIONS(402), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(396), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(398), 4, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(404), 4, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(448), 7, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - anon_sym_BANG, - sym_true_atom, + ACTIONS(672), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(306), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - sym_ident, sym_number, sym_duration, - ACTIONS(446), 21, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_LPAREN, - sym_match_leader, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2795] = 5, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6529] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(322), 4, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(452), 7, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - anon_sym_BANG, - sym_true_atom, + ACTIONS(668), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(306), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - sym_ident, sym_number, sym_duration, - ACTIONS(320), 12, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(450), 21, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_LPAREN, - sym_match_leader, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2851] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6598] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(342), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(668), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(305), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(340), 33, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2903] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6667] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(342), 11, - anon_sym_DOT, - anon_sym_BANG, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_true_atom, - sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + ACTIONS(722), 1, + anon_sym_RBRACK, + STATE(277), 1, + sym_field_expression, + STATE(306), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(340), 33, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_LPAREN, - sym_match_leader, - anon_sym_DOT_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [2955] = 10, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6736] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, - anon_sym_DOT_DOT, - ACTIONS(410), 1, - anon_sym_PIPE_PIPE, - ACTIONS(412), 1, - anon_sym_AMP_AMP, - ACTIONS(402), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(396), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(398), 4, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(404), 4, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(456), 7, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - anon_sym_BANG, - sym_true_atom, + ACTIONS(724), 1, + anon_sym_RPAREN, + STATE(277), 1, + sym_field_expression, + STATE(308), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - sym_ident, sym_number, sym_duration, - ACTIONS(454), 21, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_LBRACK, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_LPAREN, - sym_match_leader, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3021] = 5, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6805] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(364), 1, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(458), 1, - anon_sym_COLON, - ACTIONS(362), 11, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(292), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, - anon_sym_LT, - anon_sym_GT, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [6871] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(728), 5, + anon_sym_PIPE, sym_false_atom, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, sym_ident, sym_number, sym_duration, - ACTIONS(360), 30, + ACTIONS(726), 31, + ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, + anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, + anon_sym_LT, + anon_sym_GT, sym_match_leader, - anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3076] = 5, + [6915] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(464), 1, - anon_sym_COMMA, - STATE(106), 1, - aux_sym_export_statement_repeat1, - ACTIONS(462), 5, - sym_true_atom, + ACTIONS(732), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(460), 32, + ACTIONS(730), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, anon_sym_LT, anon_sym_GT, sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -8813,35 +13776,83 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3127] = 4, + [6959] = 14, ACTIONS(3), 1, sym_comment, - STATE(111), 1, - aux_sym_bind_lhs_repeat2, - ACTIONS(469), 5, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(281), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7025] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(736), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(467), 32, + ACTIONS(734), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -8850,6 +13861,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -8857,35 +13869,135 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3175] = 4, + [7069] = 14, ACTIONS(3), 1, sym_comment, - STATE(113), 1, - aux_sym_bind_lhs_repeat1, - ACTIONS(473), 5, + ACTIONS(7), 1, + sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, + ACTIONS(23), 1, + anon_sym_LBRACK, + ACTIONS(27), 1, + anon_sym_LBRACE, + ACTIONS(37), 1, + anon_sym_LPAREN, + ACTIONS(313), 1, + anon_sym_LT, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, + sym_field_expression, + STATE(84), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(317), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7135] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(7), 1, + sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, + ACTIONS(23), 1, + anon_sym_LBRACK, + ACTIONS(27), 1, + anon_sym_LBRACE, + ACTIONS(37), 1, + anon_sym_LPAREN, + ACTIONS(313), 1, + anon_sym_LT, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, + sym_field_expression, + STATE(85), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(317), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7201] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(742), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(471), 32, + ACTIONS(740), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -8894,6 +14006,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -8901,37 +14014,187 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3223] = 6, + [7245] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(7), 1, + sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, + ACTIONS(23), 1, + anon_sym_LBRACK, + ACTIONS(37), 1, + anon_sym_LPAREN, + ACTIONS(313), 1, + anon_sym_LT, + ACTIONS(738), 1, + anon_sym_PIPE, + ACTIONS(744), 1, + anon_sym_LBRACE, + STATE(93), 1, + sym_field_expression, + STATE(118), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(317), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7311] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(310), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7377] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(320), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7443] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(479), 1, - anon_sym_DOT, - ACTIONS(481), 1, - anon_sym_LBRACK, - STATE(107), 1, - aux_sym_bind_lhs_repeat2, - ACTIONS(477), 5, - sym_true_atom, + ACTIONS(748), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(475), 30, + ACTIONS(746), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, + anon_sym_TILDE, + anon_sym_DOT, + anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -8940,6 +14203,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -8947,82 +14211,85 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3275] = 5, + [7487] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(487), 1, - anon_sym_DOT, - STATE(108), 1, - aux_sym_bind_lhs_repeat1, - ACTIONS(485), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(7), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(483), 31, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, + ACTIONS(21), 1, + anon_sym_DOT, + ACTIONS(23), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(27), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(37), 1, anon_sym_LPAREN, + ACTIONS(313), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, + sym_field_expression, + STATE(86), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3325] = 6, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7553] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(493), 1, - anon_sym_DOT, - ACTIONS(496), 1, - anon_sym_LBRACK, - STATE(111), 1, - aux_sym_bind_lhs_repeat2, - ACTIONS(491), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(750), 1, sym_ident, + STATE(344), 1, + sym_field_initializer, + ACTIONS(755), 4, + anon_sym_PIPE, + sym_false_atom, sym_number, sym_duration, - ACTIONS(489), 30, - ts_builtin_sym_end, + ACTIONS(753), 30, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, + anon_sym_TILDE, + anon_sym_DOT, + anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9031,6 +14298,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9038,42 +14306,40 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3377] = 3, + [7601] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(462), 5, - sym_true_atom, + ACTIONS(759), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(460), 33, + ACTIONS(757), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, - anon_sym_RBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, - anon_sym_RPAREN, anon_sym_LT, anon_sym_GT, sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9081,78 +14347,83 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3423] = 5, + [7645] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(503), 1, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - STATE(113), 1, - aux_sym_bind_lhs_repeat1, - ACTIONS(501), 5, - sym_true_atom, + STATE(277), 1, + sym_field_expression, + STATE(306), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, - sym_ident, sym_number, sym_duration, - ACTIONS(499), 31, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_LT, - anon_sym_GT, - sym_match_leader, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3473] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7711] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(508), 5, - sym_true_atom, + ACTIONS(763), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(506), 32, + ACTIONS(761), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9161,6 +14432,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9168,123 +14440,187 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3518] = 5, + [7755] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(514), 1, - anon_sym_COMMA, - STATE(115), 1, - aux_sym_bind_statement_repeat1, - ACTIONS(512), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(7), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(510), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, + ACTIONS(21), 1, anon_sym_DOT, + ACTIONS(23), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(27), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(37), 1, anon_sym_LPAREN, + ACTIONS(313), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, + sym_field_expression, + STATE(87), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3567] = 5, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7821] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, - anon_sym_COMMA, - STATE(106), 1, - aux_sym_export_statement_repeat1, - ACTIONS(519), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(7), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(517), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, + ACTIONS(21), 1, anon_sym_DOT, + ACTIONS(23), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(27), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + ACTIONS(37), 1, + anon_sym_LPAREN, + ACTIONS(313), 1, + anon_sym_LT, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, + sym_field_expression, + STATE(88), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, - anon_sym_STAR, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(317), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7887] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(298), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3616] = 5, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [7953] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, - anon_sym_COMMA, - STATE(116), 1, - aux_sym_export_statement_repeat1, - ACTIONS(525), 5, - sym_true_atom, + ACTIONS(767), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(523), 30, + ACTIONS(765), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9293,6 +14629,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9300,35 +14637,32 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3665] = 5, + [7997] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(531), 1, - anon_sym_COMMA, - STATE(119), 1, - aux_sym_bind_statement_repeat1, - ACTIONS(529), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(771), 1, sym_ident, + ACTIONS(773), 4, + anon_sym_PIPE, + sym_false_atom, sym_number, sym_duration, - ACTIONS(527), 30, + ACTIONS(769), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9337,6 +14671,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9344,35 +14679,31 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3714] = 5, + [8043] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(531), 1, - anon_sym_COMMA, - STATE(115), 1, - aux_sym_bind_statement_repeat1, - ACTIONS(535), 5, - sym_true_atom, + ACTIONS(777), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(533), 30, + ACTIONS(775), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9381,6 +14712,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9388,34 +14720,31 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3763] = 4, + [8087] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(541), 1, - anon_sym_EQ, - ACTIONS(539), 5, - sym_true_atom, + ACTIONS(781), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(537), 31, + ACTIONS(779), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9424,6 +14753,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9431,33 +14761,31 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3810] = 3, + [8131] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(545), 5, - sym_true_atom, + ACTIONS(785), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(543), 32, + ACTIONS(783), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9466,6 +14794,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9473,74 +14802,83 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3855] = 3, + [8175] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(549), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(7), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(547), 32, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_COMMA, - anon_sym_EQ, + ACTIONS(21), 1, anon_sym_DOT, + ACTIONS(23), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(27), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(37), 1, anon_sym_LPAREN, + ACTIONS(313), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, + sym_field_expression, + STATE(81), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3900] = 3, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [8241] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(512), 5, - sym_true_atom, + ACTIONS(789), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(510), 31, + ACTIONS(787), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, - anon_sym_COMMA, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9549,6 +14887,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9556,50 +14895,49 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [3944] = 15, + [8285] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(551), 1, - anon_sym_LF, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_RBRACK, - ACTIONS(559), 1, + ACTIONS(634), 1, anon_sym_LT, - STATE(76), 1, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, sym_field_expression, - STATE(216), 2, + STATE(313), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -9609,156 +14947,131 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [4012] = 15, + [8351] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, + ACTIONS(793), 5, + anon_sym_PIPE, + sym_false_atom, sym_ident, - ACTIONS(23), 1, + sym_number, + sym_duration, + ACTIONS(791), 31, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, anon_sym_LT, - ACTIONS(561), 1, - anon_sym_LF, - ACTIONS(563), 1, - anon_sym_RBRACK, - STATE(76), 1, - sym_field_expression, - STATE(216), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_GT, + sym_match_leader, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + anon_sym_AMP, + anon_sym_SLASH, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [4080] = 15, + [8395] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, + ACTIONS(797), 5, + anon_sym_PIPE, + sym_false_atom, sym_ident, - ACTIONS(23), 1, + sym_number, + sym_duration, + ACTIONS(795), 31, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, + anon_sym_DOT, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, anon_sym_LT, - ACTIONS(565), 1, - anon_sym_LF, - ACTIONS(567), 1, - anon_sym_RBRACK, - STATE(76), 1, - sym_field_expression, - STATE(209), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_GT, + sym_match_leader, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + anon_sym_AMP, + anon_sym_SLASH, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [4148] = 15, + [8439] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(634), 1, anon_sym_LT, - ACTIONS(569), 1, - anon_sym_LF, - ACTIONS(571), 1, - anon_sym_RBRACK, - STATE(76), 1, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, sym_field_expression, - STATE(216), 2, + STATE(321), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -9768,31 +15081,31 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [4216] = 3, + [8505] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(575), 5, - sym_true_atom, + ACTIONS(801), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(573), 30, + ACTIONS(799), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -9801,6 +15114,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -9808,168 +15122,205 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4259] = 3, + [8549] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(579), 5, - sym_true_atom, - sym_false_atom, - sym_ident, - sym_number, - sym_duration, - ACTIONS(577), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(311), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4302] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [8615] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(583), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(7), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(581), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, + ACTIONS(21), 1, anon_sym_DOT, + ACTIONS(23), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(27), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(37), 1, anon_sym_LPAREN, + ACTIONS(313), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, + sym_field_expression, + STATE(82), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4345] = 3, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [8681] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(587), 5, - sym_true_atom, - sym_false_atom, - sym_ident, - sym_number, - sym_duration, - ACTIONS(585), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, + ACTIONS(21), 1, anon_sym_DOT, + ACTIONS(23), 1, anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(37), 1, anon_sym_LPAREN, + ACTIONS(313), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(738), 1, + anon_sym_PIPE, + ACTIONS(803), 1, + sym_ident, + ACTIONS(805), 1, + anon_sym_LBRACE, + STATE(93), 1, + sym_field_expression, + STATE(129), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4388] = 14, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [8747] = 14, ACTIONS(3), 1, sym_comment, ACTIONS(7), 1, sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, ACTIONS(23), 1, anon_sym_LBRACK, ACTIONS(27), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(37), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_RBRACK, - ACTIONS(559), 1, + ACTIONS(313), 1, anon_sym_LT, - STATE(76), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, sym_field_expression, - STATE(216), 2, + STATE(113), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(315), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(112), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -9979,48 +15330,49 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [4453] = 14, + [8813] = 14, ACTIONS(3), 1, sym_comment, ACTIONS(7), 1, sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, ACTIONS(23), 1, anon_sym_LBRACK, ACTIONS(27), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(37), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_RBRACK, - ACTIONS(559), 1, + ACTIONS(313), 1, anon_sym_LT, - STATE(76), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, sym_field_expression, - STATE(215), 2, + STATE(91), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(315), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(112), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -10030,31 +15382,31 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [4518] = 3, + [8879] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(591), 5, - sym_true_atom, + ACTIONS(809), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(589), 30, + ACTIONS(807), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -10063,6 +15415,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -10070,208 +15423,361 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4561] = 3, + [8923] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(595), 5, - sym_true_atom, - sym_false_atom, - sym_ident, - sym_number, - sym_duration, - ACTIONS(593), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(283), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4604] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [8989] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(599), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(284), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(597), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9055] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(285), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4647] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9121] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(603), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(286), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, sym_number, sym_duration, - ACTIONS(601), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(640), 6, + sym_string_pure, + sym_string_rich, + sym_bytes_pure, + sym_bytes_rich, + sym_locator_pure, + sym_locator_rich, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9187] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(254), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4690] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9253] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(607), 5, - sym_true_atom, - sym_false_atom, - sym_ident, - sym_number, - sym_duration, - ACTIONS(605), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(288), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4733] = 14, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9319] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(634), 1, anon_sym_LT, - ACTIONS(609), 1, - anon_sym_RPAREN, - STATE(76), 1, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, sym_field_expression, - STATE(214), 2, + STATE(289), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -10281,208 +15787,257 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [4798] = 3, + [9385] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(613), 5, - sym_true_atom, - sym_false_atom, - sym_ident, - sym_number, - sym_duration, - ACTIONS(611), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(290), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4841] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9451] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(617), 5, - sym_true_atom, - sym_false_atom, - sym_ident, - sym_number, - sym_duration, - ACTIONS(615), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(291), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4884] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9517] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(621), 5, - sym_true_atom, - sym_false_atom, + ACTIONS(7), 1, sym_ident, - sym_number, - sym_duration, - ACTIONS(619), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, + ACTIONS(21), 1, anon_sym_DOT, + ACTIONS(23), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(27), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(37), 1, anon_sym_LPAREN, + ACTIONS(313), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, + sym_field_expression, + STATE(79), 2, + sym__expression, + sym_unary_expression, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4927] = 3, + STATE(112), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9583] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(625), 5, - sym_true_atom, - sym_false_atom, - sym_ident, - sym_number, - sym_duration, - ACTIONS(623), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, + ACTIONS(628), 1, anon_sym_LBRACK, - anon_sym_PERCENT, + ACTIONS(630), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, + ACTIONS(632), 1, anon_sym_LPAREN, + ACTIONS(634), 1, anon_sym_LT, - anon_sym_GT, - sym_match_leader, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(256), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(624), 4, + anon_sym_TILDE, + anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [4970] = 14, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [9649] = 14, ACTIONS(3), 1, sym_comment, ACTIONS(7), 1, sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, ACTIONS(23), 1, anon_sym_LBRACK, ACTIONS(27), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(37), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(313), 1, anon_sym_LT, - ACTIONS(627), 1, - anon_sym_RPAREN, - STATE(76), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, sym_field_expression, - STATE(213), 2, + STATE(95), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(315), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(112), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -10492,48 +16047,49 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [5035] = 14, + [9715] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, - anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(553), 1, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - ACTIONS(563), 1, - anon_sym_RBRACK, - STATE(76), 1, + ACTIONS(811), 1, + anon_sym_LBRACE, + STATE(277), 1, sym_field_expression, - STATE(216), 2, + STATE(315), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -10543,48 +16099,49 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [5100] = 14, + [9781] = 14, ACTIONS(3), 1, sym_comment, ACTIONS(7), 1, sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, ACTIONS(23), 1, anon_sym_LBRACK, ACTIONS(27), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(37), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(313), 1, anon_sym_LT, - ACTIONS(629), 1, - anon_sym_LF, - STATE(76), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, sym_field_expression, - STATE(216), 2, + STATE(83), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(315), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(112), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -10594,31 +16151,31 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [5165] = 3, + [9847] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(633), 5, - sym_true_atom, + ACTIONS(815), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(631), 30, + ACTIONS(813), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -10627,6 +16184,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -10634,31 +16192,31 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [5208] = 3, + [9891] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(637), 5, - sym_true_atom, + ACTIONS(819), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(635), 30, + ACTIONS(817), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -10667,6 +16225,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -10674,82 +16233,31 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [5251] = 14, - ACTIONS(3), 1, - sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, - anon_sym_LBRACK, - ACTIONS(27), 1, - anon_sym_LBRACE, - ACTIONS(35), 1, - anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - ACTIONS(571), 1, - anon_sym_RBRACK, - STATE(76), 1, - sym_field_expression, - STATE(216), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [5316] = 3, + [9935] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(641), 5, - sym_true_atom, + ACTIONS(823), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(639), 30, + ACTIONS(821), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -10758,6 +16266,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -10765,142 +16274,101 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [5359] = 17, + [9979] = 14, ACTIONS(3), 1, sym_comment, + ACTIONS(7), 1, + sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, ACTIONS(23), 1, anon_sym_LBRACK, - ACTIONS(35), 1, + ACTIONS(27), 1, + anon_sym_LBRACE, + ACTIONS(37), 1, anon_sym_LPAREN, - ACTIONS(258), 1, - sym_duration, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(313), 1, anon_sym_LT, - ACTIONS(643), 1, - sym_ident, - ACTIONS(645), 1, - anon_sym_LBRACE, - STATE(76), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, sym_field_expression, - STATE(301), 1, - sym__loop_header_expr, - ACTIONS(649), 2, - sym_false_atom, - sym_number, - STATE(231), 2, + STATE(125), 2, sym__expression, sym_unary_expression, - ACTIONS(557), 3, + ACTIONS(315), 3, + sym_false_atom, + sym_number, + sym_duration, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(647), 3, - sym_true_atom, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, - ACTIONS(260), 4, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(210), 4, + STATE(112), 13, + sym__expr_non_unary, sym_receiver, sym_self_field, - sym_range_expression, - sym_parenthesized_expression, - STATE(60), 8, - sym__expr_non_unary, + sym_true_atom, sym_binary_expression, + sym_range_expression, sym_width_cast, sym_call_expression, sym_index_expression, sym_list_expression, sym_struct_literal, sym_fn_expression, - [5430] = 3, + sym_parenthesized_expression, + [10045] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(653), 5, - sym_true_atom, - sym_false_atom, - sym_ident, - sym_number, - sym_duration, - ACTIONS(651), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, + ACTIONS(21), 1, anon_sym_DOT, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_LT, - anon_sym_GT, - sym_match_leader, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_SLASH, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - [5473] = 14, - ACTIONS(3), 1, - sym_comment, ACTIONS(23), 1, anon_sym_LBRACK, - ACTIONS(27), 1, - anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(37), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(313), 1, anon_sym_LT, - ACTIONS(655), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + ACTIONS(825), 1, sym_ident, - ACTIONS(657), 1, - anon_sym_RPAREN, - STATE(76), 1, + ACTIONS(827), 1, + anon_sym_LBRACE, + STATE(93), 1, sym_field_expression, - STATE(222), 2, + STATE(127), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(315), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(112), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -10910,90 +16378,49 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [5538] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(659), 1, - sym_ident, - STATE(248), 1, - sym_field_initializer, - ACTIONS(664), 4, - sym_true_atom, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(662), 29, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, - anon_sym_BANG, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_LT, - anon_sym_GT, - sym_match_leader, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_SLASH, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - [5585] = 14, + [10111] = 14, ACTIONS(3), 1, sym_comment, ACTIONS(7), 1, sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, ACTIONS(23), 1, anon_sym_LBRACK, - ACTIONS(27), 1, - anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(37), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(313), 1, anon_sym_LT, - ACTIONS(666), 1, - anon_sym_RBRACK, - STATE(76), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + ACTIONS(829), 1, + anon_sym_LBRACE, + STATE(93), 1, sym_field_expression, - STATE(215), 2, + STATE(117), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(315), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(112), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -11003,31 +16430,31 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [5650] = 3, + [10177] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(670), 5, - sym_true_atom, + ACTIONS(833), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(668), 30, + ACTIONS(831), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -11036,6 +16463,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -11043,72 +16471,83 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [5693] = 4, + [10221] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(674), 1, + ACTIONS(628), 1, + anon_sym_LBRACK, + ACTIONS(630), 1, + anon_sym_LBRACE, + ACTIONS(632), 1, + anon_sym_LPAREN, + ACTIONS(634), 1, + anon_sym_LT, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, sym_ident, - ACTIONS(676), 4, - sym_true_atom, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, + sym_field_expression, + STATE(317), 2, + sym__expression, + sym_unary_expression, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(672), 30, - ts_builtin_sym_end, - anon_sym_LF, - sym_leader_tilde, - sym_leader_dollar, - sym_leader_hash, - sym_leader_at, - sym_leader_question, - sym_leader_caret, - sym_leader_backslash, - anon_sym_DOT, - anon_sym_LBRACK, - anon_sym_PERCENT, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COLON, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, - anon_sym_STAR, - anon_sym_LPAREN, - anon_sym_LT, - anon_sym_GT, - sym_match_leader, anon_sym_PLUS, anon_sym_DASH, - anon_sym_SLASH, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [5738] = 3, + STATE(271), 13, + sym__expr_non_unary, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_binary_expression, + sym_range_expression, + sym_width_cast, + sym_call_expression, + sym_index_expression, + sym_list_expression, + sym_struct_literal, + sym_fn_expression, + sym_parenthesized_expression, + [10287] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(680), 5, - sym_true_atom, + ACTIONS(837), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(678), 30, + ACTIONS(835), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -11117,92 +16556,39 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - [5781] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(23), 1, - anon_sym_LBRACK, - ACTIONS(27), 1, - anon_sym_LBRACE, - ACTIONS(35), 1, - anon_sym_LPAREN, - ACTIONS(258), 1, - sym_duration, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - ACTIONS(682), 1, - sym_ident, - STATE(76), 1, - sym_field_expression, - STATE(315), 1, - sym__loop_header_expr, - ACTIONS(649), 2, - sym_false_atom, - sym_number, - STATE(231), 2, - sym__expression, - sym_unary_expression, - ACTIONS(557), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(647), 3, - sym_true_atom, - sym_string_pure, - sym_string_rich, - ACTIONS(260), 4, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(210), 4, - sym_receiver, - sym_self_field, - sym_range_expression, - sym_parenthesized_expression, - STATE(60), 8, - sym__expr_non_unary, - sym_binary_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - [5852] = 3, + sym_locator_pure, + sym_locator_rich, + [10331] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(686), 5, - sym_true_atom, + ACTIONS(841), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(684), 30, + ACTIONS(839), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -11211,6 +16597,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -11218,31 +16605,31 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [5895] = 3, + [10375] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(690), 5, - sym_true_atom, + ACTIONS(845), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(688), 30, + ACTIONS(843), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -11251,6 +16638,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -11258,82 +16646,31 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [5938] = 14, - ACTIONS(3), 1, - sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, - anon_sym_LBRACK, - ACTIONS(27), 1, - anon_sym_LBRACE, - ACTIONS(35), 1, - anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - ACTIONS(692), 1, - anon_sym_RPAREN, - STATE(76), 1, - sym_field_expression, - STATE(217), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6003] = 3, + [10419] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(696), 5, - sym_true_atom, + ACTIONS(849), 5, + anon_sym_PIPE, sym_false_atom, sym_ident, sym_number, sym_duration, - ACTIONS(694), 30, + ACTIONS(847), 31, ts_builtin_sym_end, anon_sym_LF, - sym_leader_tilde, sym_leader_dollar, sym_leader_hash, sym_leader_at, sym_leader_question, - sym_leader_caret, sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, anon_sym_LBRACK, anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COLON, + anon_sym_CARET, anon_sym_BANG, anon_sym_STAR, anon_sym_LPAREN, @@ -11342,6 +16679,7 @@ static const uint16_t ts_small_parse_table[] = { sym_match_leader, anon_sym_PLUS, anon_sym_DASH, + anon_sym_AMP, anon_sym_SLASH, sym_string_pure, sym_string_rich, @@ -11349,48 +16687,49 @@ static const uint16_t ts_small_parse_table[] = { sym_bytes_rich, sym_locator_pure, sym_locator_rich, - [6046] = 14, + [10463] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(634), 1, anon_sym_LT, - ACTIONS(563), 1, - anon_sym_RBRACK, - STATE(76), 1, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, sym_field_expression, - STATE(215), 2, + STATE(316), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -11400,46 +16739,49 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [6111] = 13, + [10529] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(634), 1, anon_sym_LT, - STATE(76), 1, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, sym_field_expression, - STATE(204), 2, + STATE(305), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -11449,46 +16791,49 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [6173] = 13, + [10595] = 14, ACTIONS(3), 1, sym_comment, ACTIONS(7), 1, sym_ident, + ACTIONS(21), 1, + anon_sym_DOT, ACTIONS(23), 1, anon_sym_LBRACK, ACTIONS(27), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(37), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(313), 1, anon_sym_LT, - STATE(76), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + STATE(93), 1, sym_field_expression, - STATE(228), 2, + STATE(80), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(315), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(311), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(317), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(112), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -11498,46 +16843,49 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [6235] = 13, + [10661] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(634), 1, anon_sym_LT, - STATE(76), 1, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, sym_field_expression, - STATE(225), 2, + STATE(312), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -11547,95 +16895,90 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [6297] = 13, + [10727] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, + ACTIONS(853), 5, + anon_sym_PIPE, + sym_false_atom, sym_ident, - ACTIONS(21), 1, + sym_number, + sym_duration, + ACTIONS(851), 31, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, - ACTIONS(23), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(85), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_GT, + sym_match_leader, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, + anon_sym_AMP, + anon_sym_SLASH, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6359] = 13, + [10771] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(634), 1, anon_sym_LT, - STATE(76), 1, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, sym_field_expression, - STATE(219), 2, + STATE(300), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -11645,46 +16988,49 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [6421] = 13, + [10837] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(628), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + ACTIONS(630), 1, anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(632), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(634), 1, anon_sym_LT, - STATE(76), 1, + ACTIONS(636), 1, + anon_sym_PIPE, + ACTIONS(642), 1, + sym_ident, + ACTIONS(646), 1, + anon_sym_DOT, + STATE(277), 1, sym_field_expression, - STATE(66), 2, + STATE(318), 2, sym__expression, sym_unary_expression, - ACTIONS(258), 3, + ACTIONS(638), 3, sym_false_atom, sym_number, sym_duration, - ACTIONS(557), 3, + ACTIONS(624), 4, + anon_sym_TILDE, anon_sym_BANG, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, + ACTIONS(640), 6, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, + STATE(271), 13, sym__expr_non_unary, sym_receiver, sym_self_field, + sym_true_atom, sym_binary_expression, sym_range_expression, sym_width_cast, @@ -11694,1439 +17040,1270 @@ static const uint16_t ts_small_parse_table[] = { sym_struct_literal, sym_fn_expression, sym_parenthesized_expression, - [6483] = 13, + [10903] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, + ACTIONS(857), 5, + anon_sym_PIPE, + sym_false_atom, sym_ident, - ACTIONS(21), 1, + sym_number, + sym_duration, + ACTIONS(855), 31, + ts_builtin_sym_end, + anon_sym_LF, + sym_leader_dollar, + sym_leader_hash, + sym_leader_at, + sym_leader_question, + sym_leader_backslash, + anon_sym_TILDE, anon_sym_DOT, - ACTIONS(23), 1, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_CARET, + anon_sym_BANG, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(88), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_GT, + sym_match_leader, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, + anon_sym_AMP, + anon_sym_SLASH, sym_string_pure, sym_string_rich, sym_bytes_pure, sym_bytes_rich, sym_locator_pure, sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6545] = 13, + [10947] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(859), 1, + sym_ident, + ACTIONS(505), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(501), 23, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [10988] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(375), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(373), 20, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11028] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(511), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(509), 23, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11066] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(425), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(423), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(222), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6607] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11104] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(351), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(349), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(90), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6669] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11142] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(429), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(427), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(79), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6731] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11180] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(433), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(431), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(216), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6793] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11218] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(21), 1, + ACTIONS(437), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(435), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(35), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11256] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(441), 7, + anon_sym_DOT, anon_sym_LT, - ACTIONS(698), 1, - sym_ident, - ACTIONS(700), 1, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(439), 23, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - STATE(76), 1, - sym_field_expression, - STATE(93), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6855] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11294] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(445), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(443), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(91), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6917] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11332] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, - anon_sym_LPAREN, - ACTIONS(553), 1, + ACTIONS(449), 7, anon_sym_DOT, - ACTIONS(559), 1, anon_sym_LT, - ACTIONS(702), 1, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(447), 23, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - STATE(76), 1, - sym_field_expression, - STATE(224), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [6979] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11370] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(453), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(451), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(98), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7041] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11408] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(465), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(463), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(212), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7103] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11446] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(469), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(467), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(218), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7165] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11484] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(473), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(471), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(215), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7227] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11522] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(477), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(475), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(208), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7289] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11560] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(481), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(479), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(227), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7351] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11598] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(407), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(405), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(84), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7413] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11636] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(863), 1, + anon_sym_DOT, + ACTIONS(865), 1, anon_sym_LBRACK, - ACTIONS(27), 1, - anon_sym_LBRACE, - ACTIONS(35), 1, + ACTIONS(867), 1, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, + ACTIONS(489), 6, anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(229), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(487), 21, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_PERCENT, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7475] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11680] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(421), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(419), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(59), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7537] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11718] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(347), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(345), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(220), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7599] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11756] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(457), 7, anon_sym_DOT, - ACTIONS(23), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, - anon_sym_LPAREN, - ACTIONS(256), 1, anon_sym_LT, - ACTIONS(704), 1, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(455), 23, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - STATE(76), 1, - sym_field_expression, - STATE(97), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7661] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11794] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(21), 1, + ACTIONS(461), 7, anon_sym_DOT, - ACTIONS(23), 1, - anon_sym_LBRACK, - ACTIONS(35), 1, - anon_sym_LPAREN, - ACTIONS(256), 1, anon_sym_LT, - ACTIONS(706), 1, - sym_ident, - ACTIONS(708), 1, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(459), 23, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - STATE(76), 1, - sym_field_expression, - STATE(101), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7723] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11832] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(417), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(415), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(66), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7785] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11870] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(869), 1, + anon_sym_LBRACE, + ACTIONS(329), 7, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(327), 22, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(35), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(256), 1, - anon_sym_LT, - ACTIONS(710), 1, - anon_sym_LBRACE, - STATE(76), 1, - sym_field_expression, - STATE(100), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7847] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11910] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(359), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(357), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(205), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7909] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11948] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(363), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(361), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(79), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [7971] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [11986] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(367), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(365), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(201), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [8033] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12024] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(499), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(497), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(203), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [8095] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12062] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(371), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(369), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(202), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [8157] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12100] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(23), 1, + ACTIONS(375), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(373), 23, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(559), 1, - anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(59), 2, - sym__expression, - sym_unary_expression, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(557), 3, - anon_sym_BANG, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [8219] = 13, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12138] = 10, ACTIONS(3), 1, sym_comment, - ACTIONS(7), 1, - sym_ident, - ACTIONS(21), 1, + ACTIONS(873), 1, + anon_sym_DOT_DOT, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(375), 2, anon_sym_DOT, - ACTIONS(23), 1, + anon_sym_PIPE, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(871), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(879), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(373), 11, + anon_sym_LF, + anon_sym_COMMA, anon_sym_LBRACK, - ACTIONS(27), 1, + anon_sym_RBRACK, anon_sym_LBRACE, - ACTIONS(35), 1, + anon_sym_RBRACE, + anon_sym_CARET, anon_sym_LPAREN, - ACTIONS(256), 1, + anon_sym_RPAREN, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + [12190] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(873), 1, + anon_sym_DOT_DOT, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(375), 7, + anon_sym_DOT, anon_sym_LT, - STATE(76), 1, - sym_field_expression, - STATE(87), 2, - sym__expression, - sym_unary_expression, - ACTIONS(254), 3, - anon_sym_BANG, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(373), 15, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [12236] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(258), 3, - sym_false_atom, - sym_number, - sym_duration, - ACTIONS(260), 7, - sym_true_atom, - sym_string_pure, - sym_string_rich, - sym_bytes_pure, - sym_bytes_rich, - sym_locator_pure, - sym_locator_rich, - STATE(60), 12, - sym__expr_non_unary, - sym_receiver, - sym_self_field, - sym_binary_expression, - sym_range_expression, - sym_width_cast, - sym_call_expression, - sym_index_expression, - sym_list_expression, - sym_struct_literal, - sym_fn_expression, - sym_parenthesized_expression, - [8281] = 4, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(393), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(391), 16, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [12280] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(712), 1, - sym_ident, - ACTIONS(420), 5, + ACTIONS(403), 7, anon_sym_DOT, anon_sym_LT, anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(416), 20, + ACTIONS(401), 23, anon_sym_LF, anon_sym_COMMA, anon_sym_LBRACK, @@ -13134,6 +18311,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, anon_sym_RPAREN, @@ -13147,63 +18325,82 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8317] = 5, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12318] = 9, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(714), 3, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(375), 3, + anon_sym_DOT, + anon_sym_AMP, + anon_sym_PIPE, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(394), 5, - anon_sym_DOT, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(392), 16, + ACTIONS(879), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(373), 11, anon_sym_LF, anon_sym_COMMA, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_CARET, anon_sym_LPAREN, anon_sym_RPAREN, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, - anon_sym_EQ_EQ_EQ, - anon_sym_BANG_EQ_EQ, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - [8354] = 8, + [12368] = 11, ACTIONS(3), 1, sym_comment, - ACTIONS(394), 1, - anon_sym_DOT, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(720), 2, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(375), 2, + anon_sym_DOT, + anon_sym_PIPE, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(392), 10, + ACTIONS(373), 10, anon_sym_LF, anon_sym_COMMA, anon_sym_LBRACK, @@ -13214,33 +18411,42 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, - [8397] = 9, + [12422] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(394), 1, + ACTIONS(375), 1, anon_sym_DOT, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - ACTIONS(392), 9, + ACTIONS(373), 9, anon_sym_LF, anon_sym_COMMA, anon_sym_LBRACK, @@ -13250,90 +18456,182 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_PIPE_PIPE, - [8442] = 4, + [12480] = 12, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, - anon_sym_DOT_DOT, - ACTIONS(394), 5, + ACTIONS(375), 1, anon_sym_DOT, + ACTIONS(873), 1, + anon_sym_DOT_DOT, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(392), 19, + ACTIONS(879), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(373), 10, anon_sym_LF, anon_sym_COMMA, anon_sym_LBRACK, anon_sym_RBRACK, - anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, - anon_sym_STAR, anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + [12536] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, anon_sym_SLASH, + ACTIONS(375), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(373), 18, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_DOT_DOT, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8477] = 6, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12578] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, - anon_sym_DOT_DOT, - ACTIONS(720), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(714), 3, - anon_sym_PERCENT, - anon_sym_STAR, - anon_sym_SLASH, - ACTIONS(394), 5, + ACTIONS(485), 7, anon_sym_DOT, anon_sym_LT, anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(392), 14, + ACTIONS(483), 23, anon_sym_LF, anon_sym_COMMA, anon_sym_LBRACK, anon_sym_RBRACK, + anon_sym_PERCENT, anon_sym_LBRACE, anon_sym_RBRACE, + anon_sym_CARET, + anon_sym_STAR, anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, anon_sym_PIPE_PIPE, anon_sym_AMP_AMP, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8516] = 7, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12616] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(364), 1, + ACTIONS(608), 1, + anon_sym_COMMA, + ACTIONS(869), 1, anon_sym_LBRACE, - ACTIONS(521), 1, + ACTIONS(889), 1, + anon_sym_RPAREN, + STATE(389), 1, + aux_sym_export_statement_repeat1, + ACTIONS(329), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(327), 17, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12660] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(608), 1, anon_sym_COMMA, - ACTIONS(726), 1, + ACTIONS(869), 1, + anon_sym_LBRACE, + ACTIONS(891), 1, anon_sym_RPAREN, - STATE(273), 1, + STATE(385), 1, aux_sym_export_statement_repeat1, - ACTIONS(362), 5, + ACTIONS(329), 7, anon_sym_DOT, anon_sym_LT, anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(360), 14, + ACTIONS(327), 17, anon_sym_LBRACK, anon_sym_PERCENT, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, anon_sym_DOT_DOT, @@ -13346,26 +18644,31 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8555] = 8, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12704] = 8, ACTIONS(3), 1, sym_comment, - ACTIONS(728), 1, + ACTIONS(893), 1, anon_sym_DOT, - ACTIONS(730), 1, + ACTIONS(895), 1, anon_sym_LBRACK, - ACTIONS(732), 1, + ACTIONS(897), 1, anon_sym_LBRACE, - ACTIONS(734), 1, + ACTIONS(899), 1, anon_sym_COLON, - ACTIONS(736), 1, + ACTIONS(901), 1, anon_sym_LPAREN, - ACTIONS(362), 4, + ACTIONS(329), 6, anon_sym_LT, anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(360), 12, + ACTIONS(327), 15, anon_sym_PERCENT, + anon_sym_CARET, anon_sym_STAR, anon_sym_DOT_DOT, anon_sym_PLUS, @@ -13377,88 +18680,228 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8594] = 12, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12748] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(571), 1, + ACTIONS(873), 1, + anon_sym_DOT_DOT, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, + anon_sym_AMP_AMP, + ACTIONS(903), 1, + anon_sym_LF, + ACTIONS(905), 1, + anon_sym_COMMA, + ACTIONS(907), 1, anon_sym_RBRACK, - ACTIONS(716), 1, + ACTIONS(909), 1, + anon_sym_PIPE_PIPE, + STATE(358), 1, + aux_sym_list_expression_repeat1, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(871), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(879), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [12807] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(664), 1, + anon_sym_RBRACK, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(738), 1, + ACTIONS(909), 1, + anon_sym_PIPE_PIPE, + ACTIONS(911), 1, anon_sym_LF, - ACTIONS(740), 1, + ACTIONS(913), 1, anon_sym_COMMA, - ACTIONS(742), 1, + STATE(349), 1, + aux_sym_list_expression_repeat1, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(871), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(879), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [12866] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(897), 1, + anon_sym_LBRACE, + ACTIONS(329), 7, + anon_sym_DOT, + anon_sym_LT, + anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(327), 17, + anon_sym_LBRACK, + anon_sym_PERCENT, + anon_sym_CARET, + anon_sym_STAR, + anon_sym_LPAREN, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_SLASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_LT_LT, + anon_sym_GT_GT, + [12901] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(660), 1, + anon_sym_RBRACK, + ACTIONS(873), 1, + anon_sym_DOT_DOT, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, + anon_sym_AMP_AMP, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - STATE(257), 1, + ACTIONS(915), 1, + anon_sym_LF, + ACTIONS(917), 1, + anon_sym_COMMA, + STATE(347), 1, aux_sym_list_expression_repeat1, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8640] = 12, + [12960] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(744), 1, + ACTIONS(919), 1, anon_sym_LF, - ACTIONS(746), 1, + ACTIONS(921), 1, anon_sym_COMMA, - ACTIONS(748), 1, + ACTIONS(923), 1, anon_sym_RBRACK, - STATE(247), 1, + STATE(355), 1, aux_sym_list_expression_repeat1, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8686] = 4, + [13019] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(732), 1, - anon_sym_LBRACE, - ACTIONS(362), 5, + ACTIONS(925), 1, + sym_ident, + ACTIONS(505), 7, anon_sym_DOT, anon_sym_LT, anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(360), 14, + ACTIONS(501), 17, anon_sym_LBRACK, anon_sym_PERCENT, + anon_sym_CARET, anon_sym_STAR, anon_sym_LPAREN, anon_sym_DOT_DOT, @@ -13471,24 +18914,29 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8716] = 7, + anon_sym_LT_LT, + anon_sym_GT_GT, + [13054] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(728), 1, + ACTIONS(893), 1, anon_sym_DOT, - ACTIONS(730), 1, + ACTIONS(895), 1, anon_sym_LBRACK, - ACTIONS(732), 1, + ACTIONS(897), 1, anon_sym_LBRACE, - ACTIONS(736), 1, + ACTIONS(901), 1, anon_sym_LPAREN, - ACTIONS(362), 4, + ACTIONS(329), 6, anon_sym_LT, anon_sym_GT, + anon_sym_AMP, + anon_sym_PIPE, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(360), 12, + ACTIONS(327), 15, anon_sym_PERCENT, + anon_sym_CARET, anon_sym_STAR, anon_sym_DOT_DOT, anon_sym_PLUS, @@ -13500,616 +18948,874 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8752] = 9, + anon_sym_LT_LT, + anon_sym_GT_GT, + [13095] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, + anon_sym_AMP_AMP, + ACTIONS(909), 1, + anon_sym_PIPE_PIPE, + ACTIONS(927), 1, + anon_sym_COMMA, + ACTIONS(929), 1, + anon_sym_RPAREN, + STATE(371), 1, + aux_sym__loop_header_expr_repeat1, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(871), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(879), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [13151] = 13, + ACTIONS(3), 1, + sym_comment, + ACTIONS(873), 1, + anon_sym_DOT_DOT, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(750), 3, + ACTIONS(931), 3, anon_sym_LF, anon_sym_COMMA, - anon_sym_RBRACE, - ACTIONS(718), 4, + anon_sym_RBRACK, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8791] = 11, + [13203] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, + anon_sym_AMP_AMP, + ACTIONS(909), 1, + anon_sym_PIPE_PIPE, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(933), 3, + anon_sym_LF, + anon_sym_COMMA, + anon_sym_RBRACK, + ACTIONS(871), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(879), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [13255] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(873), 1, + anon_sym_DOT_DOT, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(752), 1, + ACTIONS(927), 1, anon_sym_COMMA, - ACTIONS(754), 1, + ACTIONS(935), 1, anon_sym_RPAREN, - STATE(286), 1, + STATE(360), 1, aux_sym__loop_header_expr_repeat1, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8834] = 11, + [13311] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(752), 1, + ACTIONS(927), 1, anon_sym_COMMA, - ACTIONS(756), 1, + ACTIONS(937), 1, anon_sym_RPAREN, - STATE(272), 1, + STATE(376), 1, aux_sym__loop_header_expr_repeat1, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8877] = 9, + [13367] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(720), 2, + ACTIONS(927), 1, + anon_sym_COMMA, + ACTIONS(939), 1, + anon_sym_RPAREN, + STATE(382), 1, + aux_sym__loop_header_expr_repeat1, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(758), 3, - anon_sym_LF, - anon_sym_COMMA, - anon_sym_RBRACK, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8916] = 9, + [13423] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(760), 3, + ACTIONS(941), 3, anon_sym_LF, anon_sym_COMMA, - anon_sym_RBRACK, - ACTIONS(718), 4, + anon_sym_RBRACE, + ACTIONS(871), 4, + anon_sym_LT, + anon_sym_GT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(879), 4, + anon_sym_EQ_EQ_EQ, + anon_sym_BANG_EQ_EQ, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + [13475] = 13, + ACTIONS(3), 1, + sym_comment, + ACTIONS(873), 1, + anon_sym_DOT_DOT, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, + anon_sym_AMP_AMP, + ACTIONS(909), 1, + anon_sym_PIPE_PIPE, + ACTIONS(875), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(943), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + ACTIONS(861), 3, + anon_sym_PERCENT, + anon_sym_STAR, + anon_sym_SLASH, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8955] = 11, + [13526] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(752), 1, + ACTIONS(423), 2, anon_sym_COMMA, - ACTIONS(762), 1, - anon_sym_RPAREN, - STATE(285), 1, - aux_sym__loop_header_expr_repeat1, - ACTIONS(720), 2, + anon_sym_LBRACE, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [8998] = 9, + [13577] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(286), 2, - anon_sym_COMMA, - anon_sym_LBRACE, - ACTIONS(720), 2, + ACTIONS(945), 1, + anon_sym_RBRACK, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9036] = 9, + [13627] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(720), 2, + ACTIONS(947), 1, + anon_sym_RBRACK, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(764), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9074] = 9, + [13677] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(754), 1, - anon_sym_RBRACK, - ACTIONS(720), 2, + ACTIONS(949), 1, + anon_sym_LBRACE, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9111] = 12, - ACTIONS(3), 1, - sym_comment, - ACTIONS(768), 1, - anon_sym_LF, - ACTIONS(772), 1, - anon_sym_PERCENT, - ACTIONS(774), 1, - anon_sym_RBRACE, - ACTIONS(776), 1, - anon_sym_COLON, - ACTIONS(778), 1, - anon_sym_LT, - ACTIONS(782), 1, - sym_number, - ACTIONS(766), 2, - sym_false_atom, - sym_ident, - ACTIONS(770), 2, - sym_leader_dollar, - anon_sym_BANG, - STATE(226), 2, - sym_match_arm, - aux_sym_match_statement_repeat1, - STATE(263), 2, - sym__match_pattern, - sym_width_cast, - ACTIONS(780), 3, - sym_true_atom, - sym_string_pure, - sym_string_rich, - [9154] = 9, + [13727] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(784), 1, - anon_sym_RPAREN, - ACTIONS(720), 2, + ACTIONS(937), 1, + anon_sym_RBRACK, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9191] = 12, - ACTIONS(3), 1, - sym_comment, - ACTIONS(772), 1, - anon_sym_PERCENT, - ACTIONS(776), 1, - anon_sym_COLON, - ACTIONS(778), 1, - anon_sym_LT, - ACTIONS(782), 1, - sym_number, - ACTIONS(786), 1, - anon_sym_LF, - ACTIONS(788), 1, - anon_sym_RBRACE, - ACTIONS(766), 2, - sym_false_atom, - sym_ident, - ACTIONS(770), 2, - sym_leader_dollar, - anon_sym_BANG, - STATE(221), 2, - sym_match_arm, - aux_sym_match_statement_repeat1, - STATE(263), 2, - sym__match_pattern, - sym_width_cast, - ACTIONS(780), 3, - sym_true_atom, - sym_string_pure, - sym_string_rich, - [9234] = 9, + [13777] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(790), 1, - anon_sym_LBRACE, - ACTIONS(720), 2, + ACTIONS(951), 1, + anon_sym_RPAREN, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9271] = 9, + [13827] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(792), 1, + ACTIONS(953), 1, anon_sym_RBRACK, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9308] = 12, - ACTIONS(3), 1, - sym_comment, - ACTIONS(797), 1, - anon_sym_LF, - ACTIONS(803), 1, - anon_sym_PERCENT, - ACTIONS(806), 1, - anon_sym_RBRACE, - ACTIONS(808), 1, - anon_sym_COLON, - ACTIONS(811), 1, - anon_sym_LT, - ACTIONS(817), 1, - sym_number, - ACTIONS(794), 2, - sym_false_atom, - sym_ident, - ACTIONS(800), 2, - sym_leader_dollar, - anon_sym_BANG, - STATE(226), 2, - sym_match_arm, - aux_sym_match_statement_repeat1, - STATE(263), 2, - sym__match_pattern, - sym_width_cast, - ACTIONS(814), 3, - sym_true_atom, - sym_string_pure, - sym_string_rich, - [9351] = 9, + [13877] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(762), 1, - anon_sym_RBRACK, - ACTIONS(720), 2, + ACTIONS(955), 1, + anon_sym_RPAREN, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9388] = 9, + [13927] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(820), 1, + ACTIONS(957), 1, anon_sym_LBRACE, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9425] = 9, + [13977] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(822), 1, + ACTIONS(929), 1, anon_sym_RBRACK, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9462] = 8, + [14027] = 12, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, + ACTIONS(381), 1, anon_sym_DOT_DOT, - ACTIONS(410), 1, - anon_sym_PIPE_PIPE, - ACTIONS(412), 1, + ACTIONS(385), 1, + anon_sym_AMP, + ACTIONS(395), 1, + anon_sym_CARET, + ACTIONS(397), 1, + anon_sym_PIPE, + ACTIONS(399), 1, anon_sym_AMP_AMP, - ACTIONS(402), 2, + ACTIONS(413), 1, + anon_sym_PIPE_PIPE, + ACTIONS(383), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(396), 3, + ACTIONS(389), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(377), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(398), 4, + ACTIONS(379), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(404), 4, + ACTIONS(387), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9496] = 8, + [14074] = 12, ACTIONS(3), 1, sym_comment, - ACTIONS(716), 1, + ACTIONS(873), 1, anon_sym_DOT_DOT, - ACTIONS(724), 1, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(883), 1, + anon_sym_CARET, + ACTIONS(885), 1, + anon_sym_PIPE, + ACTIONS(887), 1, anon_sym_AMP_AMP, - ACTIONS(742), 1, + ACTIONS(909), 1, anon_sym_PIPE_PIPE, - ACTIONS(720), 2, + ACTIONS(875), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(714), 3, + ACTIONS(881), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(861), 3, anon_sym_PERCENT, anon_sym_STAR, anon_sym_SLASH, - ACTIONS(718), 4, + ACTIONS(871), 4, anon_sym_LT, anon_sym_GT, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(722), 4, + ACTIONS(879), 4, anon_sym_EQ_EQ_EQ, anon_sym_BANG_EQ_EQ, anon_sym_LT_EQ, anon_sym_GT_EQ, - [9530] = 3, + [14121] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(824), 2, + ACTIONS(738), 1, + anon_sym_PIPE, + ACTIONS(961), 1, + anon_sym_LF, + ACTIONS(965), 1, + anon_sym_PERCENT, + ACTIONS(967), 1, + anon_sym_RBRACE, + ACTIONS(969), 1, + anon_sym_COLON, + ACTIONS(971), 1, + anon_sym_LT, + ACTIONS(973), 1, + sym_number, + ACTIONS(959), 2, sym_false_atom, sym_ident, - ACTIONS(826), 11, - anon_sym_LF, + ACTIONS(963), 2, sym_leader_dollar, + anon_sym_BANG, + ACTIONS(975), 2, + sym_string_pure, + sym_string_rich, + STATE(326), 2, + sym_match_arm, + aux_sym_match_statement_repeat1, + STATE(384), 3, + sym__match_pattern, + sym_true_atom, + sym_width_cast, + [14167] = 13, + ACTIONS(3), 1, + sym_comment, + ACTIONS(980), 1, + anon_sym_LF, + ACTIONS(986), 1, anon_sym_PERCENT, + ACTIONS(989), 1, anon_sym_RBRACE, + ACTIONS(991), 1, anon_sym_COLON, - anon_sym_BANG, + ACTIONS(994), 1, anon_sym_LT, + ACTIONS(997), 1, + anon_sym_PIPE, + ACTIONS(1000), 1, + sym_number, + ACTIONS(977), 2, + sym_false_atom, + sym_ident, + ACTIONS(983), 2, + sym_leader_dollar, + anon_sym_BANG, + ACTIONS(1003), 2, + sym_string_pure, + sym_string_rich, + STATE(325), 2, + sym_match_arm, + aux_sym_match_statement_repeat1, + STATE(384), 3, + sym__match_pattern, sym_true_atom, + sym_width_cast, + [14213] = 13, + ACTIONS(3), 1, + sym_comment, + ACTIONS(738), 1, + anon_sym_PIPE, + ACTIONS(965), 1, + anon_sym_PERCENT, + ACTIONS(969), 1, + anon_sym_COLON, + ACTIONS(971), 1, + anon_sym_LT, + ACTIONS(973), 1, sym_number, + ACTIONS(1006), 1, + anon_sym_LF, + ACTIONS(1008), 1, + anon_sym_RBRACE, + ACTIONS(959), 2, + sym_false_atom, + sym_ident, + ACTIONS(963), 2, + sym_leader_dollar, + anon_sym_BANG, + ACTIONS(975), 2, sym_string_pure, sym_string_rich, - [9551] = 3, + STATE(325), 2, + sym_match_arm, + aux_sym_match_statement_repeat1, + STATE(384), 3, + sym__match_pattern, + sym_true_atom, + sym_width_cast, + [14259] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(828), 2, + ACTIONS(1010), 2, sym_false_atom, sym_ident, - ACTIONS(830), 11, + ACTIONS(1012), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14117,17 +19823,40 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, + sym_number, + sym_string_pure, + sym_string_rich, + [14280] = 8, + ACTIONS(3), 1, + sym_comment, + ACTIONS(738), 1, + anon_sym_PIPE, + ACTIONS(1014), 1, + sym_ident, + ACTIONS(1016), 1, + anon_sym_DOT, + ACTIONS(1018), 1, + anon_sym_LPAREN, + ACTIONS(1020), 1, + sym_false_atom, + ACTIONS(1022), 3, sym_number, sym_string_pure, sym_string_rich, - [9572] = 3, + STATE(435), 5, + sym__match_scrutinee, + sym_receiver, + sym_self_field, + sym_true_atom, + sym_parenthesized_expression, + [14311] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(832), 2, + ACTIONS(1024), 2, sym_false_atom, sym_ident, - ACTIONS(834), 11, + ACTIONS(1026), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14135,17 +19864,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - [9593] = 3, + [14332] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(836), 2, + ACTIONS(1028), 2, sym_false_atom, sym_ident, - ACTIONS(838), 11, + ACTIONS(1030), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14153,17 +19882,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - [9614] = 3, + [14353] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(840), 2, + ACTIONS(1032), 2, sym_false_atom, sym_ident, - ACTIONS(842), 11, + ACTIONS(1034), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14171,17 +19900,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - [9635] = 3, + [14374] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(844), 2, + ACTIONS(1036), 2, sym_false_atom, sym_ident, - ACTIONS(846), 11, + ACTIONS(1038), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14189,17 +19918,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - [9656] = 3, + [14395] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(848), 2, + ACTIONS(1040), 2, sym_false_atom, sym_ident, - ACTIONS(850), 11, + ACTIONS(1042), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14207,17 +19936,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - [9677] = 3, + [14416] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(852), 2, + ACTIONS(1044), 2, sym_false_atom, sym_ident, - ACTIONS(854), 11, + ACTIONS(1046), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14225,17 +19954,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - [9698] = 3, + [14437] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(856), 2, + ACTIONS(1048), 2, sym_false_atom, sym_ident, - ACTIONS(858), 11, + ACTIONS(1050), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14243,17 +19972,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - [9719] = 3, + [14458] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(860), 2, + ACTIONS(1052), 2, sym_false_atom, sym_ident, - ACTIONS(862), 11, + ACTIONS(1054), 11, anon_sym_LF, sym_leader_dollar, anon_sym_PERCENT, @@ -14261,1081 +19990,1413 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, anon_sym_BANG, anon_sym_LT, - sym_true_atom, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - [9740] = 7, + [14479] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(864), 1, - sym_ident, - ACTIONS(866), 1, - anon_sym_LPAREN, - ACTIONS(870), 1, + ACTIONS(1056), 2, sym_false_atom, - ACTIONS(868), 4, - sym_true_atom, + sym_ident, + ACTIONS(1058), 11, + anon_sym_LF, + sym_leader_dollar, + anon_sym_PERCENT, + anon_sym_RBRACE, + anon_sym_COLON, + anon_sym_BANG, + anon_sym_LT, + anon_sym_PIPE, sym_number, sym_string_pure, sym_string_rich, - STATE(333), 4, - sym__match_scrutinee, - sym_receiver, - sym_self_field, - sym_parenthesized_expression, - [9768] = 6, + [14500] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(778), 1, + ACTIONS(738), 1, + anon_sym_PIPE, + ACTIONS(971), 1, anon_sym_LT, - ACTIONS(782), 1, + ACTIONS(973), 1, sym_number, - ACTIONS(872), 2, + ACTIONS(1060), 2, sym_false_atom, sym_ident, - STATE(296), 2, - sym__match_pattern, - sym_width_cast, - ACTIONS(874), 3, - sym_true_atom, + ACTIONS(1062), 2, sym_string_pure, sym_string_rich, - [9791] = 6, + STATE(397), 3, + sym__match_pattern, + sym_true_atom, + sym_width_cast, + [14526] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1064), 1, sym_ident, - ACTIONS(878), 1, + ACTIONS(1066), 1, anon_sym_LF, - ACTIONS(880), 1, + ACTIONS(1068), 1, anon_sym_RBRACE, - STATE(255), 1, + STATE(357), 1, sym_field_initializer, - STATE(318), 1, + STATE(459), 1, sym__struct_field_list, - [9810] = 6, + [14545] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1064), 1, sym_ident, - ACTIONS(878), 1, + ACTIONS(1066), 1, anon_sym_LF, - ACTIONS(882), 1, + ACTIONS(1070), 1, anon_sym_RBRACE, - STATE(255), 1, + STATE(357), 1, sym_field_initializer, - STATE(338), 1, + STATE(469), 1, sym__struct_field_list, - [9829] = 5, + [14564] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(884), 1, - anon_sym_DOT, - ACTIONS(886), 1, - anon_sym_LBRACK, - ACTIONS(888), 1, - anon_sym_LBRACE, - ACTIONS(890), 1, - anon_sym_LPAREN, - [9845] = 5, + ACTIONS(1064), 1, + sym_ident, + ACTIONS(1066), 1, + anon_sym_LF, + ACTIONS(1072), 1, + anon_sym_RBRACE, + STATE(357), 1, + sym_field_initializer, + STATE(418), 1, + sym__struct_field_list, + [14583] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(571), 1, - anon_sym_RBRACK, - ACTIONS(738), 1, + ACTIONS(1064), 1, + sym_ident, + ACTIONS(1066), 1, anon_sym_LF, - ACTIONS(740), 1, - anon_sym_COMMA, - STATE(259), 1, - aux_sym_list_expression_repeat1, - [9861] = 5, + ACTIONS(1074), 1, + anon_sym_RBRACE, + STATE(357), 1, + sym_field_initializer, + STATE(426), 1, + sym__struct_field_list, + [14602] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(892), 1, + ACTIONS(1076), 1, anon_sym_LF, - ACTIONS(894), 1, + ACTIONS(1079), 1, anon_sym_COMMA, - ACTIONS(896), 1, + ACTIONS(1082), 1, anon_sym_RBRACE, - STATE(252), 1, + STATE(343), 1, aux_sym__struct_field_list_repeat1, - [9877] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(876), 1, - sym_ident, - ACTIONS(896), 1, - anon_sym_RBRACE, - ACTIONS(898), 1, - anon_sym_LF, - STATE(267), 1, - sym_field_initializer, - [9893] = 5, + [14618] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(892), 1, + ACTIONS(1084), 1, anon_sym_LF, - ACTIONS(894), 1, + ACTIONS(1086), 1, anon_sym_COMMA, - ACTIONS(896), 1, + ACTIONS(1088), 1, anon_sym_RBRACE, - STATE(254), 1, + STATE(348), 1, aux_sym__struct_field_list_repeat1, - [9909] = 5, + [14634] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1064), 1, sym_ident, - ACTIONS(900), 1, + ACTIONS(1090), 1, anon_sym_LF, - ACTIONS(902), 1, + ACTIONS(1092), 1, anon_sym_RBRACE, - STATE(267), 1, + STATE(379), 1, sym_field_initializer, - [9925] = 5, + [14650] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(902), 1, - anon_sym_RBRACE, - ACTIONS(904), 1, + ACTIONS(1064), 1, + sym_ident, + ACTIONS(1094), 1, anon_sym_LF, - ACTIONS(906), 1, - anon_sym_COMMA, - STATE(254), 1, - aux_sym__struct_field_list_repeat1, - [9941] = 5, + ACTIONS(1096), 1, + anon_sym_RBRACE, + STATE(379), 1, + sym_field_initializer, + [14666] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(908), 1, - sym_ident, - ACTIONS(910), 1, - anon_sym_DOT, - STATE(120), 1, - sym_bind_lhs, - STATE(123), 1, - sym_bind_clause, - [9957] = 5, + ACTIONS(672), 1, + anon_sym_RBRACK, + ACTIONS(1098), 1, + anon_sym_LF, + ACTIONS(1100), 1, + anon_sym_COMMA, + STATE(352), 1, + aux_sym_list_expression_repeat1, + [14682] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(912), 1, + ACTIONS(1096), 1, + anon_sym_RBRACE, + ACTIONS(1102), 1, anon_sym_LF, - ACTIONS(915), 1, + ACTIONS(1104), 1, anon_sym_COMMA, - ACTIONS(918), 1, - anon_sym_RBRACE, - STATE(254), 1, + STATE(343), 1, aux_sym__struct_field_list_repeat1, - [9973] = 5, + [14698] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(920), 1, + ACTIONS(652), 1, + anon_sym_RBRACK, + ACTIONS(1106), 1, anon_sym_LF, - ACTIONS(922), 1, + ACTIONS(1108), 1, anon_sym_COMMA, - ACTIONS(924), 1, - anon_sym_RBRACE, - STATE(250), 1, - aux_sym__struct_field_list_repeat1, - [9989] = 5, + STATE(352), 1, + aux_sym_list_expression_repeat1, + [14714] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1110), 1, + sym_ident, + ACTIONS(1112), 1, + anon_sym_DOT, + STATE(155), 1, + sym_bind_lhs, + STATE(168), 1, + sym_bind_clause, + [14730] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(908), 1, + ACTIONS(1110), 1, sym_ident, - ACTIONS(910), 1, + ACTIONS(1112), 1, anon_sym_DOT, - STATE(118), 1, + STATE(139), 1, sym_bind_clause, - STATE(120), 1, + STATE(155), 1, sym_bind_lhs, - [10005] = 5, + [14746] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(555), 1, + ACTIONS(931), 1, anon_sym_RBRACK, - ACTIONS(926), 1, + ACTIONS(1114), 1, anon_sym_LF, - ACTIONS(928), 1, + ACTIONS(1117), 1, anon_sym_COMMA, - STATE(259), 1, + STATE(352), 1, aux_sym_list_expression_repeat1, - [10021] = 5, + [14762] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1120), 1, + anon_sym_DOT, + ACTIONS(1122), 1, + anon_sym_LBRACK, + ACTIONS(1124), 1, + anon_sym_LBRACE, + ACTIONS(1126), 1, + anon_sym_LPAREN, + [14778] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1064), 1, sym_ident, - ACTIONS(930), 1, - anon_sym_LF, - ACTIONS(932), 1, + ACTIONS(1088), 1, anon_sym_RBRACE, - STATE(267), 1, + ACTIONS(1128), 1, + anon_sym_LF, + STATE(379), 1, sym_field_initializer, - [10037] = 5, + [14794] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(760), 1, + ACTIONS(660), 1, anon_sym_RBRACK, - ACTIONS(934), 1, + ACTIONS(915), 1, anon_sym_LF, - ACTIONS(937), 1, + ACTIONS(917), 1, anon_sym_COMMA, - STATE(259), 1, + STATE(352), 1, aux_sym_list_expression_repeat1, - [10053] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(940), 1, - anon_sym_DOT, - ACTIONS(942), 1, - anon_sym_LBRACE, - STATE(261), 1, - aux_sym__loop_header_expr_repeat2, - [10066] = 4, + [14810] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(944), 1, - anon_sym_DOT, - ACTIONS(947), 1, - anon_sym_LBRACE, - STATE(261), 1, - aux_sym__loop_header_expr_repeat2, - [10079] = 3, + ACTIONS(1084), 1, + anon_sym_LF, + ACTIONS(1086), 1, + anon_sym_COMMA, + ACTIONS(1088), 1, + anon_sym_RBRACE, + STATE(343), 1, + aux_sym__struct_field_list_repeat1, + [14826] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(951), 1, - anon_sym_DOT_DOT, - ACTIONS(949), 2, + ACTIONS(1130), 1, + anon_sym_LF, + ACTIONS(1132), 1, anon_sym_COMMA, - anon_sym_LBRACE, - [10090] = 4, + ACTIONS(1134), 1, + anon_sym_RBRACE, + STATE(356), 1, + aux_sym__struct_field_list_repeat1, + [14842] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(953), 1, + ACTIONS(664), 1, + anon_sym_RBRACK, + ACTIONS(911), 1, + anon_sym_LF, + ACTIONS(913), 1, anon_sym_COMMA, - ACTIONS(955), 1, - anon_sym_LBRACE, - STATE(274), 1, - aux_sym_match_arm_repeat1, - [10103] = 4, + STATE(352), 1, + aux_sym_list_expression_repeat1, + [14858] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1064), 1, sym_ident, - ACTIONS(902), 1, + ACTIONS(1092), 1, anon_sym_RBRACE, - STATE(267), 1, + STATE(367), 1, sym_field_initializer, - [10116] = 4, + [14871] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, + ACTIONS(927), 1, anon_sym_COMMA, - ACTIONS(957), 1, + ACTIONS(1136), 1, + anon_sym_RPAREN, + STATE(387), 1, + aux_sym__loop_header_expr_repeat1, + [14884] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(608), 1, + anon_sym_COMMA, + ACTIONS(1138), 1, anon_sym_RBRACK, - STATE(106), 1, + STATE(131), 1, aux_sym_export_statement_repeat1, - [10129] = 4, + [14897] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, + ACTIONS(608), 1, anon_sym_COMMA, - ACTIONS(957), 1, + ACTIONS(1140), 1, anon_sym_RBRACK, - STATE(271), 1, + STATE(131), 1, aux_sym_export_statement_repeat1, - [10142] = 2, + [14910] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(918), 3, - anon_sym_LF, + ACTIONS(608), 1, anon_sym_COMMA, - anon_sym_RBRACE, - [10151] = 4, + ACTIONS(1140), 1, + anon_sym_RBRACK, + STATE(361), 1, + aux_sym_export_statement_repeat1, + [14923] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1064), 1, sym_ident, - ACTIONS(902), 1, + ACTIONS(1088), 1, anon_sym_RBRACE, - STATE(281), 1, + STATE(379), 1, sym_field_initializer, - [10164] = 4, + [14936] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1064), 1, sym_ident, - ACTIONS(896), 1, + ACTIONS(1092), 1, anon_sym_RBRACE, - STATE(267), 1, + STATE(379), 1, sym_field_initializer, - [10177] = 4, + [14949] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(959), 1, - anon_sym_COMMA, - ACTIONS(962), 1, + ACTIONS(1142), 1, + anon_sym_DOT, + ACTIONS(1145), 1, anon_sym_LBRACE, - STATE(270), 1, - aux_sym_match_arm_repeat1, - [10190] = 4, + STATE(366), 1, + aux_sym__loop_header_expr_repeat2, + [14962] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, + ACTIONS(1147), 3, + anon_sym_LF, anon_sym_COMMA, - ACTIONS(964), 1, - anon_sym_RBRACK, - STATE(106), 1, - aux_sym_export_statement_repeat1, - [10203] = 4, + anon_sym_RBRACE, + [14971] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1064), 1, + sym_ident, + ACTIONS(1149), 1, + anon_sym_LF, + STATE(379), 1, + sym_field_initializer, + [14984] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1151), 1, + anon_sym_DOT, + ACTIONS(1153), 1, + anon_sym_LBRACE, + STATE(366), 1, + aux_sym__loop_header_expr_repeat2, + [14997] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1064), 1, + sym_ident, + ACTIONS(1096), 1, + anon_sym_RBRACE, + STATE(379), 1, + sym_field_initializer, + [15010] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(752), 1, + ACTIONS(927), 1, anon_sym_COMMA, - ACTIONS(966), 1, + ACTIONS(1155), 1, anon_sym_RPAREN, - STATE(276), 1, + STATE(387), 1, aux_sym__loop_header_expr_repeat1, - [10216] = 4, + [15023] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, + ACTIONS(608), 1, anon_sym_COMMA, - ACTIONS(968), 1, - anon_sym_RPAREN, - STATE(106), 1, + ACTIONS(1157), 1, + anon_sym_RBRACK, + STATE(131), 1, aux_sym_export_statement_repeat1, - [10229] = 4, + [15036] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(953), 1, + ACTIONS(608), 1, anon_sym_COMMA, - ACTIONS(970), 1, + ACTIONS(1157), 1, + anon_sym_RBRACK, + STATE(362), 1, + aux_sym_export_statement_repeat1, + [15049] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1151), 1, + anon_sym_DOT, + ACTIONS(1159), 1, anon_sym_LBRACE, - STATE(270), 1, - aux_sym_match_arm_repeat1, - [10242] = 4, + STATE(375), 1, + aux_sym__loop_header_expr_repeat2, + [15062] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(940), 1, + ACTIONS(1151), 1, anon_sym_DOT, - ACTIONS(972), 1, + ACTIONS(1161), 1, anon_sym_LBRACE, - STATE(284), 1, + STATE(366), 1, aux_sym__loop_header_expr_repeat2, - [10255] = 4, + [15075] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(764), 1, - anon_sym_RPAREN, - ACTIONS(974), 1, + ACTIONS(927), 1, anon_sym_COMMA, - STATE(276), 1, + ACTIONS(1163), 1, + anon_sym_RPAREN, + STATE(387), 1, aux_sym__loop_header_expr_repeat1, - [10268] = 4, + [15088] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(940), 1, - anon_sym_DOT, - ACTIONS(977), 1, + ACTIONS(608), 1, + anon_sym_COMMA, + ACTIONS(1165), 1, + anon_sym_RBRACK, + STATE(372), 1, + aux_sym_export_statement_repeat1, + [15101] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1167), 1, + anon_sym_COMMA, + ACTIONS(1170), 1, anon_sym_LBRACE, - STATE(260), 1, - aux_sym__loop_header_expr_repeat2, - [10281] = 4, + STATE(378), 1, + aux_sym_match_arm_repeat1, + [15114] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, - sym_ident, - ACTIONS(932), 1, + ACTIONS(1082), 3, + anon_sym_LF, + anon_sym_COMMA, anon_sym_RBRACE, - STATE(281), 1, - sym_field_initializer, - [10294] = 4, + [15123] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, - sym_ident, - ACTIONS(932), 1, - anon_sym_RBRACE, - STATE(267), 1, - sym_field_initializer, - [10307] = 4, + ACTIONS(1172), 1, + anon_sym_COMMA, + ACTIONS(1174), 1, + anon_sym_LBRACE, + STATE(378), 1, + aux_sym_match_arm_repeat1, + [15136] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, - sym_ident, - ACTIONS(979), 1, - anon_sym_RBRACE, - STATE(281), 1, - sym_field_initializer, - [10320] = 2, + ACTIONS(1178), 1, + anon_sym_DOT_DOT, + ACTIONS(1176), 2, + anon_sym_COMMA, + anon_sym_LBRACE, + [15147] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(981), 3, - anon_sym_LF, + ACTIONS(927), 1, anon_sym_COMMA, - anon_sym_RBRACE, - [10329] = 4, + ACTIONS(1180), 1, + anon_sym_RPAREN, + STATE(387), 1, + aux_sym__loop_header_expr_repeat1, + [15160] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1064), 1, sym_ident, - ACTIONS(983), 1, - anon_sym_LF, - STATE(267), 1, + ACTIONS(1096), 1, + anon_sym_RBRACE, + STATE(367), 1, sym_field_initializer, - [10342] = 4, + [15173] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, + ACTIONS(1172), 1, anon_sym_COMMA, - ACTIONS(985), 1, - anon_sym_RBRACK, - STATE(287), 1, + ACTIONS(1182), 1, + anon_sym_LBRACE, + STATE(380), 1, + aux_sym_match_arm_repeat1, + [15186] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(608), 1, + anon_sym_COMMA, + ACTIONS(1184), 1, + anon_sym_RPAREN, + STATE(131), 1, aux_sym_export_statement_repeat1, - [10355] = 4, + [15199] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(940), 1, + ACTIONS(1151), 1, anon_sym_DOT, - ACTIONS(987), 1, + ACTIONS(1186), 1, anon_sym_LBRACE, - STATE(261), 1, + STATE(369), 1, aux_sym__loop_header_expr_repeat2, - [10368] = 4, + [15212] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(752), 1, - anon_sym_COMMA, - ACTIONS(989), 1, + ACTIONS(943), 1, anon_sym_RPAREN, - STATE(276), 1, + ACTIONS(1188), 1, + anon_sym_COMMA, + STATE(387), 1, aux_sym__loop_header_expr_repeat1, - [10381] = 4, + [15225] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1064), 1, + sym_ident, + ACTIONS(1191), 1, + anon_sym_RBRACE, + STATE(367), 1, + sym_field_initializer, + [15238] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(752), 1, + ACTIONS(608), 1, anon_sym_COMMA, - ACTIONS(991), 1, + ACTIONS(1193), 1, anon_sym_RPAREN, - STATE(276), 1, - aux_sym__loop_header_expr_repeat1, - [10394] = 4, + STATE(131), 1, + aux_sym_export_statement_repeat1, + [15251] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, + ACTIONS(608), 1, anon_sym_COMMA, - ACTIONS(993), 1, + ACTIONS(1195), 1, anon_sym_RBRACK, - STATE(106), 1, + STATE(391), 1, aux_sym_export_statement_repeat1, - [10407] = 4, + [15264] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, + ACTIONS(608), 1, anon_sym_COMMA, - ACTIONS(993), 1, + ACTIONS(1197), 1, anon_sym_RBRACK, - STATE(265), 1, + STATE(131), 1, aux_sym_export_statement_repeat1, - [10420] = 3, + [15277] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(985), 1, + ACTIONS(608), 1, + anon_sym_COMMA, + ACTIONS(1197), 1, anon_sym_RBRACK, - ACTIONS(995), 1, - sym_ident, - [10430] = 3, + STATE(393), 1, + aux_sym_export_statement_repeat1, + [15290] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, - sym_ident, - STATE(267), 1, - sym_field_initializer, - [10440] = 3, + ACTIONS(608), 1, + anon_sym_COMMA, + ACTIONS(1199), 1, + anon_sym_RBRACK, + STATE(131), 1, + aux_sym_export_statement_repeat1, + [15303] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(997), 1, - sym_ident, - ACTIONS(999), 1, + ACTIONS(608), 1, + anon_sym_COMMA, + ACTIONS(1199), 1, anon_sym_RBRACK, - [10450] = 3, + STATE(395), 1, + aux_sym_export_statement_repeat1, + [15316] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, - sym_ident, - STATE(248), 1, - sym_field_initializer, - [10460] = 2, + ACTIONS(608), 1, + anon_sym_COMMA, + ACTIONS(1201), 1, + anon_sym_RBRACK, + STATE(131), 1, + aux_sym_export_statement_repeat1, + [15329] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1001), 2, + ACTIONS(1203), 2, anon_sym_COMMA, anon_sym_LBRACE, - [10468] = 3, + [15337] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1003), 1, - anon_sym_LBRACK, - ACTIONS(1005), 1, + ACTIONS(1205), 2, + anon_sym_COMMA, anon_sym_LBRACE, - [10478] = 3, + [15345] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(876), 1, + ACTIONS(1165), 1, + anon_sym_RBRACK, + ACTIONS(1207), 1, sym_ident, - STATE(281), 1, - sym_field_initializer, - [10488] = 2, + [15355] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1007), 2, - anon_sym_COMMA, + ACTIONS(1209), 1, + anon_sym_LBRACK, + ACTIONS(1211), 1, anon_sym_LBRACE, - [10496] = 3, + [15365] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1009), 1, + ACTIONS(1213), 1, anon_sym_LBRACK, - ACTIONS(1011), 1, + ACTIONS(1215), 1, anon_sym_LBRACE, - [10506] = 3, + [15375] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(993), 1, - anon_sym_RBRACK, - ACTIONS(1013), 1, + ACTIONS(1145), 2, + anon_sym_DOT, + anon_sym_LBRACE, + [15383] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1217), 1, sym_ident, - [10516] = 3, + ACTIONS(1219), 1, + anon_sym_LBRACE, + [15393] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1015), 1, + ACTIONS(1221), 1, anon_sym_LBRACK, - ACTIONS(1017), 1, + ACTIONS(1223), 1, anon_sym_LBRACE, - [10526] = 2, + [15403] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(947), 2, - anon_sym_DOT, + ACTIONS(1225), 1, + anon_sym_LBRACK, + ACTIONS(1227), 1, anon_sym_LBRACE, - [10534] = 2, + [15413] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1019), 1, + ACTIONS(1229), 1, + anon_sym_LBRACK, + ACTIONS(1231), 1, anon_sym_LBRACE, - [10541] = 2, + [15423] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1021), 1, + ACTIONS(1233), 1, + anon_sym_LBRACK, + ACTIONS(1235), 1, anon_sym_LBRACE, - [10548] = 2, + [15433] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1023), 1, - anon_sym_LBRACE, - [10555] = 2, + ACTIONS(1237), 1, + sym_ident, + ACTIONS(1239), 1, + anon_sym_RBRACK, + [15443] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1025), 1, - sym_import_path, - [10562] = 2, + ACTIONS(1064), 1, + sym_ident, + STATE(367), 1, + sym_field_initializer, + [15453] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1027), 1, + ACTIONS(1157), 1, + anon_sym_RBRACK, + ACTIONS(1241), 1, sym_ident, - [10569] = 2, + [15463] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1029), 1, + ACTIONS(1195), 1, + anon_sym_RBRACK, + ACTIONS(1243), 1, sym_ident, - [10576] = 2, + [15473] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1031), 1, + ACTIONS(1064), 1, sym_ident, - [10583] = 2, + STATE(379), 1, + sym_field_initializer, + [15483] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1033), 1, + ACTIONS(1245), 1, sym_ident, - [10590] = 2, + ACTIONS(1247), 1, + anon_sym_RBRACK, + [15493] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1035), 1, - anon_sym_LBRACE, - [10597] = 2, + ACTIONS(1197), 1, + anon_sym_RBRACK, + ACTIONS(1249), 1, + sym_ident, + [15503] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1037), 1, + ACTIONS(501), 1, anon_sym_LBRACE, - [10604] = 2, + ACTIONS(1251), 1, + sym_ident, + [15513] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1039), 1, + ACTIONS(1064), 1, sym_ident, - [10611] = 2, + STATE(344), 1, + sym_field_initializer, + [15523] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(977), 1, - anon_sym_LBRACE, - [10618] = 2, + ACTIONS(1253), 1, + sym_number, + [15530] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1041), 1, + ACTIONS(1255), 1, anon_sym_LBRACE, - [10625] = 2, + [15537] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1043), 1, - ts_builtin_sym_end, - [10632] = 2, + ACTIONS(1257), 1, + anon_sym_RBRACE, + [15544] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1045), 1, + ACTIONS(1259), 1, anon_sym_LBRACE, - [10639] = 2, + [15551] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(972), 1, + ACTIONS(1261), 1, + sym_ident, + [15558] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1263), 1, anon_sym_LBRACE, - [10646] = 2, + [15565] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1047), 1, + ACTIONS(1265), 1, sym_ident, - [10653] = 2, + [15572] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1186), 1, + anon_sym_LBRACE, + [15579] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1267), 1, + anon_sym_LBRACE, + [15586] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1269), 1, + anon_sym_LBRACE, + [15593] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1049), 1, + ACTIONS(1271), 1, anon_sym_RBRACE, - [10660] = 2, + [15600] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1051), 1, + ACTIONS(1273), 1, + anon_sym_LBRACE, + [15607] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1275), 1, sym_ident, - [10667] = 2, + [15614] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1017), 1, + ACTIONS(1277), 1, anon_sym_LBRACE, - [10674] = 2, + [15621] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1279), 1, + sym_ident, + [15628] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1053), 1, + ACTIONS(1281), 1, anon_sym_GT, - [10681] = 2, + [15635] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1055), 1, - sym_number, - [10688] = 2, + ACTIONS(1283), 1, + sym_ident, + [15642] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1057), 1, + ACTIONS(1285), 1, sym_ident, - [10695] = 2, + [15649] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1059), 1, + ACTIONS(1287), 1, + sym_import_path, + [15656] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1289), 1, anon_sym_LBRACE, - [10702] = 2, + [15663] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1061), 1, + ACTIONS(1291), 1, sym_ident, - [10709] = 2, + [15670] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1063), 1, + ACTIONS(1293), 1, sym_ident, - [10716] = 2, + [15677] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1065), 1, + ACTIONS(1161), 1, anon_sym_LBRACE, - [10723] = 2, + [15684] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1067), 1, + ACTIONS(1295), 1, sym_ident, - [10730] = 2, + [15691] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1069), 1, + ACTIONS(1297), 1, anon_sym_LBRACE, - [10737] = 2, + [15698] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1299), 1, + sym_ident, + [15705] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1301), 1, + sym_ident, + [15712] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(987), 1, + ACTIONS(1211), 1, anon_sym_LBRACE, - [10744] = 2, + [15719] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1303), 1, + anon_sym_GT, + [15726] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1071), 1, + ACTIONS(1305), 1, + ts_builtin_sym_end, + [15733] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1307), 1, sym_ident, - [10751] = 2, + [15740] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1309), 1, + anon_sym_LBRACE, + [15747] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1311), 1, + anon_sym_LBRACE, + [15754] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1159), 1, + anon_sym_LBRACE, + [15761] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1073), 1, + ACTIONS(1313), 1, sym_ident, - [10758] = 2, + [15768] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1075), 1, + ACTIONS(1235), 1, anon_sym_LBRACE, - [10765] = 2, + [15775] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1077), 1, + ACTIONS(1315), 1, anon_sym_LBRACE, - [10772] = 2, + [15782] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1079), 1, + ACTIONS(1317), 1, anon_sym_LBRACE, - [10779] = 2, + [15789] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(458), 1, - anon_sym_COLON, - [10786] = 2, + ACTIONS(1319), 1, + anon_sym_LBRACE, + [15796] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(942), 1, + ACTIONS(1321), 1, anon_sym_LBRACE, - [10793] = 2, + [15803] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1081), 1, - anon_sym_RBRACE, - [10800] = 2, + ACTIONS(1323), 1, + anon_sym_LBRACE, + [15810] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1083), 1, - anon_sym_GT, - [10807] = 2, + ACTIONS(1325), 1, + sym_ident, + [15817] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1327), 1, + anon_sym_EQ, + [15824] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1329), 1, + anon_sym_RBRACE, + [15831] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1085), 1, + ACTIONS(1331), 1, anon_sym_LBRACE, - [10814] = 2, + [15838] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1087), 1, + ACTIONS(1333), 1, anon_sym_GT, - [10821] = 2, + [15845] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1089), 1, + ACTIONS(1335), 1, sym_ident, - [10828] = 2, + [15852] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1091), 1, + ACTIONS(1337), 1, sym_ident, - [10835] = 2, + [15859] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1339), 1, + anon_sym_LBRACE, + [15866] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1093), 1, + ACTIONS(1153), 1, + anon_sym_LBRACE, + [15873] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1341), 1, sym_ident, + [15880] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1343), 1, + anon_sym_LBRACE, + [15887] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(549), 1, + anon_sym_COLON, + [15894] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1345), 1, + anon_sym_RBRACE, }; static const uint32_t ts_small_parse_table_map[] = { - [SMALL_STATE(52)] = 0, - [SMALL_STATE(53)] = 80, - [SMALL_STATE(54)] = 135, - [SMALL_STATE(55)] = 190, - [SMALL_STATE(56)] = 245, - [SMALL_STATE(57)] = 300, - [SMALL_STATE(58)] = 355, - [SMALL_STATE(59)] = 410, - [SMALL_STATE(60)] = 465, - [SMALL_STATE(61)] = 526, - [SMALL_STATE(62)] = 581, - [SMALL_STATE(63)] = 636, - [SMALL_STATE(64)] = 691, - [SMALL_STATE(65)] = 746, - [SMALL_STATE(66)] = 801, - [SMALL_STATE(67)] = 856, - [SMALL_STATE(68)] = 911, - [SMALL_STATE(69)] = 966, - [SMALL_STATE(70)] = 1021, - [SMALL_STATE(71)] = 1076, - [SMALL_STATE(72)] = 1131, - [SMALL_STATE(73)] = 1186, - [SMALL_STATE(74)] = 1241, - [SMALL_STATE(75)] = 1296, - [SMALL_STATE(76)] = 1351, - [SMALL_STATE(77)] = 1408, - [SMALL_STATE(78)] = 1463, - [SMALL_STATE(79)] = 1518, - [SMALL_STATE(80)] = 1573, - [SMALL_STATE(81)] = 1628, - [SMALL_STATE(82)] = 1683, - [SMALL_STATE(83)] = 1738, - [SMALL_STATE(84)] = 1795, - [SMALL_STATE(85)] = 1858, - [SMALL_STATE(86)] = 1925, - [SMALL_STATE(87)] = 1982, - [SMALL_STATE(88)] = 2047, - [SMALL_STATE(89)] = 2102, - [SMALL_STATE(90)] = 2157, - [SMALL_STATE(91)] = 2216, - [SMALL_STATE(92)] = 2273, - [SMALL_STATE(93)] = 2335, - [SMALL_STATE(94)] = 2391, - [SMALL_STATE(95)] = 2447, - [SMALL_STATE(96)] = 2499, - [SMALL_STATE(97)] = 2551, - [SMALL_STATE(98)] = 2617, - [SMALL_STATE(99)] = 2673, - [SMALL_STATE(100)] = 2729, - [SMALL_STATE(101)] = 2795, - [SMALL_STATE(102)] = 2851, - [SMALL_STATE(103)] = 2903, - [SMALL_STATE(104)] = 2955, - [SMALL_STATE(105)] = 3021, - [SMALL_STATE(106)] = 3076, - [SMALL_STATE(107)] = 3127, - [SMALL_STATE(108)] = 3175, - [SMALL_STATE(109)] = 3223, - [SMALL_STATE(110)] = 3275, - [SMALL_STATE(111)] = 3325, - [SMALL_STATE(112)] = 3377, - [SMALL_STATE(113)] = 3423, - [SMALL_STATE(114)] = 3473, - [SMALL_STATE(115)] = 3518, - [SMALL_STATE(116)] = 3567, - [SMALL_STATE(117)] = 3616, - [SMALL_STATE(118)] = 3665, - [SMALL_STATE(119)] = 3714, - [SMALL_STATE(120)] = 3763, - [SMALL_STATE(121)] = 3810, - [SMALL_STATE(122)] = 3855, - [SMALL_STATE(123)] = 3900, - [SMALL_STATE(124)] = 3944, - [SMALL_STATE(125)] = 4012, - [SMALL_STATE(126)] = 4080, - [SMALL_STATE(127)] = 4148, - [SMALL_STATE(128)] = 4216, - [SMALL_STATE(129)] = 4259, - [SMALL_STATE(130)] = 4302, - [SMALL_STATE(131)] = 4345, - [SMALL_STATE(132)] = 4388, - [SMALL_STATE(133)] = 4453, - [SMALL_STATE(134)] = 4518, - [SMALL_STATE(135)] = 4561, - [SMALL_STATE(136)] = 4604, - [SMALL_STATE(137)] = 4647, - [SMALL_STATE(138)] = 4690, - [SMALL_STATE(139)] = 4733, - [SMALL_STATE(140)] = 4798, - [SMALL_STATE(141)] = 4841, - [SMALL_STATE(142)] = 4884, - [SMALL_STATE(143)] = 4927, - [SMALL_STATE(144)] = 4970, - [SMALL_STATE(145)] = 5035, - [SMALL_STATE(146)] = 5100, - [SMALL_STATE(147)] = 5165, - [SMALL_STATE(148)] = 5208, - [SMALL_STATE(149)] = 5251, - [SMALL_STATE(150)] = 5316, - [SMALL_STATE(151)] = 5359, - [SMALL_STATE(152)] = 5430, - [SMALL_STATE(153)] = 5473, - [SMALL_STATE(154)] = 5538, - [SMALL_STATE(155)] = 5585, - [SMALL_STATE(156)] = 5650, - [SMALL_STATE(157)] = 5693, - [SMALL_STATE(158)] = 5738, - [SMALL_STATE(159)] = 5781, - [SMALL_STATE(160)] = 5852, - [SMALL_STATE(161)] = 5895, - [SMALL_STATE(162)] = 5938, - [SMALL_STATE(163)] = 6003, - [SMALL_STATE(164)] = 6046, - [SMALL_STATE(165)] = 6111, - [SMALL_STATE(166)] = 6173, - [SMALL_STATE(167)] = 6235, - [SMALL_STATE(168)] = 6297, - [SMALL_STATE(169)] = 6359, - [SMALL_STATE(170)] = 6421, - [SMALL_STATE(171)] = 6483, - [SMALL_STATE(172)] = 6545, - [SMALL_STATE(173)] = 6607, - [SMALL_STATE(174)] = 6669, - [SMALL_STATE(175)] = 6731, - [SMALL_STATE(176)] = 6793, - [SMALL_STATE(177)] = 6855, - [SMALL_STATE(178)] = 6917, - [SMALL_STATE(179)] = 6979, - [SMALL_STATE(180)] = 7041, - [SMALL_STATE(181)] = 7103, - [SMALL_STATE(182)] = 7165, - [SMALL_STATE(183)] = 7227, - [SMALL_STATE(184)] = 7289, - [SMALL_STATE(185)] = 7351, - [SMALL_STATE(186)] = 7413, - [SMALL_STATE(187)] = 7475, - [SMALL_STATE(188)] = 7537, - [SMALL_STATE(189)] = 7599, - [SMALL_STATE(190)] = 7661, - [SMALL_STATE(191)] = 7723, - [SMALL_STATE(192)] = 7785, - [SMALL_STATE(193)] = 7847, - [SMALL_STATE(194)] = 7909, - [SMALL_STATE(195)] = 7971, - [SMALL_STATE(196)] = 8033, - [SMALL_STATE(197)] = 8095, - [SMALL_STATE(198)] = 8157, - [SMALL_STATE(199)] = 8219, - [SMALL_STATE(200)] = 8281, - [SMALL_STATE(201)] = 8317, - [SMALL_STATE(202)] = 8354, - [SMALL_STATE(203)] = 8397, - [SMALL_STATE(204)] = 8442, - [SMALL_STATE(205)] = 8477, - [SMALL_STATE(206)] = 8516, - [SMALL_STATE(207)] = 8555, - [SMALL_STATE(208)] = 8594, - [SMALL_STATE(209)] = 8640, - [SMALL_STATE(210)] = 8686, - [SMALL_STATE(211)] = 8716, - [SMALL_STATE(212)] = 8752, - [SMALL_STATE(213)] = 8791, - [SMALL_STATE(214)] = 8834, - [SMALL_STATE(215)] = 8877, - [SMALL_STATE(216)] = 8916, - [SMALL_STATE(217)] = 8955, - [SMALL_STATE(218)] = 8998, - [SMALL_STATE(219)] = 9036, - [SMALL_STATE(220)] = 9074, - [SMALL_STATE(221)] = 9111, - [SMALL_STATE(222)] = 9154, - [SMALL_STATE(223)] = 9191, - [SMALL_STATE(224)] = 9234, - [SMALL_STATE(225)] = 9271, - [SMALL_STATE(226)] = 9308, - [SMALL_STATE(227)] = 9351, - [SMALL_STATE(228)] = 9388, - [SMALL_STATE(229)] = 9425, - [SMALL_STATE(230)] = 9462, - [SMALL_STATE(231)] = 9496, - [SMALL_STATE(232)] = 9530, - [SMALL_STATE(233)] = 9551, - [SMALL_STATE(234)] = 9572, - [SMALL_STATE(235)] = 9593, - [SMALL_STATE(236)] = 9614, - [SMALL_STATE(237)] = 9635, - [SMALL_STATE(238)] = 9656, - [SMALL_STATE(239)] = 9677, - [SMALL_STATE(240)] = 9698, - [SMALL_STATE(241)] = 9719, - [SMALL_STATE(242)] = 9740, - [SMALL_STATE(243)] = 9768, - [SMALL_STATE(244)] = 9791, - [SMALL_STATE(245)] = 9810, - [SMALL_STATE(246)] = 9829, - [SMALL_STATE(247)] = 9845, - [SMALL_STATE(248)] = 9861, - [SMALL_STATE(249)] = 9877, - [SMALL_STATE(250)] = 9893, - [SMALL_STATE(251)] = 9909, - [SMALL_STATE(252)] = 9925, - [SMALL_STATE(253)] = 9941, - [SMALL_STATE(254)] = 9957, - [SMALL_STATE(255)] = 9973, - [SMALL_STATE(256)] = 9989, - [SMALL_STATE(257)] = 10005, - [SMALL_STATE(258)] = 10021, - [SMALL_STATE(259)] = 10037, - [SMALL_STATE(260)] = 10053, - [SMALL_STATE(261)] = 10066, - [SMALL_STATE(262)] = 10079, - [SMALL_STATE(263)] = 10090, - [SMALL_STATE(264)] = 10103, - [SMALL_STATE(265)] = 10116, - [SMALL_STATE(266)] = 10129, - [SMALL_STATE(267)] = 10142, - [SMALL_STATE(268)] = 10151, - [SMALL_STATE(269)] = 10164, - [SMALL_STATE(270)] = 10177, - [SMALL_STATE(271)] = 10190, - [SMALL_STATE(272)] = 10203, - [SMALL_STATE(273)] = 10216, - [SMALL_STATE(274)] = 10229, - [SMALL_STATE(275)] = 10242, - [SMALL_STATE(276)] = 10255, - [SMALL_STATE(277)] = 10268, - [SMALL_STATE(278)] = 10281, - [SMALL_STATE(279)] = 10294, - [SMALL_STATE(280)] = 10307, - [SMALL_STATE(281)] = 10320, - [SMALL_STATE(282)] = 10329, - [SMALL_STATE(283)] = 10342, - [SMALL_STATE(284)] = 10355, - [SMALL_STATE(285)] = 10368, - [SMALL_STATE(286)] = 10381, - [SMALL_STATE(287)] = 10394, - [SMALL_STATE(288)] = 10407, - [SMALL_STATE(289)] = 10420, - [SMALL_STATE(290)] = 10430, - [SMALL_STATE(291)] = 10440, - [SMALL_STATE(292)] = 10450, - [SMALL_STATE(293)] = 10460, - [SMALL_STATE(294)] = 10468, - [SMALL_STATE(295)] = 10478, - [SMALL_STATE(296)] = 10488, - [SMALL_STATE(297)] = 10496, - [SMALL_STATE(298)] = 10506, - [SMALL_STATE(299)] = 10516, - [SMALL_STATE(300)] = 10526, - [SMALL_STATE(301)] = 10534, - [SMALL_STATE(302)] = 10541, - [SMALL_STATE(303)] = 10548, - [SMALL_STATE(304)] = 10555, - [SMALL_STATE(305)] = 10562, - [SMALL_STATE(306)] = 10569, - [SMALL_STATE(307)] = 10576, - [SMALL_STATE(308)] = 10583, - [SMALL_STATE(309)] = 10590, - [SMALL_STATE(310)] = 10597, - [SMALL_STATE(311)] = 10604, - [SMALL_STATE(312)] = 10611, - [SMALL_STATE(313)] = 10618, - [SMALL_STATE(314)] = 10625, - [SMALL_STATE(315)] = 10632, - [SMALL_STATE(316)] = 10639, - [SMALL_STATE(317)] = 10646, - [SMALL_STATE(318)] = 10653, - [SMALL_STATE(319)] = 10660, - [SMALL_STATE(320)] = 10667, - [SMALL_STATE(321)] = 10674, - [SMALL_STATE(322)] = 10681, - [SMALL_STATE(323)] = 10688, - [SMALL_STATE(324)] = 10695, - [SMALL_STATE(325)] = 10702, - [SMALL_STATE(326)] = 10709, - [SMALL_STATE(327)] = 10716, - [SMALL_STATE(328)] = 10723, - [SMALL_STATE(329)] = 10730, - [SMALL_STATE(330)] = 10737, - [SMALL_STATE(331)] = 10744, - [SMALL_STATE(332)] = 10751, - [SMALL_STATE(333)] = 10758, - [SMALL_STATE(334)] = 10765, - [SMALL_STATE(335)] = 10772, - [SMALL_STATE(336)] = 10779, - [SMALL_STATE(337)] = 10786, - [SMALL_STATE(338)] = 10793, - [SMALL_STATE(339)] = 10800, - [SMALL_STATE(340)] = 10807, - [SMALL_STATE(341)] = 10814, - [SMALL_STATE(342)] = 10821, - [SMALL_STATE(343)] = 10828, - [SMALL_STATE(344)] = 10835, + [SMALL_STATE(70)] = 0, + [SMALL_STATE(71)] = 84, + [SMALL_STATE(72)] = 152, + [SMALL_STATE(73)] = 222, + [SMALL_STATE(74)] = 278, + [SMALL_STATE(75)] = 338, + [SMALL_STATE(76)] = 394, + [SMALL_STATE(77)] = 450, + [SMALL_STATE(78)] = 506, + [SMALL_STATE(79)] = 562, + [SMALL_STATE(80)] = 618, + [SMALL_STATE(81)] = 688, + [SMALL_STATE(82)] = 752, + [SMALL_STATE(83)] = 814, + [SMALL_STATE(84)] = 872, + [SMALL_STATE(85)] = 940, + [SMALL_STATE(86)] = 1012, + [SMALL_STATE(87)] = 1088, + [SMALL_STATE(88)] = 1162, + [SMALL_STATE(89)] = 1222, + [SMALL_STATE(90)] = 1278, + [SMALL_STATE(91)] = 1334, + [SMALL_STATE(92)] = 1412, + [SMALL_STATE(93)] = 1468, + [SMALL_STATE(94)] = 1526, + [SMALL_STATE(95)] = 1582, + [SMALL_STATE(96)] = 1638, + [SMALL_STATE(97)] = 1694, + [SMALL_STATE(98)] = 1750, + [SMALL_STATE(99)] = 1806, + [SMALL_STATE(100)] = 1862, + [SMALL_STATE(101)] = 1918, + [SMALL_STATE(102)] = 1974, + [SMALL_STATE(103)] = 2030, + [SMALL_STATE(104)] = 2086, + [SMALL_STATE(105)] = 2142, + [SMALL_STATE(106)] = 2198, + [SMALL_STATE(107)] = 2254, + [SMALL_STATE(108)] = 2310, + [SMALL_STATE(109)] = 2366, + [SMALL_STATE(110)] = 2422, + [SMALL_STATE(111)] = 2478, + [SMALL_STATE(112)] = 2534, + [SMALL_STATE(113)] = 2596, + [SMALL_STATE(114)] = 2652, + [SMALL_STATE(115)] = 2710, + [SMALL_STATE(116)] = 2770, + [SMALL_STATE(117)] = 2826, + [SMALL_STATE(118)] = 2903, + [SMALL_STATE(119)] = 2980, + [SMALL_STATE(120)] = 3039, + [SMALL_STATE(121)] = 3094, + [SMALL_STATE(122)] = 3149, + [SMALL_STATE(123)] = 3214, + [SMALL_STATE(124)] = 3273, + [SMALL_STATE(125)] = 3350, + [SMALL_STATE(126)] = 3409, + [SMALL_STATE(127)] = 3464, + [SMALL_STATE(128)] = 3523, + [SMALL_STATE(129)] = 3578, + [SMALL_STATE(130)] = 3637, + [SMALL_STATE(131)] = 3695, + [SMALL_STATE(132)] = 3747, + [SMALL_STATE(133)] = 3798, + [SMALL_STATE(134)] = 3851, + [SMALL_STATE(135)] = 3898, + [SMALL_STATE(136)] = 3949, + [SMALL_STATE(137)] = 3998, + [SMALL_STATE(138)] = 4047, + [SMALL_STATE(139)] = 4100, + [SMALL_STATE(140)] = 4150, + [SMALL_STATE(141)] = 4196, + [SMALL_STATE(142)] = 4246, + [SMALL_STATE(143)] = 4296, + [SMALL_STATE(144)] = 4342, + [SMALL_STATE(145)] = 4388, + [SMALL_STATE(146)] = 4438, + [SMALL_STATE(147)] = 4510, + [SMALL_STATE(148)] = 4582, + [SMALL_STATE(149)] = 4654, + [SMALL_STATE(150)] = 4726, + [SMALL_STATE(151)] = 4798, + [SMALL_STATE(152)] = 4870, + [SMALL_STATE(153)] = 4942, + [SMALL_STATE(154)] = 5014, + [SMALL_STATE(155)] = 5064, + [SMALL_STATE(156)] = 5112, + [SMALL_STATE(157)] = 5184, + [SMALL_STATE(158)] = 5230, + [SMALL_STATE(159)] = 5299, + [SMALL_STATE(160)] = 5368, + [SMALL_STATE(161)] = 5437, + [SMALL_STATE(162)] = 5506, + [SMALL_STATE(163)] = 5575, + [SMALL_STATE(164)] = 5644, + [SMALL_STATE(165)] = 5713, + [SMALL_STATE(166)] = 5788, + [SMALL_STATE(167)] = 5857, + [SMALL_STATE(168)] = 5926, + [SMALL_STATE(169)] = 5971, + [SMALL_STATE(170)] = 6046, + [SMALL_STATE(171)] = 6115, + [SMALL_STATE(172)] = 6184, + [SMALL_STATE(173)] = 6253, + [SMALL_STATE(174)] = 6322, + [SMALL_STATE(175)] = 6391, + [SMALL_STATE(176)] = 6460, + [SMALL_STATE(177)] = 6529, + [SMALL_STATE(178)] = 6598, + [SMALL_STATE(179)] = 6667, + [SMALL_STATE(180)] = 6736, + [SMALL_STATE(181)] = 6805, + [SMALL_STATE(182)] = 6871, + [SMALL_STATE(183)] = 6915, + [SMALL_STATE(184)] = 6959, + [SMALL_STATE(185)] = 7025, + [SMALL_STATE(186)] = 7069, + [SMALL_STATE(187)] = 7135, + [SMALL_STATE(188)] = 7201, + [SMALL_STATE(189)] = 7245, + [SMALL_STATE(190)] = 7311, + [SMALL_STATE(191)] = 7377, + [SMALL_STATE(192)] = 7443, + [SMALL_STATE(193)] = 7487, + [SMALL_STATE(194)] = 7553, + [SMALL_STATE(195)] = 7601, + [SMALL_STATE(196)] = 7645, + [SMALL_STATE(197)] = 7711, + [SMALL_STATE(198)] = 7755, + [SMALL_STATE(199)] = 7821, + [SMALL_STATE(200)] = 7887, + [SMALL_STATE(201)] = 7953, + [SMALL_STATE(202)] = 7997, + [SMALL_STATE(203)] = 8043, + [SMALL_STATE(204)] = 8087, + [SMALL_STATE(205)] = 8131, + [SMALL_STATE(206)] = 8175, + [SMALL_STATE(207)] = 8241, + [SMALL_STATE(208)] = 8285, + [SMALL_STATE(209)] = 8351, + [SMALL_STATE(210)] = 8395, + [SMALL_STATE(211)] = 8439, + [SMALL_STATE(212)] = 8505, + [SMALL_STATE(213)] = 8549, + [SMALL_STATE(214)] = 8615, + [SMALL_STATE(215)] = 8681, + [SMALL_STATE(216)] = 8747, + [SMALL_STATE(217)] = 8813, + [SMALL_STATE(218)] = 8879, + [SMALL_STATE(219)] = 8923, + [SMALL_STATE(220)] = 8989, + [SMALL_STATE(221)] = 9055, + [SMALL_STATE(222)] = 9121, + [SMALL_STATE(223)] = 9187, + [SMALL_STATE(224)] = 9253, + [SMALL_STATE(225)] = 9319, + [SMALL_STATE(226)] = 9385, + [SMALL_STATE(227)] = 9451, + [SMALL_STATE(228)] = 9517, + [SMALL_STATE(229)] = 9583, + [SMALL_STATE(230)] = 9649, + [SMALL_STATE(231)] = 9715, + [SMALL_STATE(232)] = 9781, + [SMALL_STATE(233)] = 9847, + [SMALL_STATE(234)] = 9891, + [SMALL_STATE(235)] = 9935, + [SMALL_STATE(236)] = 9979, + [SMALL_STATE(237)] = 10045, + [SMALL_STATE(238)] = 10111, + [SMALL_STATE(239)] = 10177, + [SMALL_STATE(240)] = 10221, + [SMALL_STATE(241)] = 10287, + [SMALL_STATE(242)] = 10331, + [SMALL_STATE(243)] = 10375, + [SMALL_STATE(244)] = 10419, + [SMALL_STATE(245)] = 10463, + [SMALL_STATE(246)] = 10529, + [SMALL_STATE(247)] = 10595, + [SMALL_STATE(248)] = 10661, + [SMALL_STATE(249)] = 10727, + [SMALL_STATE(250)] = 10771, + [SMALL_STATE(251)] = 10837, + [SMALL_STATE(252)] = 10903, + [SMALL_STATE(253)] = 10947, + [SMALL_STATE(254)] = 10988, + [SMALL_STATE(255)] = 11028, + [SMALL_STATE(256)] = 11066, + [SMALL_STATE(257)] = 11104, + [SMALL_STATE(258)] = 11142, + [SMALL_STATE(259)] = 11180, + [SMALL_STATE(260)] = 11218, + [SMALL_STATE(261)] = 11256, + [SMALL_STATE(262)] = 11294, + [SMALL_STATE(263)] = 11332, + [SMALL_STATE(264)] = 11370, + [SMALL_STATE(265)] = 11408, + [SMALL_STATE(266)] = 11446, + [SMALL_STATE(267)] = 11484, + [SMALL_STATE(268)] = 11522, + [SMALL_STATE(269)] = 11560, + [SMALL_STATE(270)] = 11598, + [SMALL_STATE(271)] = 11636, + [SMALL_STATE(272)] = 11680, + [SMALL_STATE(273)] = 11718, + [SMALL_STATE(274)] = 11756, + [SMALL_STATE(275)] = 11794, + [SMALL_STATE(276)] = 11832, + [SMALL_STATE(277)] = 11870, + [SMALL_STATE(278)] = 11910, + [SMALL_STATE(279)] = 11948, + [SMALL_STATE(280)] = 11986, + [SMALL_STATE(281)] = 12024, + [SMALL_STATE(282)] = 12062, + [SMALL_STATE(283)] = 12100, + [SMALL_STATE(284)] = 12138, + [SMALL_STATE(285)] = 12190, + [SMALL_STATE(286)] = 12236, + [SMALL_STATE(287)] = 12280, + [SMALL_STATE(288)] = 12318, + [SMALL_STATE(289)] = 12368, + [SMALL_STATE(290)] = 12422, + [SMALL_STATE(291)] = 12480, + [SMALL_STATE(292)] = 12536, + [SMALL_STATE(293)] = 12578, + [SMALL_STATE(294)] = 12616, + [SMALL_STATE(295)] = 12660, + [SMALL_STATE(296)] = 12704, + [SMALL_STATE(297)] = 12748, + [SMALL_STATE(298)] = 12807, + [SMALL_STATE(299)] = 12866, + [SMALL_STATE(300)] = 12901, + [SMALL_STATE(301)] = 12960, + [SMALL_STATE(302)] = 13019, + [SMALL_STATE(303)] = 13054, + [SMALL_STATE(304)] = 13095, + [SMALL_STATE(305)] = 13151, + [SMALL_STATE(306)] = 13203, + [SMALL_STATE(307)] = 13255, + [SMALL_STATE(308)] = 13311, + [SMALL_STATE(309)] = 13367, + [SMALL_STATE(310)] = 13423, + [SMALL_STATE(311)] = 13475, + [SMALL_STATE(312)] = 13526, + [SMALL_STATE(313)] = 13577, + [SMALL_STATE(314)] = 13627, + [SMALL_STATE(315)] = 13677, + [SMALL_STATE(316)] = 13727, + [SMALL_STATE(317)] = 13777, + [SMALL_STATE(318)] = 13827, + [SMALL_STATE(319)] = 13877, + [SMALL_STATE(320)] = 13927, + [SMALL_STATE(321)] = 13977, + [SMALL_STATE(322)] = 14027, + [SMALL_STATE(323)] = 14074, + [SMALL_STATE(324)] = 14121, + [SMALL_STATE(325)] = 14167, + [SMALL_STATE(326)] = 14213, + [SMALL_STATE(327)] = 14259, + [SMALL_STATE(328)] = 14280, + [SMALL_STATE(329)] = 14311, + [SMALL_STATE(330)] = 14332, + [SMALL_STATE(331)] = 14353, + [SMALL_STATE(332)] = 14374, + [SMALL_STATE(333)] = 14395, + [SMALL_STATE(334)] = 14416, + [SMALL_STATE(335)] = 14437, + [SMALL_STATE(336)] = 14458, + [SMALL_STATE(337)] = 14479, + [SMALL_STATE(338)] = 14500, + [SMALL_STATE(339)] = 14526, + [SMALL_STATE(340)] = 14545, + [SMALL_STATE(341)] = 14564, + [SMALL_STATE(342)] = 14583, + [SMALL_STATE(343)] = 14602, + [SMALL_STATE(344)] = 14618, + [SMALL_STATE(345)] = 14634, + [SMALL_STATE(346)] = 14650, + [SMALL_STATE(347)] = 14666, + [SMALL_STATE(348)] = 14682, + [SMALL_STATE(349)] = 14698, + [SMALL_STATE(350)] = 14714, + [SMALL_STATE(351)] = 14730, + [SMALL_STATE(352)] = 14746, + [SMALL_STATE(353)] = 14762, + [SMALL_STATE(354)] = 14778, + [SMALL_STATE(355)] = 14794, + [SMALL_STATE(356)] = 14810, + [SMALL_STATE(357)] = 14826, + [SMALL_STATE(358)] = 14842, + [SMALL_STATE(359)] = 14858, + [SMALL_STATE(360)] = 14871, + [SMALL_STATE(361)] = 14884, + [SMALL_STATE(362)] = 14897, + [SMALL_STATE(363)] = 14910, + [SMALL_STATE(364)] = 14923, + [SMALL_STATE(365)] = 14936, + [SMALL_STATE(366)] = 14949, + [SMALL_STATE(367)] = 14962, + [SMALL_STATE(368)] = 14971, + [SMALL_STATE(369)] = 14984, + [SMALL_STATE(370)] = 14997, + [SMALL_STATE(371)] = 15010, + [SMALL_STATE(372)] = 15023, + [SMALL_STATE(373)] = 15036, + [SMALL_STATE(374)] = 15049, + [SMALL_STATE(375)] = 15062, + [SMALL_STATE(376)] = 15075, + [SMALL_STATE(377)] = 15088, + [SMALL_STATE(378)] = 15101, + [SMALL_STATE(379)] = 15114, + [SMALL_STATE(380)] = 15123, + [SMALL_STATE(381)] = 15136, + [SMALL_STATE(382)] = 15147, + [SMALL_STATE(383)] = 15160, + [SMALL_STATE(384)] = 15173, + [SMALL_STATE(385)] = 15186, + [SMALL_STATE(386)] = 15199, + [SMALL_STATE(387)] = 15212, + [SMALL_STATE(388)] = 15225, + [SMALL_STATE(389)] = 15238, + [SMALL_STATE(390)] = 15251, + [SMALL_STATE(391)] = 15264, + [SMALL_STATE(392)] = 15277, + [SMALL_STATE(393)] = 15290, + [SMALL_STATE(394)] = 15303, + [SMALL_STATE(395)] = 15316, + [SMALL_STATE(396)] = 15329, + [SMALL_STATE(397)] = 15337, + [SMALL_STATE(398)] = 15345, + [SMALL_STATE(399)] = 15355, + [SMALL_STATE(400)] = 15365, + [SMALL_STATE(401)] = 15375, + [SMALL_STATE(402)] = 15383, + [SMALL_STATE(403)] = 15393, + [SMALL_STATE(404)] = 15403, + [SMALL_STATE(405)] = 15413, + [SMALL_STATE(406)] = 15423, + [SMALL_STATE(407)] = 15433, + [SMALL_STATE(408)] = 15443, + [SMALL_STATE(409)] = 15453, + [SMALL_STATE(410)] = 15463, + [SMALL_STATE(411)] = 15473, + [SMALL_STATE(412)] = 15483, + [SMALL_STATE(413)] = 15493, + [SMALL_STATE(414)] = 15503, + [SMALL_STATE(415)] = 15513, + [SMALL_STATE(416)] = 15523, + [SMALL_STATE(417)] = 15530, + [SMALL_STATE(418)] = 15537, + [SMALL_STATE(419)] = 15544, + [SMALL_STATE(420)] = 15551, + [SMALL_STATE(421)] = 15558, + [SMALL_STATE(422)] = 15565, + [SMALL_STATE(423)] = 15572, + [SMALL_STATE(424)] = 15579, + [SMALL_STATE(425)] = 15586, + [SMALL_STATE(426)] = 15593, + [SMALL_STATE(427)] = 15600, + [SMALL_STATE(428)] = 15607, + [SMALL_STATE(429)] = 15614, + [SMALL_STATE(430)] = 15621, + [SMALL_STATE(431)] = 15628, + [SMALL_STATE(432)] = 15635, + [SMALL_STATE(433)] = 15642, + [SMALL_STATE(434)] = 15649, + [SMALL_STATE(435)] = 15656, + [SMALL_STATE(436)] = 15663, + [SMALL_STATE(437)] = 15670, + [SMALL_STATE(438)] = 15677, + [SMALL_STATE(439)] = 15684, + [SMALL_STATE(440)] = 15691, + [SMALL_STATE(441)] = 15698, + [SMALL_STATE(442)] = 15705, + [SMALL_STATE(443)] = 15712, + [SMALL_STATE(444)] = 15719, + [SMALL_STATE(445)] = 15726, + [SMALL_STATE(446)] = 15733, + [SMALL_STATE(447)] = 15740, + [SMALL_STATE(448)] = 15747, + [SMALL_STATE(449)] = 15754, + [SMALL_STATE(450)] = 15761, + [SMALL_STATE(451)] = 15768, + [SMALL_STATE(452)] = 15775, + [SMALL_STATE(453)] = 15782, + [SMALL_STATE(454)] = 15789, + [SMALL_STATE(455)] = 15796, + [SMALL_STATE(456)] = 15803, + [SMALL_STATE(457)] = 15810, + [SMALL_STATE(458)] = 15817, + [SMALL_STATE(459)] = 15824, + [SMALL_STATE(460)] = 15831, + [SMALL_STATE(461)] = 15838, + [SMALL_STATE(462)] = 15845, + [SMALL_STATE(463)] = 15852, + [SMALL_STATE(464)] = 15859, + [SMALL_STATE(465)] = 15866, + [SMALL_STATE(466)] = 15873, + [SMALL_STATE(467)] = 15880, + [SMALL_STATE(468)] = 15887, + [SMALL_STATE(469)] = 15894, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -15343,528 +21404,650 @@ static const TSParseActionEntry ts_parse_actions[] = { [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), - [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(76), - [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), - [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), - [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), - [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), - [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), - [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), - [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), - [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), - [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), - [43] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), - [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304), - [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(92), - [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(105), - [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [65] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [69] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), - [71] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(76), - [74] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(8), - [77] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(256), - [80] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(308), - [83] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(166), - [86] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(52), - [89] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(319), - [92] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(89), - [95] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(126), - [98] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(325), - [101] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(245), - [104] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(178), - [107] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(179), - [110] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(151), - [113] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(153), - [116] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(157), - [119] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(158), - [122] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(242), - [125] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(190), - [128] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(176), - [131] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(304), - [134] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(92), - [137] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(92), - [140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), - [142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), - [148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), - [154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), - [188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), - [192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), - [202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), - [206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), - [208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), - [210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), - [220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), - [224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), - [226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), - [228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), - [232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), - [234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), - [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), - [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), - [242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), - [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [252] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 1, 0, 1), - [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), - [256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), - [258] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), - [260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_self_field, 2, 0, 5), - [264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_self_field, 2, 0, 5), - [266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 11, 0, 0), - [268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 11, 0, 0), - [270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_expression, 3, 0, 13), - [272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_expression, 3, 0, 13), - [274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 14), - [276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 14), - [278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 4, 0, 0), - [280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 4, 0, 0), - [282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 4, 0, 0), - [284] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 4, 0, 0), - [286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_width_cast, 4, 0, 22), - [288] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_width_cast, 4, 0, 22), - [290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), - [292] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 1, 0, 0), - [294] = {.entry = {.count = 1, .reusable = false}}, SHIFT(331), - [296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 4, 0, 10), - [302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 4, 0, 10), - [304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_expression, 4, 0, 24), - [306] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_expression, 4, 0, 24), - [308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 14), - [310] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 14), - [312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 5, 0, 0), - [314] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 5, 0, 0), - [316] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 5, 0, 0), - [318] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 5, 0, 0), - [320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 6), - [322] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 6), - [324] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 2, 0, 0), - [326] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 2, 0, 0), - [328] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 3, 0, 0), - [330] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 3, 0, 0), - [332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 14), - [334] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 14), - [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 6, 0, 0), - [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 6, 0, 0), - [340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 2, 0, 0), - [342] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 2, 0, 0), - [344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 6, 0, 0), - [346] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 6, 0, 0), - [348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 3, 0, 0), - [350] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 3, 0, 0), - [352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 7, 0, 0), - [354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 7, 0, 0), - [356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 7, 0, 0), - [358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 7, 0, 0), - [360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expr_non_unary, 1, 0, 0), - [362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expr_non_unary, 1, 0, 0), - [364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), - [366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), - [368] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), - [370] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 8, 0, 0), - [372] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 8, 0, 0), - [374] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_range_expression, 3, 0, 12), - [376] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_range_expression, 3, 0, 12), - [378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 9, 0, 0), - [380] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 9, 0, 0), - [382] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 3, 0, 10), - [384] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 3, 0, 10), - [386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 10, 0, 0), - [388] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 10, 0, 0), - [390] = {.entry = {.count = 1, .reusable = false}}, SHIFT(189), - [392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 11), - [394] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 11), - [396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), - [398] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), - [400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), - [402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), - [406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_clause, 3, 0, 17), - [408] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_clause, 3, 0, 17), - [410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), - [412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), - [414] = {.entry = {.count = 1, .reusable = false}}, SHIFT(192), - [416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_receiver, 1, 0, 0), - [418] = {.entry = {.count = 1, .reusable = false}}, SHIFT(53), - [420] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_receiver, 1, 0, 0), - [422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), - [424] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression_statement, 1, 0, 0), - [426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_join_statement, 2, 0, 1), - [428] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_join_statement, 2, 0, 1), - [430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_statement, 3, 0, 1), - [432] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_statement, 3, 0, 1), - [434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_spawn_statement, 4, 0, 18), - [436] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_spawn_statement, 4, 0, 18), - [438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_error_return_statement, 2, 0, 3), - [440] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_error_return_statement, 2, 0, 3), - [442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 3, 0, 1), - [444] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 3, 0, 1), - [446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_join_statement, 4, 0, 18), - [448] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_join_statement, 4, 0, 18), - [450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_spawn_statement, 2, 0, 1), - [452] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_spawn_statement, 2, 0, 1), - [454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 2, 0, 3), - [456] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 2, 0, 3), - [458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), - [460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_export_statement_repeat1, 2, 0, 0), - [462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_export_statement_repeat1, 2, 0, 0), - [464] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_export_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(307), - [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_lhs, 2, 0, 8), - [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_lhs, 2, 0, 8), - [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_lhs, 3, 0, 15), - [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_lhs, 3, 0, 15), - [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_lhs, 1, 0, 0), - [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_lhs, 1, 0, 0), - [479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), - [481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), - [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_lhs, 2, 0, 5), - [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_lhs, 2, 0, 5), - [487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332), - [489] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 16), - [491] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 16), - [493] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 16), SHIFT_REPEAT(317), - [496] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 16), SHIFT_REPEAT(167), - [499] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 25), - [501] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 25), - [503] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 25), SHIFT_REPEAT(332), - [506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 5), - [508] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 5), - [510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_statement_repeat1, 2, 0, 0), - [512] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_statement_repeat1, 2, 0, 0), - [514] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bind_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(253), - [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_statement, 3, 0, 9), - [519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_export_statement, 3, 0, 9), - [521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), - [523] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_statement, 2, 0, 4), - [525] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_export_statement, 2, 0, 4), - [527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_statement, 2, 0, 1), - [529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_statement, 2, 0, 1), - [531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), - [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_statement, 3, 0, 1), - [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_statement, 3, 0, 1), - [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_clause, 1, 0, 2), - [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_clause, 1, 0, 2), - [541] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), - [543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 3, 0, 26), - [545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat2, 3, 0, 26), - [547] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 5), - [549] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 5), - [551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), - [553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), - [555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [557] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), - [559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), - [561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), - [567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [569] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [573] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_join_statement, 4, 0, 1), - [575] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_join_statement, 4, 0, 1), - [577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_extend_statement, 4, 0, 18), - [579] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_extend_statement, 4, 0, 18), - [581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 4, 0, 19), - [583] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 4, 0, 19), - [585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 7), - [587] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 7), - [589] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_statement, 4, 0, 18), - [591] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_statement, 4, 0, 18), - [593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_statement, 4, 0, 1), - [595] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_statement, 4, 0, 1), - [597] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if_statement, 4, 0, 19), - [599] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if_statement, 4, 0, 19), - [601] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 4, 0, 1), - [603] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 4, 0, 1), - [605] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 4, 0, 21), - [607] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 4, 0, 21), - [609] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), - [611] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_statement, 4, 0, 23), - [613] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_statement, 4, 0, 23), - [615] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_spawn_statement, 4, 0, 1), - [617] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_spawn_statement, 4, 0, 1), - [619] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_extend_statement, 5, 0, 18), - [621] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_extend_statement, 5, 0, 18), - [623] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 19), - [625] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 19), - [627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), - [629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), - [631] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_statement, 5, 0, 18), - [633] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_statement, 5, 0, 18), - [635] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if_statement, 5, 0, 19), - [637] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if_statement, 5, 0, 19), - [639] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 5, 0, 21), - [641] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 5, 0, 21), - [643] = {.entry = {.count = 1, .reusable = false}}, SHIFT(207), - [645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), - [649] = {.entry = {.count = 1, .reusable = false}}, SHIFT(210), - [651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_statement, 5, 0, 23), - [653] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_statement, 5, 0, 23), - [655] = {.entry = {.count = 1, .reusable = false}}, SHIFT(206), - [657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), - [659] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 1, 0, 0), SHIFT(336), - [662] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 1, 0, 0), - [664] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 1, 0, 0), - [666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 6, 0, 27), - [670] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 6, 0, 27), - [672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_break_statement, 1, 0, 1), - [674] = {.entry = {.count = 1, .reusable = false}}, SHIFT(321), - [676] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_break_statement, 1, 0, 1), - [678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_continue_statement, 1, 0, 1), - [680] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_continue_statement, 1, 0, 1), - [682] = {.entry = {.count = 1, .reusable = false}}, SHIFT(211), - [684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_spawn_statement, 6, 0, 18), - [686] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_spawn_statement, 6, 0, 18), - [688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_join_statement, 6, 0, 18), - [690] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_join_statement, 6, 0, 18), - [692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), - [694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 7, 0, 27), - [696] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 7, 0, 27), - [698] = {.entry = {.count = 1, .reusable = false}}, SHIFT(86), - [700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), - [702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), - [706] = {.entry = {.count = 1, .reusable = false}}, SHIFT(83), - [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), - [710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), - [712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), - [716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), - [718] = {.entry = {.count = 1, .reusable = false}}, SHIFT(193), - [720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), - [722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), - [726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), - [728] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), - [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), - [732] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_header_expr, 1, 0, 0), - [734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), - [736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), - [738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), - [742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), - [744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_initializer, 3, 0, 20), - [752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), - [754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), - [756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_expression_repeat1, 3, 0, 0), - [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_expression_repeat1, 2, 0, 0), - [762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), - [764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__loop_header_expr_repeat1, 2, 0, 0), - [766] = {.entry = {.count = 1, .reusable = false}}, SHIFT(263), - [768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), - [770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), - [772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), - [774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), - [778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), - [780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), - [782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), - [784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), - [788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), - [792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), - [794] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(263), - [797] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(226), - [800] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(326), - [803] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(305), - [806] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), - [808] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(310), - [811] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(343), - [814] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(263), - [817] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(262), - [820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), - [822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [824] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 5, 0, 32), - [826] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 5, 0, 32), - [828] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 5, 0, 31), - [830] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 5, 0, 31), - [832] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 29), - [834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 29), - [836] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 18), - [838] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 18), - [840] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 31), - [842] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 31), - [844] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 1), - [846] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 1), - [848] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 1), - [850] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 1), - [852] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 5, 0, 18), - [854] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 5, 0, 18), - [856] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 32), - [858] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 32), - [860] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 29), - [862] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 29), - [864] = {.entry = {.count = 1, .reusable = false}}, SHIFT(246), - [866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(333), - [870] = {.entry = {.count = 1, .reusable = false}}, SHIFT(333), - [872] = {.entry = {.count = 1, .reusable = false}}, SHIFT(296), - [874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), - [876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), - [878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), - [880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), - [884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(311), - [886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), - [888] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_scrutinee, 1, 0, 0), - [890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), - [894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), - [896] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 2, 0, 0), - [898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), - [900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), - [902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 3, 0, 0), - [904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), - [906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), - [908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323), - [912] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__struct_field_list_repeat1, 2, 0, 0), SHIFT_REPEAT(290), - [915] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__struct_field_list_repeat1, 2, 0, 0), SHIFT_REPEAT(282), - [918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__struct_field_list_repeat1, 2, 0, 0), - [920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), - [922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), - [924] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 1, 0, 0), - [926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), - [930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), - [932] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 4, 0, 0), - [934] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(175), - [937] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(146), - [940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), - [942] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_scrutinee, 4, 0, 0), - [944] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__loop_header_expr_repeat2, 2, 0, 0), SHIFT_REPEAT(328), - [947] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__loop_header_expr_repeat2, 2, 0, 0), - [949] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_pattern, 1, 0, 0), - [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), - [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), - [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), - [959] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_arm_repeat1, 2, 0, 30), SHIFT_REPEAT(243), - [962] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_arm_repeat1, 2, 0, 30), - [964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), - [966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), - [970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [972] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_header_expr, 3, 0, 0), - [974] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__loop_header_expr_repeat1, 2, 0, 0), SHIFT_REPEAT(169), - [977] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_scrutinee, 3, 0, 0), - [979] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 5, 0, 0), - [981] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__struct_field_list_repeat1, 3, 0, 0), - [983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), - [985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335), - [987] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_header_expr, 4, 0, 0), - [989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), - [991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), - [993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), - [995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), - [997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), - [999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), - [1001] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_pattern, 3, 0, 0), - [1003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), - [1005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [1007] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_arm_repeat1, 2, 0, 28), - [1009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), - [1011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), - [1013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), - [1015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298), - [1017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [1019] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), - [1021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [1023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [1025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [1027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), - [1029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(339), - [1031] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [1033] = {.entry = {.count = 1, .reusable = true}}, SHIFT(334), - [1035] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_scrutinee, 5, 0, 0), - [1037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [1039] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), - [1041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [1043] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [1045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [1047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [1049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [1051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [1053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), - [1055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293), - [1057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), - [1059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [1061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), - [1063] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), - [1065] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), - [1067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), - [1069] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_header_expr, 5, 0, 0), - [1071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), - [1073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [1075] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [1077] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), - [1079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [1081] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [1083] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), - [1085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), - [1087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), - [1089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), - [1091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), - [1093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(93), + [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(430), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(441), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(442), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), + [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [43] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), + [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [49] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402), + [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(92), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(122), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(130), + [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [65] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [69] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [71] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [73] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [75] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), + [77] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(93), + [80] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(8), + [83] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(351), + [86] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(430), + [89] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(191), + [92] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(441), + [95] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(146), + [98] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(114), + [101] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(156), + [104] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(442), + [107] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(340), + [110] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(231), + [113] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(70), + [116] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(236), + [119] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(165), + [122] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(167), + [125] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(202), + [128] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(209), + [131] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(328), + [134] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(215), + [137] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(237), + [140] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(402), + [143] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(434), + [146] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(92), + [149] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(122), + [152] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(122), + [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), + [163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), + [187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), + [189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), + [193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), + [195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), + [201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [213] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), + [215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), + [219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), + [221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332), + [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), + [231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), + [233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335), + [245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(334), + [249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), + [251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), + [253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(331), + [257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(333), + [263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), + [265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), + [267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), + [281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), + [283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), + [299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293), + [307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [309] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 1, 0, 1), + [311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), + [313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(446), + [315] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112), + [317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [319] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_lhs, 1, 0, 0), + [321] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_lhs, 1, 0, 0), + [323] = {.entry = {.count = 1, .reusable = false}}, SHIFT(437), + [325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [327] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expr_non_unary, 1, 0, 0), + [329] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expr_non_unary, 1, 0, 0), + [331] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_lhs, 2, 0, 5), + [333] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_lhs, 2, 0, 5), + [335] = {.entry = {.count = 3, .reusable = false}}, REDUCE(sym_bind_lhs, 2, 0, 5), REDUCE(sym_self_field, 2, 0, 5), SHIFT(432), + [339] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_bind_lhs, 2, 0, 5), REDUCE(sym_self_field, 2, 0, 5), + [342] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_bind_lhs, 2, 0, 5), REDUCE(sym_self_field, 2, 0, 5), + [345] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_self_field, 2, 0, 5), + [347] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_self_field, 2, 0, 5), + [349] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 4, 0, 10), + [351] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 4, 0, 10), + [353] = {.entry = {.count = 1, .reusable = false}}, SHIFT(189), + [355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), + [357] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 3, 0, 0), + [359] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 3, 0, 0), + [361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 3, 0, 0), + [363] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 3, 0, 0), + [365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), + [367] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), + [369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 3, 0, 10), + [371] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 3, 0, 10), + [373] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 11), + [375] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 11), + [377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [379] = {.entry = {.count = 1, .reusable = false}}, SHIFT(206), + [381] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), + [383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [385] = {.entry = {.count = 1, .reusable = false}}, SHIFT(186), + [387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), + [391] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_range_expression, 3, 0, 12), + [393] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_range_expression, 3, 0, 12), + [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(187), + [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [401] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_expression, 3, 0, 13), + [403] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_expression, 3, 0, 13), + [405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 14), + [407] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 14), + [409] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_clause, 3, 0, 17), + [411] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_clause, 3, 0, 17), + [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [415] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_true_atom, 1, 0, 0), + [417] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_true_atom, 1, 0, 0), + [419] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 4, 0, 0), + [421] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 4, 0, 0), + [423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_width_cast, 4, 0, 22), + [425] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_width_cast, 4, 0, 22), + [427] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_expression, 4, 0, 24), + [429] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_expression, 4, 0, 24), + [431] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 14), + [433] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 14), + [435] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 5, 0, 0), + [437] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 5, 0, 0), + [439] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 5, 0, 0), + [441] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 5, 0, 0), + [443] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 14), + [445] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 14), + [447] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 6, 0, 0), + [449] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 6, 0, 0), + [451] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 6, 0, 0), + [453] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 6, 0, 0), + [455] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 2, 0, 0), + [457] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 2, 0, 0), + [459] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 2, 0, 0), + [461] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 2, 0, 0), + [463] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list_expression, 7, 0, 0), + [465] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list_expression, 7, 0, 0), + [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 7, 0, 0), + [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 7, 0, 0), + [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 8, 0, 0), + [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 8, 0, 0), + [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 9, 0, 0), + [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 9, 0, 0), + [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 10, 0, 0), + [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 10, 0, 0), + [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 11, 0, 0), + [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 11, 0, 0), + [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), + [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 1, 0, 0), + [491] = {.entry = {.count = 1, .reusable = false}}, SHIFT(439), + [493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [497] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 4), + [499] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 4), + [501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_receiver, 1, 0, 0), + [503] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), + [505] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_receiver, 1, 0, 0), + [507] = {.entry = {.count = 1, .reusable = false}}, SHIFT(238), + [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fn_expression, 4, 0, 0), + [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_fn_expression, 4, 0, 0), + [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_spawn_statement, 4, 0, 18), + [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_spawn_statement, 4, 0, 18), + [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_join_statement, 4, 0, 18), + [519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_join_statement, 4, 0, 18), + [521] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_statement, 3, 0, 1), + [523] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_statement, 3, 0, 1), + [525] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_statement, 1, 0, 0), + [527] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression_statement, 1, 0, 0), + [529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 3, 0, 1), + [531] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 3, 0, 1), + [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 2, 0, 6), + [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 2, 0, 6), + [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_error_return_statement, 2, 0, 6), + [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_error_return_statement, 2, 0, 6), + [541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_join_statement, 2, 0, 1), + [543] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_join_statement, 2, 0, 1), + [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_spawn_statement, 2, 0, 1), + [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_spawn_statement, 2, 0, 1), + [549] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [551] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_export_statement_repeat1, 2, 0, 0), + [553] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_export_statement_repeat1, 2, 0, 0), + [555] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_export_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(428), + [558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(432), + [560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 16), + [562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 16), + [564] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 16), SHIFT_REPEAT(437), + [567] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 16), SHIFT_REPEAT(160), + [570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 25), + [572] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 25), + [574] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 25), SHIFT_REPEAT(432), + [577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_lhs, 3, 0, 15), + [579] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_lhs, 3, 0, 15), + [581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_lhs, 2, 0, 8), + [583] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_lhs, 2, 0, 8), + [585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(437), + [587] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_statement, 2, 0, 1), + [589] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_statement, 2, 0, 1), + [591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350), + [593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 0), + [595] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 0), + [597] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_statement_repeat1, 2, 0, 0), + [599] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_statement_repeat1, 2, 0, 0), + [601] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_bind_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(350), + [604] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_statement, 3, 0, 9), + [606] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_export_statement, 3, 0, 9), + [608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428), + [610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 3, 0, 26), + [612] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat2, 3, 0, 26), + [614] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 5), + [616] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat1, 2, 0, 5), + [618] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_statement, 3, 0, 1), + [620] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_statement, 3, 0, 1), + [622] = {.entry = {.count = 1, .reusable = false}}, SHIFT(71), + [624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), + [628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(339), + [632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(422), + [636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [638] = {.entry = {.count = 1, .reusable = false}}, SHIFT(271), + [640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), + [642] = {.entry = {.count = 1, .reusable = false}}, SHIFT(277), + [644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), + [664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [674] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_export_statement, 2, 0, 3), + [676] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_export_statement, 2, 0, 3), + [678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bind_clause, 1, 0, 2), + [680] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bind_clause, 1, 0, 2), + [682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 5), + [690] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_bind_lhs_repeat2, 2, 0, 5), + [692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [694] = {.entry = {.count = 1, .reusable = false}}, SHIFT(294), + [696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(403), + [698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [702] = {.entry = {.count = 1, .reusable = false}}, SHIFT(296), + [704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [706] = {.entry = {.count = 1, .reusable = false}}, SHIFT(299), + [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), + [710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [712] = {.entry = {.count = 1, .reusable = false}}, SHIFT(295), + [714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), + [716] = {.entry = {.count = 1, .reusable = false}}, SHIFT(303), + [718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), + [720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449), + [726] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_statement, 5, 0, 18), + [728] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_statement, 5, 0, 18), + [730] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if_statement, 5, 0, 19), + [732] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if_statement, 5, 0, 19), + [734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_statement, 4, 0, 23), + [736] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_statement, 4, 0, 23), + [738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [740] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_statement, 5, 0, 23), + [742] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_statement, 5, 0, 23), + [744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_block_statement, 5, 0, 18), + [748] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_block_statement, 5, 0, 18), + [750] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 1, 0, 0), SHIFT(468), + [753] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 1, 0, 0), + [755] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 1, 0, 0), + [757] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_block_statement, 4, 0, 1), + [759] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_block_statement, 4, 0, 1), + [761] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 6, 0, 27), + [763] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 6, 0, 27), + [765] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_block_statement, 3, 0, 1), + [767] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_block_statement, 3, 0, 1), + [769] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_break_statement, 1, 0, 1), + [771] = {.entry = {.count = 1, .reusable = false}}, SHIFT(431), + [773] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_break_statement, 1, 0, 1), + [775] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_spawn_statement, 6, 0, 18), + [777] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_spawn_statement, 6, 0, 18), + [779] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_join_statement, 6, 0, 18), + [781] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_join_statement, 6, 0, 18), + [783] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_effect_block_statement, 6, 0, 18), + [785] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_effect_block_statement, 6, 0, 18), + [787] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 7, 0, 27), + [789] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 7, 0, 27), + [791] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_continue_statement, 1, 0, 1), + [793] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_continue_statement, 1, 0, 1), + [795] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_extend_statement, 4, 0, 18), + [797] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_extend_statement, 4, 0, 18), + [799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 4, 0, 19), + [801] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 4, 0, 19), + [803] = {.entry = {.count = 1, .reusable = false}}, SHIFT(115), + [805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_statement, 2, 0, 7), + [809] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_statement, 2, 0, 7), + [811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_extend_statement, 5, 0, 18), + [815] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_extend_statement, 5, 0, 18), + [817] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, 0, 19), + [819] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, 0, 19), + [821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_statement, 4, 0, 18), + [823] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_statement, 4, 0, 18), + [825] = {.entry = {.count = 1, .reusable = false}}, SHIFT(74), + [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [831] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_statement, 4, 0, 1), + [833] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_statement, 4, 0, 1), + [835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_join_statement, 4, 0, 1), + [837] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_join_statement, 4, 0, 1), + [839] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if_statement, 4, 0, 19), + [841] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if_statement, 4, 0, 19), + [843] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 4, 0, 1), + [845] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 4, 0, 1), + [847] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 4, 0, 21), + [849] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 4, 0, 21), + [851] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_task_spawn_statement, 4, 0, 1), + [853] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_task_spawn_statement, 4, 0, 1), + [855] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_loop_statement, 5, 0, 21), + [857] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_loop_statement, 5, 0, 21), + [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [863] = {.entry = {.count = 1, .reusable = false}}, SHIFT(463), + [865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), + [867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [869] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), + [871] = {.entry = {.count = 1, .reusable = false}}, SHIFT(221), + [873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [875] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [877] = {.entry = {.count = 1, .reusable = false}}, SHIFT(224), + [879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), + [881] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), + [885] = {.entry = {.count = 1, .reusable = false}}, SHIFT(225), + [887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), + [889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), + [891] = {.entry = {.count = 1, .reusable = true}}, SHIFT(400), + [893] = {.entry = {.count = 1, .reusable = false}}, SHIFT(433), + [895] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_header_expr, 1, 0, 0), + [899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [901] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [907] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [911] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [915] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), + [921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [923] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), + [925] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(465), + [931] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_expression_repeat1, 2, 0, 0), + [933] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_expression_repeat1, 3, 0, 0), + [935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(438), + [939] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [941] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_initializer, 3, 0, 20), + [943] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__loop_header_expr_repeat1, 2, 0, 0), + [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), + [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), + [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [959] = {.entry = {.count = 1, .reusable = false}}, SHIFT(384), + [961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(466), + [965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(420), + [967] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [969] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), + [971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(457), + [973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(381), + [975] = {.entry = {.count = 1, .reusable = true}}, SHIFT(384), + [977] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(384), + [980] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(325), + [983] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(466), + [986] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(420), + [989] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), + [991] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(425), + [994] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(457), + [997] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(92), + [1000] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(381), + [1003] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_statement_repeat1, 2, 0, 0), SHIFT_REPEAT(384), + [1006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), + [1008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [1010] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 29), + [1012] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 29), + [1014] = {.entry = {.count = 1, .reusable = false}}, SHIFT(353), + [1016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), + [1018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [1020] = {.entry = {.count = 1, .reusable = false}}, SHIFT(435), + [1022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(435), + [1024] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 1), + [1026] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 1), + [1028] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 29), + [1030] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 29), + [1032] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 32), + [1034] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 32), + [1036] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 3, 0, 1), + [1038] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 1), + [1040] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 5, 0, 18), + [1042] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 5, 0, 18), + [1044] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 31), + [1046] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 31), + [1048] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 4, 0, 18), + [1050] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 4, 0, 18), + [1052] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 5, 0, 32), + [1054] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 5, 0, 32), + [1056] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_arm, 5, 0, 31), + [1058] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 5, 0, 31), + [1060] = {.entry = {.count = 1, .reusable = false}}, SHIFT(397), + [1062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(397), + [1064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(468), + [1066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), + [1068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [1070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [1072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [1076] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__struct_field_list_repeat1, 2, 0, 0), SHIFT_REPEAT(411), + [1079] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__struct_field_list_repeat1, 2, 0, 0), SHIFT_REPEAT(368), + [1082] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__struct_field_list_repeat1, 2, 0, 0), + [1084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), + [1086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), + [1088] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 2, 0, 0), + [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), + [1092] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 4, 0, 0), + [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [1096] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 3, 0, 0), + [1098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [1100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [1102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [1104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(345), + [1106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [1108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [1110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [1112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(436), + [1114] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(246), + [1117] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(164), + [1120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), + [1122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), + [1124] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_scrutinee, 1, 0, 0), + [1126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [1128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [1130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [1132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), + [1134] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 1, 0, 0), + [1136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [1138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(452), + [1140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429), + [1142] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__loop_header_expr_repeat2, 2, 0, 0), SHIFT_REPEAT(450), + [1145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__loop_header_expr_repeat2, 2, 0, 0), + [1147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__struct_field_list_repeat1, 3, 0, 0), + [1149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408), + [1151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(450), + [1153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_header_expr, 4, 0, 0), + [1155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(427), + [1157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(467), + [1159] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_scrutinee, 3, 0, 0), + [1161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_scrutinee, 4, 0, 0), + [1163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), + [1165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(424), + [1167] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_arm_repeat1, 2, 0, 30), SHIFT_REPEAT(338), + [1170] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_arm_repeat1, 2, 0, 30), + [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338), + [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [1176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_pattern, 1, 0, 0), + [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), + [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399), + [1186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_header_expr, 3, 0, 0), + [1188] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__loop_header_expr_repeat1, 2, 0, 0), SHIFT_REPEAT(213), + [1191] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__struct_field_list, 5, 0, 0), + [1193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(406), + [1195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(453), + [1197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(454), + [1199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(455), + [1201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(456), + [1203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_pattern, 3, 0, 0), + [1205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_arm_repeat1, 2, 0, 28), + [1207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), + [1209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), + [1211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [1213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), + [1215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [1217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(458), + [1219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [1221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), + [1223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [1225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), + [1227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [1229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), + [1231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [1233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), + [1235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [1237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), + [1239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(451), + [1241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363), + [1243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), + [1245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(377), + [1247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(443), + [1249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(394), + [1251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [1253] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396), + [1255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__match_scrutinee, 5, 0, 0), + [1257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [1259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(464), + [1263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [1265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(461), + [1267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [1269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [1271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [1273] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_header_expr, 5, 0, 0), + [1275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [1277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [1279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(440), + [1281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [1283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [1285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), + [1287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), + [1289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), + [1291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [1293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [1295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [1297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [1299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [1301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(419), + [1303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [1305] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [1307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431), + [1309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [1311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [1313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(401), + [1315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [1317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [1319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [1321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [1323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [1325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(444), + [1327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(460), + [1329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [1331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [1333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [1335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), + [1337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [1339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [1341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), + [1343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [1345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), }; #ifdef __cplusplus diff --git a/grammars/tree-sitter-echo/tree-sitter-echo.wasm b/grammars/tree-sitter-echo/tree-sitter-echo.wasm index 2d7687a2..f590e8c7 100755 Binary files a/grammars/tree-sitter-echo/tree-sitter-echo.wasm and b/grammars/tree-sitter-echo/tree-sitter-echo.wasm differ diff --git a/std/json.echo b/std/json.echo index 25ed605b..8fec553d 100644 --- a/std/json.echo +++ b/std/json.echo @@ -1,4 +1,7 @@ ; std/json — parse/stringify product values. +; Echo values are untagged integers: JSON true parses to 1, false and null to 0, +; and 0 and 1 stringify as numbers. A top-level 0, false, or null cannot be +; parsed because 0 also signals failure (docs/stdlib.md). / runtime / std/test / std/str diff --git a/www/SITE.md b/www/SITE.md index 27233135..ddf5a3e0 100644 --- a/www/SITE.md +++ b/www/SITE.md @@ -118,14 +118,17 @@ xo build emits a native executable from that same pipeline. ## Positioning -**H1 (definition):** Echo is a compiled language. +**H1 (definition):** Echo is a small compiled language with glyph-led statements. -**Lead:** Statement leaders mark control and binding. The rest of each line is -an ordinary expression. `xo` checks a program and emits a native binary from -the same LLVM pipeline. +**Lead:** A glyph opens each statement and names its role. `xo` checks a +program, runs it, and builds a native binary through one LLVM pipeline. -**Status:** Echo 2026 is the public edition. A Rust toolchain ships as -prerelease tags on GitHub. The repository is MIT licensed. +**Status:** Echo 2026 is the public edition. The Rust toolchain ships as alpha +prerelease tags on GitHub, so forms and std APIs can still change. The +repository is MIT licensed. + +**Meta description:** `homePage.description` in `src/docs/site.ts`. It feeds +``, `og:description`, and `twitter:description` for `/`. Keep product claims factual. Do not invent APIs, partner logos, or unearned maturity. @@ -151,19 +154,21 @@ while there is no live invite. Public project mail is `oss@christofferhallas.com 1. **Leaders** — `$` `~` `?` `*` `^` (and the rest of the glyph set) mark statement roles 2. **Errors as values** — `!` / match; optionals follow the same idea -3. **Small loop, native output** — `xo check` / `run` / `build`; I/O from `std` +3. **One LLVM pipeline** — `xo check` / `run` / `run --jit` / `build`; I/O and + more from `std` ## Primary nav -The logo is the only Home control. Book stays at `/book` and in the footer. +The logo is the only Home control. Book is in the nav and the footer. Security lives at `/security` and in the footer About group. Catalog, footer, and nav destinations are real HTML files at those paths. | Item | Path | Notes | | ----------------- | ----------- | --------------------------------------------- | | Documents | `/docs` | Language reference hub | +| Book | `/book` | Why each construct exists, how to read code | | Packages | `/docs/std` | Standard library | -| Echo 2026 | `/e26` | Edition + Spec TOC + suite | +| Spec | `/e26` | Echo 2026 edition + Spec TOC + suite | | Try | `/try` | In-browser check + playground run (wasm host) | | **Install** (CTA) | `/install` | Solid button; get `xo` | | Security | `/security` | Vulnerability mailbox + `SECURITY.md` | @@ -179,11 +184,22 @@ add a second rail or nested train. The home page is a language-docs front door. Copy and links live in `src/docs/site.ts` (`homePage`, `primaryNav`, `docsHubCatalog`, `footerLinkGroups`). -1. Language definition (`Echo is a compiled language`) plus the lead -2. Status line: Echo 2026, Rust, prerelease tags, MIT -3. Representative sample that shows statement leaders and binds -4. First-class links: Documents (`/docs`), Packages (`/docs/std`), Spec (`/e26`) -5. Footer (compiled language, `xo`, LLVM, Echo 2026, prerelease, MIT) +1. Language definition plus the lead, the status line, and the CTAs + (Install xo, Try Echo, Documents) +2. Hero sample (`sum.echo`) with its `xo run` output +3. Four highlights (`homePage.highlights`): glyph leaders, errors as values, + one LLVM pipeline, standard library +4. "Programs and their output" (`homePage.examples`): files from `examples/` + shown with real output +5. First-class links: Documents (`/docs`), Packages (`/docs/std`), Spec (`/e26`) +6. Footer (small compiled language, `xo`, LLVM, Echo 2026, alpha prerelease, MIT) + +Every snippet on the homepage is a real file. `npm run test:samples` asserts +that `homePage.sample` equals `samples/hero.echo`, that each example equals its +`source` file under the repository root (leading `;` comment lines are not +shown), and, when `target/debug/xo` or `XO_BIN` exists, that `xo run` prints the +output shown. Add a new homepage example by adding the file under `examples/` +first. Each of those links, plus Install, First program, Book, Try, Privacy, Terms, and Security, is a real page (`path/index.html`) with that page title and @@ -268,3 +284,12 @@ list the GitHub Pages host. Richer download tabs, `/e26` URL rename to `/echo-2026`. Discord footer link when a real invite exists. + +## Social card and metadata + +Every built page gets `canonical`, `og:*`, and `twitter:*` tags from +`applyStaticPage` in `vite.config.ts`, using `publicCatalogUrl(path)`. The +shared image is `public/og.png` (1200x630). Its source is +`scripts/og-image.html`; the regeneration command is in that file's header +comment. Re-render it when the homepage definition or hero sample changes. +`npm run build` fails if `dist/og.png` or a page's head tags are missing. diff --git a/www/index.html b/www/index.html index 90b87058..771affd1 100644 --- a/www/index.html +++ b/www/index.html @@ -4,7 +4,35 @@ Echo Programming Language - + + + + + + + + + + + + + + + + +
diff --git a/www/package.json b/www/package.json index 9ebfb262..7d8ffdba 100644 --- a/www/package.json +++ b/www/package.json @@ -10,11 +10,12 @@ "format": "oxfmt --check .", "lint": "oxlint . --ignore-pattern public/echo-wasm", "preview": "vite preview", - "test": "npm run test:docs && npm run test:prose && npm run test:std-ref && npm run test:try && npm run test:sitemap && npm run test:spa-redirects", + "test": "npm run test:docs && npm run test:prose && npm run test:std-ref && npm run test:try && npm run test:samples && npm run test:sitemap && npm run test:spa-redirects", "test:docs": "node scripts/verify-docs-pages.mjs", "test:std-ref": "node scripts/verify-std-reference.mjs", "test:prose": "node scripts/verify-prose.mjs", "test:try": "node scripts/verify-try.mjs", + "test:samples": "node scripts/verify-samples.mjs", "test:sitemap": "node scripts/verify-sitemap.mjs", "test:spa-redirects": "node scripts/verify-spa-redirects.mjs", "sync:tree-sitter": "node scripts/sync-tree-sitter.mjs", diff --git a/www/public/echo-wasm/echo_wasm.d.ts b/www/public/echo-wasm/echo_wasm.d.ts index 43f6f296..cd77fba4 100644 --- a/www/public/echo-wasm/echo_wasm.d.ts +++ b/www/public/echo-wasm/echo_wasm.d.ts @@ -13,15 +13,19 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl export interface InitOutput { readonly memory: WebAssembly.Memory; + readonly echo_runtime_string_builder_new: () => bigint; + readonly echo_runtime_string_builder_push_value: (a: bigint, b: bigint) => void; + readonly echo_runtime_string_builder_finish: (a: bigint) => bigint; readonly echo_runtime_float_from_f64: (a: number) => bigint; readonly echo_runtime_str_from_int: (a: bigint) => bigint; + readonly echo_runtime_eprint: (a: bigint) => void; readonly echo_runtime_print_i64: (a: bigint) => void; readonly echo_runtime_str_from_debug: (a: bigint) => bigint; readonly echo_runtime_list_new: () => bigint; + readonly echo_runtime_locator_from_string: (a: bigint) => bigint; readonly echo_runtime_range_new: (a: bigint, b: bigint) => bigint; - readonly echo_runtime_string_builder_new: () => bigint; - readonly echo_runtime_string_builder_push_value: (a: bigint, b: bigint) => void; - readonly echo_runtime_string_builder_finish: (a: bigint) => bigint; + readonly echo_runtime_bytes_from_value: (a: bigint) => bigint; + readonly echo_runtime_bytes_cat: (a: bigint, b: bigint) => bigint; readonly echo_runtime_scope_enter: (a: bigint) => void; readonly echo_runtime_scope_exit: (a: bigint) => void; readonly echo_runtime_scope_register: (a: bigint) => void; @@ -33,11 +37,11 @@ export interface InitOutput { readonly playgroundRun: (a: number, b: number) => [number, number]; readonly stdFileCount: () => number; readonly echo_runtime_struct_get: (a: bigint, b: number, c: number) => bigint; + readonly echo_runtime_struct_new: () => bigint; readonly echo_runtime_struct_new_named: (a: number, b: number) => bigint; readonly echo_runtime_struct_set: (a: bigint, b: number, c: number, d: bigint) => void; readonly echo_runtime_string_from_utf8: (a: number, b: number) => bigint; readonly echo_runtime_abort: (a: number, b: number) => void; - readonly echo_runtime_bytes_cat: (a: bigint, b: bigint) => bigint; readonly echo_runtime_bytes_from_i64: (a: bigint) => bigint; readonly echo_runtime_bytes_from_ptr: (a: number, b: number) => bigint; readonly echo_runtime_bytes_from_str: (a: bigint) => bigint; @@ -77,12 +81,27 @@ export interface InitOutput { readonly echo_runtime_str_slice: (a: bigint, b: bigint, c: bigint) => bigint; readonly echo_runtime_str_starts_with: (a: bigint, b: bigint) => bigint; readonly echo_runtime_string_builder_push_str: (a: bigint, b: number, c: number) => void; - readonly echo_runtime_struct_new: () => bigint; readonly echo_runtime_struct_type_is: (a: bigint, b: number, c: number) => bigint; readonly echo_runtime_list_get: (a: bigint, b: bigint) => bigint; readonly echo_runtime_list_len: (a: bigint) => bigint; readonly echo_runtime_list_push: (a: bigint, b: bigint) => void; readonly echo_runtime_list_set: (a: bigint, b: bigint, c: bigint) => void; + readonly echo_runtime_git_index_pack: (a: bigint) => bigint; + readonly echo_runtime_git_pack_count: (a: bigint) => bigint; + readonly echo_runtime_git_pack_valid: (a: bigint) => bigint; + readonly echo_runtime_git_receive_pack_split: (a: bigint) => bigint; + readonly echo_runtime_git_upload_pack_wants: (a: bigint) => bigint; + readonly echo_runtime_store_cas: (a: bigint, b: bigint, c: bigint, d: bigint) => bigint; + readonly echo_runtime_store_cas_create: (a: bigint, b: bigint, c: bigint) => bigint; + readonly echo_runtime_store_close: (a: bigint) => bigint; + readonly echo_runtime_store_get: (a: bigint, b: bigint) => bigint; + readonly echo_runtime_store_get_if_none_match: (a: bigint, b: bigint, c: bigint) => bigint; + readonly echo_runtime_store_get_range: (a: bigint, b: bigint, c: bigint, d: bigint) => bigint; + readonly echo_runtime_store_head: (a: bigint, b: bigint) => bigint; + readonly echo_runtime_store_keys: (a: bigint) => bigint; + readonly echo_runtime_store_memory_new: () => bigint; + readonly echo_runtime_store_put: (a: bigint, b: bigint, c: bigint) => bigint; + readonly echo_runtime_store_s3_new: () => bigint; readonly echo_runtime_scope_drain_deferred: () => void; readonly echo_runtime_scope_enqueue_release: (a: bigint) => void; readonly echo_runtime_scope_promote_graph: (a: bigint, b: bigint) => void; diff --git a/www/public/echo-wasm/echo_wasm_bg.wasm b/www/public/echo-wasm/echo_wasm_bg.wasm index bdefbbd2..55e9556e 100644 Binary files a/www/public/echo-wasm/echo_wasm_bg.wasm and b/www/public/echo-wasm/echo_wasm_bg.wasm differ diff --git a/www/public/echo-wasm/echo_wasm_bg.wasm.d.ts b/www/public/echo-wasm/echo_wasm_bg.wasm.d.ts index c6b694f8..5c2da6c5 100644 --- a/www/public/echo-wasm/echo_wasm_bg.wasm.d.ts +++ b/www/public/echo-wasm/echo_wasm_bg.wasm.d.ts @@ -1,15 +1,19 @@ /* tslint:disable */ /* eslint-disable */ export const memory: WebAssembly.Memory; +export const echo_runtime_string_builder_new: () => bigint; +export const echo_runtime_string_builder_push_value: (a: bigint, b: bigint) => void; +export const echo_runtime_string_builder_finish: (a: bigint) => bigint; export const echo_runtime_float_from_f64: (a: number) => bigint; export const echo_runtime_str_from_int: (a: bigint) => bigint; +export const echo_runtime_eprint: (a: bigint) => void; export const echo_runtime_print_i64: (a: bigint) => void; export const echo_runtime_str_from_debug: (a: bigint) => bigint; export const echo_runtime_list_new: () => bigint; +export const echo_runtime_locator_from_string: (a: bigint) => bigint; export const echo_runtime_range_new: (a: bigint, b: bigint) => bigint; -export const echo_runtime_string_builder_new: () => bigint; -export const echo_runtime_string_builder_push_value: (a: bigint, b: bigint) => void; -export const echo_runtime_string_builder_finish: (a: bigint) => bigint; +export const echo_runtime_bytes_from_value: (a: bigint) => bigint; +export const echo_runtime_bytes_cat: (a: bigint, b: bigint) => bigint; export const echo_runtime_scope_enter: (a: bigint) => void; export const echo_runtime_scope_exit: (a: bigint) => void; export const echo_runtime_scope_register: (a: bigint) => void; @@ -21,11 +25,11 @@ export const format: (a: number, b: number) => [number, number]; export const playgroundRun: (a: number, b: number) => [number, number]; export const stdFileCount: () => number; export const echo_runtime_struct_get: (a: bigint, b: number, c: number) => bigint; +export const echo_runtime_struct_new: () => bigint; export const echo_runtime_struct_new_named: (a: number, b: number) => bigint; export const echo_runtime_struct_set: (a: bigint, b: number, c: number, d: bigint) => void; export const echo_runtime_string_from_utf8: (a: number, b: number) => bigint; export const echo_runtime_abort: (a: number, b: number) => void; -export const echo_runtime_bytes_cat: (a: bigint, b: bigint) => bigint; export const echo_runtime_bytes_from_i64: (a: bigint) => bigint; export const echo_runtime_bytes_from_ptr: (a: number, b: number) => bigint; export const echo_runtime_bytes_from_str: (a: bigint) => bigint; @@ -65,12 +69,27 @@ export const echo_runtime_str_repeat: (a: bigint, b: bigint) => bigint; export const echo_runtime_str_slice: (a: bigint, b: bigint, c: bigint) => bigint; export const echo_runtime_str_starts_with: (a: bigint, b: bigint) => bigint; export const echo_runtime_string_builder_push_str: (a: bigint, b: number, c: number) => void; -export const echo_runtime_struct_new: () => bigint; export const echo_runtime_struct_type_is: (a: bigint, b: number, c: number) => bigint; export const echo_runtime_list_get: (a: bigint, b: bigint) => bigint; export const echo_runtime_list_len: (a: bigint) => bigint; export const echo_runtime_list_push: (a: bigint, b: bigint) => void; export const echo_runtime_list_set: (a: bigint, b: bigint, c: bigint) => void; +export const echo_runtime_git_index_pack: (a: bigint) => bigint; +export const echo_runtime_git_pack_count: (a: bigint) => bigint; +export const echo_runtime_git_pack_valid: (a: bigint) => bigint; +export const echo_runtime_git_receive_pack_split: (a: bigint) => bigint; +export const echo_runtime_git_upload_pack_wants: (a: bigint) => bigint; +export const echo_runtime_store_cas: (a: bigint, b: bigint, c: bigint, d: bigint) => bigint; +export const echo_runtime_store_cas_create: (a: bigint, b: bigint, c: bigint) => bigint; +export const echo_runtime_store_close: (a: bigint) => bigint; +export const echo_runtime_store_get: (a: bigint, b: bigint) => bigint; +export const echo_runtime_store_get_if_none_match: (a: bigint, b: bigint, c: bigint) => bigint; +export const echo_runtime_store_get_range: (a: bigint, b: bigint, c: bigint, d: bigint) => bigint; +export const echo_runtime_store_head: (a: bigint, b: bigint) => bigint; +export const echo_runtime_store_keys: (a: bigint) => bigint; +export const echo_runtime_store_memory_new: () => bigint; +export const echo_runtime_store_put: (a: bigint, b: bigint, c: bigint) => bigint; +export const echo_runtime_store_s3_new: () => bigint; export const echo_runtime_scope_drain_deferred: () => void; export const echo_runtime_scope_enqueue_release: (a: bigint) => void; export const echo_runtime_scope_promote_graph: (a: bigint, b: bigint) => void; diff --git a/www/public/og.png b/www/public/og.png new file mode 100644 index 00000000..9dbf6907 Binary files /dev/null and b/www/public/og.png differ diff --git a/www/public/tree-sitter/highlights.scm b/www/public/tree-sitter/highlights.scm index 97ba3fce..9ddfb2ba 100644 --- a/www/public/tree-sitter/highlights.scm +++ b/www/public/tree-sitter/highlights.scm @@ -4,26 +4,41 @@ ; Line comments (; → EOL) (comment) @comment +; Operators / punctuation (expression dual-use surface) +; Keep before the leader captures: later patterns win on the same range. +[ +"=" "==" "!=" "===" "!==" +"<" ">" "<=" ">=" "<<" ">>" +"+" "-" "*" "/" "%" +"&&" "||" "&" "^" "|" "~" "!" ".." +"." "," ":" +"(" ")" "[" "]" "{" "}" +] @operator + ; Leader-only tokens (named rules) -(leader_tilde) @keyword (leader_dollar) @keyword (leader_hash) @keyword (leader_at) @keyword (leader_question) @keyword -(leader_caret) @keyword (leader_backslash) @keyword ; Dual-use leaders as statement introducers (anonymous glyph in context) +; leader_tilde (~) ; leader_percent (%) ; leader_colon (:) ; leader_bang (!) +; leader_caret (^) ; leader_star (*) ; leader_lt (<) ; leader_gt (>) ; leader_pipe (|) ; leader_plus (+) ; leader_minus (-) +; leader_ampersand (&) ; leader_slash (/) +(bind_statement leader: "~" @keyword) +(return_statement leader: "^" @keyword) +(effect_block_statement leader: "&" @keyword) (struct_statement leader: "%" @keyword) (match_arm leader: "%" @keyword) (else_if_statement leader: ":" @keyword) @@ -70,15 +85,3 @@ (receiver) @variable.builtin (self_field field: (ident) @property) (width_cast type: (ident) @type) - -; Operators / punctuation (expression dual-use surface) -; Listed before more-specific leader captures win via query order in editors -; that last-match-wins; leaders above already mark statement glyphs. -[ -"=" "==" "!=" "===" "!==" -"<" ">" "<=" ">=" -"+" "-" "*" "/" "%" -"&&" "||" "!" ".." -"." "," ":" -"(" ")" "[" "]" "{" "}" -] @operator diff --git a/www/public/tree-sitter/tree-sitter-echo.wasm b/www/public/tree-sitter/tree-sitter-echo.wasm index 2d7687a2..f590e8c7 100755 Binary files a/www/public/tree-sitter/tree-sitter-echo.wasm and b/www/public/tree-sitter/tree-sitter-echo.wasm differ diff --git a/www/samples/hero.echo b/www/samples/hero.echo index 72f4e121..0c76b0e1 100644 --- a/www/samples/hero.echo +++ b/www/samples/hero.echo @@ -1,4 +1,4 @@ -; Homepage hero — must match app.tsx sample (top-level, no entry keyword). +; Homepage hero. Must match homePage.sample in src/docs/site.ts (npm run test:samples). / std/io $ xs = [1, 2, 3] diff --git a/www/scripts/og-image.html b/www/scripts/og-image.html new file mode 100644 index 00000000..a2a53713 --- /dev/null +++ b/www/scripts/og-image.html @@ -0,0 +1,196 @@ + + + + + + Echo social card + + + +
+ +

A small compiled language with glyph-led statements.

+
xo.run
+
+
sum.echo
+ 
/ std/io
+
+$ xs = [1, 2, 3]
+~ sum = 0
+* x : xs {
+    ~ sum = sum + x
+}
+io.print("sum={sum}")
+
xo run outputsum=6
+
+ + diff --git a/www/scripts/verify-docs-pages.mjs b/www/scripts/verify-docs-pages.mjs index 1c3bcd97..6be65773 100644 --- a/www/scripts/verify-docs-pages.mjs +++ b/www/scripts/verify-docs-pages.mjs @@ -108,8 +108,9 @@ try { const navByLabel = new Map(primaryNav.map((item) => [item.label, item.to])); const expectedNav = [ ["Documents", "/docs"], + ["Book", "/book"], ["Packages", "/docs/std"], - ["Echo 2026", "/e26"], + ["Spec", "/e26"], ["Try", "/try"], ]; for (const [label, to] of expectedNav) { diff --git a/www/scripts/verify-prose.mjs b/www/scripts/verify-prose.mjs index 7e2221df..8baad1be 100644 --- a/www/scripts/verify-prose.mjs +++ b/www/scripts/verify-prose.mjs @@ -151,7 +151,16 @@ try { } prose.push({ where: "home definition", text: homePage.definition }); + prose.push({ where: "home description", text: homePage.description }); prose.push({ where: "home lead", text: homePage.lead }); + prose.push({ where: "home examples title", text: homePage.examplesTitle }); + prose.push({ where: "home examples lead", text: homePage.examplesLead }); + for (const item of homePage.highlights) { + prose.push({ where: `home highlight ${item.title}`, text: item.text }); + } + for (const example of homePage.examples) { + prose.push({ where: `home example ${example.caption}`, text: example.note }); + } prose.push({ where: "home status", text: homePage.status }); prose.push({ where: "footer blurb", text: footerBlurb }); prose.push({ where: "try lead", text: tryPage.lead }); diff --git a/www/scripts/verify-samples.mjs b/www/scripts/verify-samples.mjs new file mode 100644 index 00000000..86d3b7f9 --- /dev/null +++ b/www/scripts/verify-samples.mjs @@ -0,0 +1,96 @@ +/** + * Homepage snippets must be real files. Each `homePage.examples[].code` equals + * its `source` file under the repository root, and `homePage.sample` equals + * `samples/hero.echo`. Leading `;` comment lines in the files are not shown on + * the page. When an `xo` binary exists (XO_BIN, or ../target/debug/xo), each + * snippet also runs and its stdout must equal the output shown beside it. + */ +import { spawnSync } from "node:child_process"; +import { existsSync, readFileSync } from "node:fs"; +import { fileURLToPath } from "node:url"; +import path from "node:path"; +import { createServer } from "vite"; + +const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); +const repoRoot = path.resolve(root, ".."); + +function shown(text) { + const lines = text.replace(/\r\n/g, "\n").split("\n"); + while (lines.length && (lines[0].startsWith(";") || lines[0].trim() === "")) { + lines.shift(); + } + return lines.join("\n").trimEnd(); +} + +const server = await createServer({ + root, + logLevel: "error", + server: { middlewareMode: true }, + appType: "custom", +}); + +try { + const { homePage } = await server.ssrLoadModule("/src/docs/site.ts"); + const failures = []; + + const xoBin = + process.env.XO_BIN ?? + [path.join(repoRoot, "target/debug/xo"), path.join(repoRoot, "target/release/xo")].find( + existsSync, + ); + + const cases = [ + { + label: "hero", + file: path.join(root, "samples/hero.echo"), + code: homePage.sample, + output: homePage.sampleOutput, + }, + ...homePage.examples.map((example) => ({ + label: example.source, + file: path.join(repoRoot, example.source), + code: example.code, + output: example.output, + })), + ]; + + let executed = 0; + for (const item of cases) { + if (!existsSync(item.file)) { + failures.push(`${item.label}: source file is missing`); + continue; + } + if (shown(readFileSync(item.file, "utf8")) !== item.code.trimEnd()) { + failures.push( + `${item.label}: homepage code differs from ${path.relative(repoRoot, item.file)}`, + ); + } + if (xoBin) { + const run = spawnSync(xoBin, ["run", item.file], { encoding: "utf8", cwd: repoRoot }); + executed += 1; + if (run.status !== 0) { + failures.push(`${item.label}: xo run exited ${run.status}: ${run.stderr.slice(0, 200)}`); + } else if (run.stdout.trimEnd() !== item.output) { + failures.push( + `${item.label}: output ${JSON.stringify(run.stdout.trimEnd())} differs from page ${JSON.stringify(item.output)}`, + ); + } + } + } + + if (failures.length) { + console.error(JSON.stringify({ ok: false, failures }, null, 2)); + process.exitCode = 1; + } else { + console.log( + JSON.stringify({ + ok: true, + snippets: cases.length, + executed, + note: xoBin ? undefined : "xo binary not found; output was not re-run", + }), + ); + } +} finally { + await server.close(); +} diff --git a/www/scripts/verify-static-dist.mjs b/www/scripts/verify-static-dist.mjs index de1dfbe5..ba59d4e2 100644 --- a/www/scripts/verify-static-dist.mjs +++ b/www/scripts/verify-static-dist.mjs @@ -33,6 +33,9 @@ try { if (!existsSync(path.join(dist, "index.html"))) { fail("dist/index.html is missing; run this script after vite build"); } + if (!existsSync(path.join(dist, "og.png"))) { + fail("dist/og.png is missing; the social card is referenced from every page head"); + } for (const route of publicChromePaths()) { const page = pages.get(route); @@ -54,6 +57,19 @@ try { if (!html.includes(page.body)) { fail(`${route}: ${path.relative(root, file)} is missing the page body`); } + const url = site.publicCatalogUrl(route); + for (const needle of [ + ``, + `property="og:url"\n content="${url}"`, + ]) { + const flat = needle.replace(/\s+/g, " "); + if (!html.replace(/\s+/g, " ").includes(flat)) { + fail(`${route}: head is missing ${flat}`); + } + } + if (!/${site.homePage.definition}`)) { fail(`${route}: ${path.relative(root, file)} still has the homepage snapshot`); } diff --git a/www/src/app.tsx b/www/src/app.tsx index 6d0b7e91..0217c9a4 100644 --- a/www/src/app.tsx +++ b/www/src/app.tsx @@ -3,13 +3,25 @@ import { CtaLink } from "./components/cta-link"; import { EchoCode } from "./components/echo-code"; import { homePage } from "./docs/site"; +/** Keep the hyphenated word on one line so the heading never breaks mid-word. */ +function splitHyphenated(text: string, word: string): [string, string, string] { + const index = text.indexOf(word); + if (index < 0) { + return [text, "", ""]; + } + return [text.slice(0, index), word, text.slice(index + word.length)]; +} + export function HomePage() { + const definitionParts = splitHyphenated(homePage.definition, "glyph-led"); return (

- {homePage.definition} + {definitionParts[0]} + {definitionParts[1]} + {definitionParts[2]}

{homePage.lead} @@ -18,12 +30,12 @@ export function HomePage() { {homePage.status}

- Documents + Install xo Try Echo - - Install xo + + Documents
@@ -45,13 +57,90 @@ export function HomePage() { language="echo" variant="inline-block" /> +
+

+ xo run output +

+ 
+                {homePage.sampleOutput}
+
+
+
+ {homePage.highlights.map((item) => ( +
+

+ + {item.title} + +

+

{item.text}

+
+ ))} +
+ +
+

+ {homePage.examplesTitle} +

+

+ {homePage.examplesLead} +

+
+ {homePage.examples.map((example) => ( +
+

{example.note}

+
+
+
+ {example.caption} +
+ + source + +
+ +
+

+ xo run output +

+ 
+                    {example.output}
+
+
+
+
+ ))} +
+
+