From 62c6cc01c5bbe70ee61f564d7a8b4e1e26a370d9 Mon Sep 17 00:00:00 2001 From: simontreanor Date: Tue, 28 Jul 2026 18:49:38 +0100 Subject: [PATCH 1/2] docs: add Rust fundamentals guide for compiler internals A practical 17-section guide to Rust using examples from the Pyfun compiler, for readers new to Rust who want to understand the codebase. Covers ownership, impl blocks, pattern matching, Result types, traits, generics, lifetimes, memory layout, closures, error handling, modules, deriving traits, smart pointers, iterators, and syntax fundamentals. Placed in docs/src/internals as a prerequisite to the numbered compiler tour chapters, since the compiler is written in Rust and readers may need a language primer alongside the architecture tour. --- docs/src/SUMMARY.md | 1 + docs/src/internals/rust-primer.md | 1080 +++++++++++++++++++++++++++++ 2 files changed, 1081 insertions(+) create mode 100644 docs/src/internals/rust-primer.md diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md index 3d23775..4997722 100644 --- a/docs/src/SUMMARY.md +++ b/docs/src/SUMMARY.md @@ -43,6 +43,7 @@ # Inside the compiler +- [Learning Rust through this compiler](internals/rust-primer.md) - [The tour and its running example](internals/README.md) - [Orientation](internals/00-orientation.md) - [Lexing](internals/01-lexing.md) diff --git a/docs/src/internals/rust-primer.md b/docs/src/internals/rust-primer.md new file mode 100644 index 0000000..87649fd --- /dev/null +++ b/docs/src/internals/rust-primer.md @@ -0,0 +1,1080 @@ +# Learning Rust Through the Pyfun Compiler + +A practical guide to Rust fundamentals using real examples from a production compiler written in Rust. + +This primer is for readers new to Rust who want to understand the Pyfun compiler's source code. We'll walk through 18 core Rust concepts using excerpts from the actual compiler. If you're already familiar with Rust, skip ahead to the numbered chapters. + +## 1. Ownership and Borrowing + +Rust's superpower is memory safety without garbage collection. It achieves this through a system of **ownership** rules enforced at compile-time. + +### The Three Rules +1. **Each value has exactly one owner** — the variable responsible for cleaning it up +2. **You can borrow (reference) a value** — temporarily access it without taking ownership +3. **Mutable borrows are exclusive** — only one `&mut` at a time; immutable `&` borrows can be many + +### Real Example: The Lexer + +From `src/lexer/mod.rs`: + +```rust +struct Lexer<'a> { + src: &'a [u8], // Borrowed byte slice with lifetime 'a + pos: usize, + out: Vec, // Owned vector + errors: Vec, // Owned vector +} + +impl<'a> Lexer<'a> { + fn new(source: &'a str) -> Self { + Lexer { + src: source.as_bytes(), // Borrow the source + pos: 0, + out: Vec::new(), // Create new owned vector + errors: Vec::new(), + } + } +} +``` + +**What's happening:** +- `Lexer` borrows the input `source` for its entire lifetime (`'a`) +- The `'a` annotation means: "this reference is valid as long as `'a` is valid" +- `out` and `errors` are **owned** by the struct — when `Lexer` is dropped, these vectors are automatically freed +- `source` is **not** freed when `Lexer` is dropped; the original owner still owns it + +**Why this matters:** +This pattern lets the compiler prevent use-after-free bugs. The type system guarantees that `src` won't be freed while `Lexer` exists. + +### Mutable Borrows: The Lexer's Main Loop + +```rust +fn run(mut self) -> (Vec, Vec) { + loop { + let crossed_newline = self.skip_trivia(); + // ... + if let Err(error) = self.lex_one() { + self.errors.push(error); // Mutate self.errors + } + // ... + } + (self.out, self.errors) // Move ownership of out/errors back to caller +} +``` + +**Key points:** +- `self` is `mut`, so we can call methods that mutate `self` +- `self.errors.push(error)` mutates the vector — this is only allowed because `self` is uniquely owned +- At the end, we return ownership of `out` and `errors` to the caller + +--- + +## 2. The `impl` Keyword: Adding Methods to Types + +`impl` stands for **implement**. It's how you add methods (functions attached to a type) to that type. Think of it as "we're implementing behavior for this type." + +### Basic impl Block + +```rust +struct Point { + x: i32, + y: i32, +} + +impl Point { + fn new(x: i32, y: i32) -> Point { + Point { x, y } + } + + fn distance_from_origin(&self) -> f64 { + (((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()) + } +} + +// Usage +let p = Point::new(3, 4); +println!("{}", p.distance_from_origin()); // Prints 5.0 +``` + +**Reading this:** +- `impl Point` says: "We're adding methods to the `Point` type" +- `Point::new(...)` is an **associated function** (called on the type itself, not an instance) +- `p.distance_from_origin()` is a **method** (called on an instance) +- `&self` means the method borrows the point (doesn't modify it or take ownership) + +### Multiple impl Blocks + +You can split methods across multiple `impl` blocks: + +```rust +impl Point { + fn new(x: i32, y: i32) -> Point { Point { x, y } } +} + +impl Point { + fn translate(&mut self, dx: i32, dy: i32) { + self.x += dx; + self.y += dy; + } +} +``` + +Both blocks add to the same type. This is useful for organizing code. + +### Implementing a Trait + +From `src/lib.rs`: + +```rust +impl std::fmt::Display for CompileError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + CompileError::Lex(e) => write!(f, "lex error: {e}"), + CompileError::Parse(e) => write!(f, "parse error: {e}"), + CompileError::Type(e) => write!(f, "type error: {e}"), + CompileError::Lower(e) => write!(f, "lowering error: {e}"), + } + } +} +``` + +`impl Trait for Type` means: "Implement this trait for this type." + +After this, you can do: +```rust +let err = CompileError::Lex(...); +println!("{}", err); // Calls the Display::fmt method +``` + +### Generic impl Blocks + +```rust +impl Vec { + fn len(&self) -> usize { + // ... + } +} +``` + +This adds a method `len()` to `Vec` for *any* type `T`. + +### Real Example: Unit Operations + +From `src/types/mod.rs`: + +```rust +impl Unit { + fn dimensionless() -> Unit { + Unit::default() + } + + fn base(name: &str) -> Unit { + let mut u = Unit::default(); + u.insert(Atom::Base(name.to_string()), 1); + u + } + + fn mul(&self, other: &Unit) -> Unit { + let mut r = self.clone(); + for (a, e) in &other.factors { + r.insert(a.clone(), *e); + } + r + } + + fn is_dimensionless(&self) -> bool { + self.factors.is_empty() + } +} +``` + +**Methods:** +- `Unit::dimensionless()` — associated function (creates a default unit) +- `Unit::base("m")` — associated function (creates a unit from a base measure) +- `unit1.mul(&unit2)` — method (multiplies two units) +- `unit.is_dimensionless()` — method (checks if dimensionless) + +--- + +## 3. Pattern Matching and Enums + +Rust enums are **tagged unions** (like discriminated unions in TypeScript). Pattern matching on them is exhaustive — the compiler won't let you miss a case. + +### Representing Errors with Enums + +From `src/lib.rs`: + +```rust +#[derive(Debug, Clone, PartialEq)] +pub enum CompileError { + Lex(lexer::LexError), + Parse(parser::ParseError), + Type(types::TypeError), + Lower(lowering::LowerError), +} +``` + +This says: "A `CompileError` is one of four things: a lex error, a parse error, a type error, or a lowering error. Each variant can carry associated data." + +### Pattern Matching: Exhaustive Handling + +```rust +impl CompileError { + pub fn span(&self) -> lexer::Span { + match self { + CompileError::Lex(e) => e.span, + CompileError::Parse(e) => e.span, + CompileError::Type(e) => e.span, + CompileError::Lower(_) => lexer::Span::new(0, 0), + } + } +} +``` + +**The compiler enforces:** +1. **All cases are handled** — if you forget one variant, it won't compile +2. **The return type is consistent** — all arms return the same type (`lexer::Span`) +3. **No null pointers** — you can't have a `CompileError` that's somehow uninitialized + +Compare to null-checking in other languages: +```javascript +// JavaScript — you can forget to check +if (error.type === 'Lex') { ... } +// What if error is null? What if type is undefined? +``` + +```rust +// Rust — you must handle all cases +match error { + CompileError::Lex(e) => { ... } + CompileError::Parse(e) => { ... } + CompileError::Type(e) => { ... } + CompileError::Lower(e) => { ... } + // Compiler error if you forget one! +} +``` + +### Pattern Matching with Destructuring + +From `src/main.rs`: + +```rust +fn has_imports(module: &Module) -> bool { + module + .items + .iter() + .any(|i| matches!(i, Item::Import { .. })) +} +``` + +The `matches!` macro checks if an item matches a pattern without extracting the data. The `..` means "ignore the contents of this variant." + +More explicit version: + +```rust +for item in &module.items { + if let Item::Import { name, span } = item { + println!("Found import: {}", name); + } +} +``` + +This extracts `name` and `span` only if `item` is an `Import`. If it's any other variant, the body is skipped. + +--- + +## 4. The Result Type: Representing Failures + +Instead of exceptions, Rust uses `Result` — a type that says "this can either succeed with a value of type `T` or fail with an error of type `E`." + +### Defining Results + +From `src/lib.rs`: + +```rust +pub fn parse(source: &str) -> Result { + let tokens = lexer::lex(source).map_err(CompileError::Lex)?; + parser::parse(tokens).map_err(CompileError::Parse) +} +``` + +**Reading this:** +- `lexer::lex(source)` returns `Result, LexError>` +- `.map_err(CompileError::Lex)` converts `Err(LexError)` to `Err(CompileError::Lex(...))` +- `?` is the "propagate error" operator: if `lex` fails, return immediately with the error +- If `lex` succeeds, unwrap the `Vec` and assign to `tokens` + +This is equivalent to exception handling: +```rust +// Rust (explicit) +match lexer::lex(source) { + Ok(tokens) => { /* continue */ } + Err(e) => return Err(CompileError::Lex(e)), +} +``` + +But the `?` operator makes it concise like exception handling while remaining explicit about error paths. + +### Handling Results at Call Sites + +From `src/main.rs`: + +```rust +fn check(path: &str) -> ExitCode { + let Some(source) = read(path) else { + return ExitCode::FAILURE; + }; + + let module = match pyfun::parse(&source) { + Ok(m) => m, + Err(e) => { + eprintln!("{}", diagnostics::render(&source, Level::Error, &e.message(), e.span())); + return ExitCode::FAILURE; + } + }; + // Continue with module... +} +``` + +**Pattern: `let Some(...) else`** +- If `read(path)` returns `Some(source)`, bind it and continue +- Otherwise, execute the `else` block (early return with failure) + +This is Rust's way of handling nullable values without `null` — either a value is `Some(x)` or it's `None`. + +--- + +## 5. Type Traits: Shared Behavior + +A **trait** is like an interface: it defines a set of methods that types can implement. + +### Simple Trait: Display + +```rust +impl std::fmt::Display for CompileError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + CompileError::Lex(e) => write!(f, "lex error: {e}"), + CompileError::Parse(e) => write!(f, "parse error: {e}"), + CompileError::Type(e) => write!(f, "type error: {e}"), + CompileError::Lower(e) => write!(f, "lowering error: {e}"), + } + } +} + +impl std::error::Error for CompileError {} +``` + +This says: +- `CompileError` can be formatted as a string (supports `format!("{}", error)` and `print!("{}", error)`) +- `CompileError` implements the standard `Error` trait (so it can be used anywhere an error is expected) + +### Generic Traits: Handling Any Error Type + +From `src/main.rs`, here's where the `Display` trait proves valuable: + +```rust +fn main() -> ExitCode { + match pyfun::compile(&source) { + Ok(python) => { /* ... */ } + Err(e) => { + eprintln!("{}", diagnostics::render(&source, Level::Error, &e.message(), e.span())); + ExitCode::FAILURE + } + } +} +``` + +Because `CompileError` implements the `Display` trait, we can call `e.message()` uniformly on any error, whether it came from the lexer, parser, type-checker, or lowerer. + +--- + +## 6. Generics and Type Parameters + +Generics let you write code that works for many types while staying type-safe. + +### Generic Data Structures + +From `src/parser/ast.rs`: + +```rust +pub enum TypeExpr { + Con(String, NodeSpan, Vec), // Vec of TypeExpr + Fun(Box, Box, Vec), // Nested TypeExpr + Tuple(Vec), +} +``` + +This is recursive: `TypeExpr` contains `Vec`. The compiler knows the size only because `Vec` is a heap-allocated pointer, so a `TypeExpr` is always a fixed size. + +### Lifetimes: Tying References Together + +Lifetimes are **generic parameters for references**. They connect the lifetime of a borrow to the lifetime of the data being borrowed. + +From `src/lexer/mod.rs`: + +```rust +struct Lexer<'a> { + src: &'a [u8], +} + +impl<'a> Lexer<'a> { + fn new(source: &'a str) -> Self { ... } +} +``` + +**Reading this:** +- `'a` is a lifetime parameter (any valid lifetime, written as `'variable_name`) +- `&'a [u8]` means "a reference to a byte slice valid for lifetime `'a`" +- The `impl<'a>` says: "implement these methods for any lifetime `'a`" + +This lets the compiler check: "Does the `Lexer` live longer than the source? If so, compilation fails." + +Without lifetimes: +```rust +struct BadLexer { + src: &[u8], // Compiler error! How long should the reference live? +} +``` + +Rust won't let you write this because it can't guarantee the reference won't outlive the source. + +--- + +## 7. Memory Layout: Stack vs Heap + +Rust gives you fine-grained control over where values live. + +### Stack-Allocated Structs + +```rust +#[derive(Debug, Clone, Copy)] +pub struct NodeSpan(pub Span); +``` + +- `#[derive(Debug)]` auto-implements a debug printer +- `#[derive(Clone)]` auto-implements a copy operation +- `Copy` means the value is automatically copied when moved (for tiny values like pointers) +- `NodeSpan` lives on the stack if it's a local variable — cheap to create/destroy + +### Heap-Allocated Collections + +```rust +pub struct Module { + pub items: Vec, +} +``` + +- `Vec` is a heap-allocated vector (like `ArrayList` in Java or a Python list) +- When `Module` is dropped, the `Vec` is automatically freed +- This is zero-cost abstraction: no garbage collector, just deterministic cleanup + +### Heap Allocation with Box + +```rust +pub enum TypeExpr { + Fun(Box, Box, Vec), +} +``` + +- `Box` is a heap-allocated `TypeExpr` +- We use `Box` here because `TypeExpr` is recursive — if we used `TypeExpr` directly, the size would be infinite +- `Box` gives us a pointer (fixed size) to the actual `TypeExpr` on the heap + +--- + +## 8. Closures and Higher-Order Functions + +Closures are functions that capture variables from their environment. + +### Simple Closures + +From `src/types/mod.rs`: + +```rust +pub fn float_literal_spans(types: &[types::TypeSpan]) -> std::collections::HashSet { + types + .iter() + .filter(|t| t.ty == "float" || t.ty.starts_with("float<")) + .map(|t| t.span) + .collect() +} +``` + +- `|t| t.ty == "float"` is a closure taking one parameter `t` and returning a bool +- `|t| t.span` is a closure that returns `t.span` +- These closures don't capture any external variables (they only use their parameter) + +### Closures That Capture Environment + +```rust +let parse_errors: Vec<_> = parse_errors + .iter() + .map(|e| to_type_error(&CompileError::Parse(e.clone()))) + .collect(); +``` + +The closure `|e| to_type_error(&CompileError::Parse(...))` captures nothing from the environment but creates a new value that includes `CompileError::Parse`. + +### Mutable Closures + +```rust +let mut result = Vec::new(); +items.iter().for_each(|item| { + result.push(process(item)); // Captures and mutates result +}); +``` + +The closure captures `result` mutably, so it can push to it. This requires `result` to be declared `mut`. + +--- + +## 9. Error Handling Patterns + +### The Question Mark Operator + +```rust +pub fn compile(source: &str) -> Result { + let module = parse(source)?; // If parse fails, return the error immediately + let (mut errors, types, holes, ordered) = types::check_collecting(&module); + if !errors.is_empty() { + return Err(CompileError::Type(errors.remove(0))); // Explicit early return + } + // ... continue +} +``` + +The `?` operator is syntactic sugar for: +```rust +let module = match parse(source) { + Ok(m) => m, + Err(e) => return Err(e), +}; +``` + +### Checked/Unchecked Indexing + +From `src/main.rs`: + +```rust +while i < args.len() { + match args[i].as_str() { + "-o" | "--output" => { + i += 1; + out = Some(args.get(i).ok_or("`-o` needs a path")?.clone()); + } + // ... + } +} +``` + +**Safe indexing:** +- `args[i]` — panics if out of bounds (use when you're sure it's safe) +- `args.get(i)` — returns `Option`: `Some(value)` if in bounds, `None` if not +- `.ok_or(...)` converts `None` to an `Err`, then `?` propagates it + +--- + +## 10. Modules and Visibility + +The module system organizes code into namespaces. + +### File Structure + +From the Pyfun `src/` directory structure: +``` +src/ +├── lib.rs (defines what's public from the whole crate) +├── main.rs (CLI binary) +├── lexer/ +│ ├── mod.rs (defines the lexer module) +│ └── token.rs (sub-module of lexer) +├── parser/ +│ ├── mod.rs +│ └── ast.rs +└── types/ + └── mod.rs +``` + +### Visibility Control + +From `src/lib.rs`: + +```rust +pub mod ast; // Public module, accessible to users of the crate +pub mod desugar; +pub mod diagnostics; +pub mod lexer; +pub mod lsp; +pub mod parser; +pub mod project; +pub mod python_emitter; +pub mod types; + +pub use parser::ast as syntax; // Re-export as `syntax` for convenience +``` + +- `pub mod name` — the module is public +- `pub use` — re-export something under a new name +- Without `pub`, a module/function is private to the crate + +### Functions and their Visibility + +```rust +pub fn parse(source: &str) -> Result { + // ... +} + +fn to_type_error(error: &CompileError) -> types::TypeError { + // Private function, used only within this module +} +``` + +--- + +## 11. Deriving Traits + +The `#[derive(...)]` attribute auto-implements common traits. + +From `src/parser/ast.rs`: + +```rust +#[derive(Debug, Clone, PartialEq)] +pub enum CompileError { + Lex(lexer::LexError), + Parse(parser::ParseError), + Type(types::TypeError), + Lower(lowering::LowerError), +} +``` + +- `#[derive(Debug)]` — auto-generates a debug printer (for `{:?}` in format strings) +- `#[derive(Clone)]` — auto-generates a clone method (deep copy) +- `#[derive(PartialEq)]` — auto-generates equality comparison + +These traits are derived only for types whose fields also implement them. + +--- + +## 12. Smart Pointers and Reference Counting + +### Box: Unique Ownership + +```rust +pub enum TypeExpr { + Fun(Box, Box, Vec), +} +``` + +`Box` means: "I own a single heap-allocated `T`. When I'm dropped, the `T` is freed." + +### Rc: Shared Ownership (Single-Threaded) + +```rust +// Not used much in Pyfun, but common in other Rust programs: +use std::rc::Rc; + +let shared = Rc::new(some_data); +let clone1 = Rc::clone(&shared); // Increment reference count +let clone2 = Rc::clone(&shared); // Increment reference count +// When clone2, clone1, and shared are all dropped, the data is freed +``` + +--- + +## 13. Iterators and Functional Chains + +Rust's iterator API is lazy: nothing happens until you consume the iterator. + +### Lazy Evaluation + +```rust +pub fn float_literal_spans(types: &[types::TypeSpan]) -> std::collections::HashSet { + types + .iter() // Start iterating (lazy) + .filter(|t| t.ty == "float" || t.ty.starts_with("float<")) // Filter predicate (lazy) + .map(|t| t.span) // Transform (lazy) + .collect() // Consume the iterator (executes the chain) +} +``` + +Nothing runs until `.collect()`. The compiler optimizes this chain into a single efficient loop. + +### Collecting into Different Types + +```rust +// Collect into a Vec +let vec: Vec<_> = items.iter().map(transform).collect(); + +// Collect into a HashSet +let set: HashSet<_> = items.iter().map(transform).collect(); + +// Collect into a HashMap +let map: HashMap = items.iter().map(|(k, v)| (k, v)).collect(); +``` + +The type annotation tells `.collect()` what to produce. + +--- + +## 14. Error Messages and Diagnostics + +### Using Display and Debug + +```rust +pub struct LexError { + pub message: String, + pub span: Span, +} + +impl std::fmt::Display for LexError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{} (at {}..{})", self.message, self.span.start, self.span.end) + } +} +``` + +- `Display` (`{}`) — a user-friendly, concise error +- `Debug` (`{:?}`) — a verbose, developer-friendly error (auto-derived) + +```rust +println!("{}", lex_error); // Calls Display: "unexpected character (at 42..43)" +println!("{:?}", lex_error); // Calls Debug: "LexError { message: \"unexpected character\", span: Span { start: 42, end: 43 } }" +``` + +--- + +## 15. Syntax Fundamentals + +### Variables and Mutability + +```rust +let x = 5; // Immutable by default +let mut y = 5; // Mutable variable +const MAX: usize = 100; // Compile-time constant + +let x = "hello"; // Shadowing: rebind x to a new value (different type OK) +``` + +**Rust is immutable-by-default** — you must explicitly opt-in to mutability with `mut`. This makes it easier to reason about which values change. + +### Type Annotations + +```rust +let x: i32 = 5; // Type annotation (usually optional—inferred) +let items: Vec = Vec::new(); // Generic type with type parameter +let f: fn(i32) -> i32 = |x| x * 2; // Function pointer type +let r: &str = "hello"; // Reference to a string literal +``` + +Type annotations are optional when the compiler can infer them, but required in some contexts (like function parameters and return types). + +### Semicolons and Expressions + +```rust +let x = { + let y = 3; + y + 1 // No semicolon—this is an expression that returns 4 +}; +assert_eq!(x, 4); + +let z = { + let y = 3; + y + 1; // Semicolon—this turns it into a statement, returns () +}; +assert_eq!(z, ()); +``` + +**Rust distinguishes statements from expressions:** +- **Expressions** return a value (no semicolon at the end) +- **Statements** perform an action and return nothing (semicolon at the end) + +This is why `let x = if cond { 5 } else { 6 };` works — the `if` is an expression. + +### Function Declarations + +```rust +fn add(a: i32, b: i32) -> i32 { + a + b // Return the expression (no semicolon) +} + +fn print_and_return(msg: &str) -> String { + println!("{}", msg); + msg.to_string() +} + +fn side_effect() { + println!("Hello!"); + // Returns () +} +``` + +**Rust functions always return a value:** +- Explicit `return` statement (with semicolon): `return x;` +- Final expression (without semicolon): `x` +- No explicit return → returns `()` (unit type) + +### Operators + +```rust +// Arithmetic +let sum = 5 + 6; +let product = 12 / 3; +let remainder = 7 % 3; +let power = 2_i32.pow(3); + +// Comparison +let x = 5; +let is_greater = x > 3; // true +let is_equal = x == 5; // true +let in_range = x >= 3 && x <= 7; + +// Logical +let a = true || false; // OR +let b = true && false; // AND +let c = !true; // NOT + +// String/Collection operators +let s = "Hello".to_string() + " " + "World"; +let v = vec![1, 2, 3]; +let first = v[0]; // Index (panics if out of bounds) +``` + +### String Types + +```rust +let s1 = "hello"; // &str — string literal (immutable, fixed size) +let s2 = String::from("hello"); // String — owned, mutable, heap-allocated +let s3 = "hello".to_string(); // String — owned copy + +let mut s = String::new(); +s.push_str("hello"); // Append to mutable String +s.push('!'); // Append a character + +// String interpolation +let name = "Alice"; +let greeting = format!("Hello, {}!", name); +``` + +**Key distinction:** +- `&str` — a view into existing string data (can't modify) +- `String` — owns the string data (can modify, can grow) + +### Collections + +```rust +// Vectors (dynamic arrays) +let v: Vec = vec![1, 2, 3]; +let mut items = Vec::new(); +items.push(1); +items.push(2); +let first = items[0]; +let maybe_first = items.get(0); // Returns Option + +// HashMaps (dictionaries) +use std::collections::HashMap; +let mut map = HashMap::new(); +map.insert("key", "value"); +map.get("key"); // Returns Option<&V> + +// HashSets (unique values) +use std::collections::HashSet; +let mut set = HashSet::new(); +set.insert(1); +set.insert(2); +set.contains(&1); // Returns bool +``` + +### Control Flow + +```rust +// if expressions (return values) +let x = if condition { 5 } else { 6 }; + +// match (exhaustive pattern matching) +match value { + 1 => println!("one"), + 2 | 3 => println!("two or three"), + n if n > 10 => println!("big number"), + _ => println!("something else"), +} + +// loops +for i in 0..5 { + println!("{}", i); // Prints 0, 1, 2, 3, 4 +} + +let mut count = 0; +while count < 5 { + count += 1; +} + +loop { + if should_break { break; } +} + +// Named loop breaks +'outer: for i in 0..3 { + for j in 0..3 { + if i == 1 && j == 1 { + break 'outer; // Break from outer loop + } + } +} +``` + +### Ranges + +```rust +let r1 = 0..5; // [0, 1, 2, 3, 4] — excludes end +let r2 = 0..=5; // [0, 1, 2, 3, 4, 5] — includes end +let r3 = 0..; // [0, 1, 2, ...] — infinite range + +for i in 0..3 { + println!("{}", i); +} +``` + +### Tuples + +```rust +let tuple = (5, "hello", true); +let (a, b, c) = tuple; // Destructure +let first = tuple.0; // Access by index +``` + +### Struct Literals + +```rust +struct Point { x: i32, y: i32 } + +let p = Point { x: 5, y: 10 }; +let Point { x, y } = p; // Destructure + +// Shorthand (if variable name matches field name) +let x = 5; +let y = 10; +let p = Point { x, y }; // Same as Point { x: x, y: y } +``` + +### Comments + +```rust +// Single-line comment + +/* Multi-line + comment */ + +/// Doc comment for the item below (exported in documentation) +fn documented() {} + +//! Module-level doc comment (exported in documentation) +``` + +### Method Chaining Syntax + +From `src/lib.rs`: + +```rust +let syntax_errors: Vec<_> = lex_errors + .iter() + .map(|e| to_type_error(&CompileError::Lex(e.clone()))) + .chain( + parse_errors + .iter() + .map(|e| to_type_error(&CompileError::Parse(e.clone()))), + ) + .collect(); +``` + +Methods are called with dot notation, and chains can span multiple lines. The `.` operator automatically dereferences and borrows as needed. + +### The `?` Operator (Try Operator) + +```rust +fn parse_compile_args(args: &[String]) -> Result<(&str, Option, PyTarget), String> { + let mut i = 0; + while i < args.len() { + match args[i].as_str() { + "--target" => { + i += 1; + target = match args.get(i).map(String::as_str) { + Some("3.11") => PyTarget::Py311, + Some("3.12") => PyTarget::Py312, + Some(other) => return Err(format!("`--target` must be 3.11 or 3.12, got `{other}`")), + None => return Err("`--target` needs a version (3.11 or 3.12)".to_string()), + }; + } + // ... + } + i += 1; + } + Ok((path.ok_or("`compile` needs a file path")?, out, target)) +} +``` + +The `?` operator: +- On `Result`: if `Err`, return immediately with that error; if `Ok(v)`, unwrap to `v` +- On `Option`: if `None`, return immediately with an error; if `Some(v)`, unwrap to `v` + +This makes error handling concise without try-catch verbosity. + +--- + +## 16. Common Patterns + +### The `match` Guard + +```rust +match item { + Item::Expr(e) if is_side_effect(&e) => { + // Only match if is_side_effect returns true + } + _ => { /* default */ } +} +``` + +### Destructuring in Function Parameters + +```rust +fn render_project_error(entry: &str, error: &ProjectError) -> ExitCode { + match error { + ProjectError::Compile { name, error } => { + // Extract name and error from the variant + eprintln!("error: in module `{name}`: {}", error.message()) + } + other => eprintln!("error: {other}"), + } +} +``` + +### Early Returns with Explicit Unwrapping + +```rust +let Some(source) = read(path) else { + return ExitCode::FAILURE; +}; +``` + +This pattern (introduced in Rust 1.65) is cleaner than nested if-let. + +--- + +## 17. Key Takeaways + +1. **Ownership is enforced at compile-time** — no garbage collector, no panics (usually) +2. **Rust is explicit about failures** — use `Result` and `Option` instead of exceptions/null +3. **Pattern matching is exhaustive** — the compiler ensures you handle all cases +4. **Generics are monomorphic** — each generic is specialized at compile-time (no runtime overhead like Java generics) +5. **Lifetimes prevent dangling references** — the compiler checks that references don't outlive their data +6. **Traits provide shared behavior** — interfaces without inheritance +7. **Iterators are lazy** — chains of operations optimize into single loops +8. **The type system is your friend** — compile-time errors are vastly better than runtime panics + +Rust is harder to learn than Python or JavaScript, but the payoff is correctness: if it compiles, it's very likely to work correctly. The compiler is famous for being strict but fair — once you understand the rules, the error messages guide you to the fix. + +--- + +## Next Steps + +Now that you're familiar with Rust fundamentals, dive into the numbered chapters to see how these concepts come together in a real compiler. Each chapter focuses on one stage of the pipeline and calls out Rust idioms as they appear in context. From 140ae318249f566df60c0889601873fbb3ed2ae6 Mon Sep 17 00:00:00 2001 From: simontreanor Date: Tue, 28 Jul 2026 18:59:14 +0100 Subject: [PATCH 2/2] extern: caller-supplied keyword slots (`kw = ...`) Pinned kwargs took only literals fixed at the declaration, so a call whose keyword value comes from the caller needed a separate extern per call shape. A `...` in place of the literal now takes the value from the caller, spelled as in a Python stub file and lexed as one token. The target takes the leading arguments positionally and the slots take the trailing ones in written order; pinned literals consume no argument, so the two mix freely on all three target forms. A slot claims one argument of the declared arrow, so a receiver-only or nullary extern has none to spare and is rejected with a diagnostic. Under-application cannot use functools.partial, which has no way to carry a keyword whose value has not arrived, so it becomes a lambda over the missing arguments. Already-supplied arguments (and a method extern's receiver) bind to temporaries first, keeping the evaluation timing functools.partial had. The type is untouched: a slot changes only where an argument lands in the emitted call, so inference, effects and arity are unchanged. --- DESIGN.md | 28 + ROADMAP.md | 14 - editors/tree-sitter-pyfun/grammar.js | 5 +- editors/tree-sitter-pyfun/src/grammar.json | 17 +- editors/tree-sitter-pyfun/src/node-types.json | 8 + editors/tree-sitter-pyfun/src/parser.c | 5448 +++++++++-------- .../tree-sitter-pyfun/test/corpus/items.txt | 30 + src/ast/mod.rs | 1 + src/lexer/mod.rs | 38 + src/lexer/token.rs | 5 + src/lowering/mod.rs | 277 +- src/parser/ast.rs | 19 +- src/parser/mod.rs | 62 +- tests/compile.rs | 133 + tests/roundtrip.rs | 6 + 15 files changed, 3279 insertions(+), 2812 deletions(-) diff --git a/DESIGN.md b/DESIGN.md index c3c5325..2ae08fe 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -341,6 +341,34 @@ kwargs-extern carries them through `functools.partial` (`openText` → `functool mode="rt", encoding="utf-8")`), so a later application still supplies them; only a full (or over-) application emits the direct `f(a, kw=v)` call. +**Caller-supplied keyword slots (`= target(kw = ...)`).** Python's API culture is optional keyword +arguments with defaults, and pinning a literal only covers the value that is fixed for every call. A +`...` in place of the literal makes the keyword's value come from the **caller** instead: + +``` +extern parseInt : string -> int -> int = int(base = ...) # parseInt "ff" 16 → int("ff", base=16) +extern openText : string -> string -> Seq string = builtins.open(mode = "rt", encoding = ...) +extern writeText : Path -> string -> string -> int = .write_text(encoding = ...) +``` + +The spelling is Python's own stub-file placeholder (`def get(url, timeout=...)`), lexed as one token. +The **binding rule** is positional and mirrors a Python call: the target takes the leading arguments +positionally and the `...` slots take the **trailing** ones, in the order the keywords are written; +pinned literals consume no argument, so they may sit anywhere among the slots +(`m.f(a = 1, b = ..., c = "x", d = ...)` at arity 3 emits `m.f(s, a=1, b=i, c="x", d=b)`). A slot claims +one argument of the declared arrow, so the type must have one to spare: a receiver takes the first +argument, and a nullary extern's only argument is the `unit` that lowering drops, so both are rejected +with a diagnostic rather than silently mis-lowered. + +A slot changes only *where* an argument lands in the emitted call, so like a pinned literal it stays +**invisible to the type** (`parseInt` is an ordinary `string -> int -> int`), to inference, and to +effects. Under-application still never drops anything, but it cannot use `functools.partial`, which has +no way to carry a keyword whose value has not arrived. An under-applied slot extern becomes a **lambda** +over the remaining arguments (`parseInt "ff"` → `lambda _pf_k0: int("ff", base=_pf_k0)`; a bare +`parseInt` → `lambda _pf_k0, _pf_k1: int(_pf_k0, base=_pf_k1)`). The arguments already supplied are +bound to temporaries first, so they evaluate at application time exactly as `functools.partial` would +have evaluated them, rather than once per later call; a receiver is bound the same way. + **Lists — the eager collection.** `List a` is a built-in type that **lowers to a Python `list`** (a dynamic array), with literal syntax `[1, 2, 3]` (comma-separated, like Python and like Pyfun records and tuples). The big-O is Python's, *not* diff --git a/ROADMAP.md b/ROADMAP.md index 5a3b881..454b069 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -29,20 +29,6 @@ Keep this a *forward-looking* backlog — do not let it grow back into a changel §5.3: statically-known decoders deforest to direct dict/list access, byte-identical `Result`s, 2.8x measured on a decode-dominated workload; dynamic shapes (`andThen`, decoder-as-value) keep the interpreter.) -- **Caller-varying keyword arguments at the `extern` boundary** (M) — pinned kwargs (`DESIGN.md` §6) - accept only *literals fixed at the declaration*, so a call whose keyword value comes from the caller - (`requests.get(url, timeout = t)`) needs a separate extern per call shape. Python's API culture is - optional-kwargs-with-defaults, so this is the boundary friction a real user is likeliest to meet first, - and it is the one place where the declaration count scales with the *call shapes* used rather than with - the functions called. The shape is open and the bar is Pythonista familiarity, so offer the - alternatives before shipping one: a marked slot in the existing pinned list (`= requests.get(timeout = _)`, filled by the next argument) is the smallest - step and needs no new type machinery, since the slot consumes an ordinary arrow and only the emitted - call shape changes; a record-of-options argument types better but wants optional fields, which nothing - else in the language has. Distinct from the **`extern` stub generator** non-goal below: that one - automates *writing* signatures, this one makes a signature expressible at all. The complementary cost, - that every user re-derives the same wrapper lines independently, is the façade half of **Larger prelude - / package manager** above. - - ~~Module-alias shadowing~~ **CLOSED 2026-07-27** — `import Ids` + any same-named binder (top-level `let`, parameter, block `let` anywhere in the function, lambda parameter, match-pattern capture at any level, native-CE binder) now emits `import ids as _pf_ids` at the affected sites diff --git a/editors/tree-sitter-pyfun/grammar.js b/editors/tree-sitter-pyfun/grammar.js index af169da..1375f47 100644 --- a/editors/tree-sitter-pyfun/grammar.js +++ b/editors/tree-sitter-pyfun/grammar.js @@ -209,9 +209,12 @@ module.exports = grammar({ extern_kwarg: $ => seq( field('name', $.identifier), '=', - field('value', $._extern_literal), + field('value', choice($._extern_literal, $.extern_slot)), ), + // `...` — the value comes from the caller rather than the declaration. + extern_slot: _ => '...', + _extern_literal: $ => choice( $.string, $.boolean, diff --git a/editors/tree-sitter-pyfun/src/grammar.json b/editors/tree-sitter-pyfun/src/grammar.json index 67a277a..6cccad8 100644 --- a/editors/tree-sitter-pyfun/src/grammar.json +++ b/editors/tree-sitter-pyfun/src/grammar.json @@ -1010,12 +1010,25 @@ "type": "FIELD", "name": "value", "content": { - "type": "SYMBOL", - "name": "_extern_literal" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_extern_literal" + }, + { + "type": "SYMBOL", + "name": "extern_slot" + } + ] } } ] }, + "extern_slot": { + "type": "STRING", + "value": "..." + }, "_extern_literal": { "type": "CHOICE", "members": [ diff --git a/editors/tree-sitter-pyfun/src/node-types.json b/editors/tree-sitter-pyfun/src/node-types.json index 626abff..acdc4f9 100644 --- a/editors/tree-sitter-pyfun/src/node-types.json +++ b/editors/tree-sitter-pyfun/src/node-types.json @@ -1940,6 +1940,10 @@ "type": "boolean", "named": true }, + { + "type": "extern_slot", + "named": true + }, { "type": "float", "named": true @@ -4728,6 +4732,10 @@ "type": "extern", "named": false }, + { + "type": "extern_slot", + "named": true + }, { "type": "f\"", "named": false diff --git a/editors/tree-sitter-pyfun/src/parser.c b/editors/tree-sitter-pyfun/src/parser.c index 64c821e..0ee4445 100644 --- a/editors/tree-sitter-pyfun/src/parser.c +++ b/editors/tree-sitter-pyfun/src/parser.c @@ -9,9 +9,9 @@ #define LANGUAGE_VERSION 15 #define STATE_COUNT 900 #define LARGE_STATE_COUNT 104 -#define SYMBOL_COUNT 227 +#define SYMBOL_COUNT 228 #define ALIAS_COUNT 6 -#define TOKEN_COUNT 88 +#define TOKEN_COUNT 89 #define EXTERNAL_TOKEN_COUNT 3 #define FIELD_COUNT 32 #define MAX_ALIAS_SEQUENCE_LENGTH 8 @@ -40,218 +40,219 @@ enum ts_symbol_identifiers { anon_sym_import = 18, anon_sym_as = 19, anon_sym_DOT = 20, - anon_sym_DASH = 21, - anon_sym_LT_DASH = 22, - anon_sym_fun = 23, - anon_sym_DASH_GT = 24, - anon_sym_if = 25, - anon_sym_then = 26, - anon_sym_else = 27, - anon_sym_elif = 28, - anon_sym_match = 29, - anon_sym_case = 30, - anon_sym_PIPE_GT = 31, - anon_sym_LT_PIPE = 32, - anon_sym_GT_GT = 33, - anon_sym_LT_LT = 34, - anon_sym_or = 35, - anon_sym_and = 36, - anon_sym_not = 37, - anon_sym_try = 38, - anon_sym_EQ_EQ = 39, - anon_sym_BANG_EQ = 40, - anon_sym_LT = 41, - anon_sym_GT = 42, - anon_sym_LT_EQ = 43, - anon_sym_GT_EQ = 44, - anon_sym_PLUS = 45, - anon_sym_STAR = 46, - anon_sym_SLASH = 47, - anon_sym_SLASH_SLASH = 48, - anon_sym_PERCENT = 49, - anon_sym_STAR_STAR = 50, - anon_sym_LBRACK = 51, - anon_sym_RBRACK = 52, - anon_sym_with = 53, - anon_sym_async = 54, - anon_sym_seq = 55, - anon_sym_result = 56, - anon_sym_let_BANG = 57, - anon_sym_do_BANG = 58, - anon_sym_return = 59, - anon_sym_return_BANG = 60, - anon_sym_yield = 61, - anon_sym_yield_BANG = 62, - sym_wildcard = 63, - anon_sym_CARET = 64, - anon_sym_LT2 = 65, - anon_sym_true = 66, - anon_sym_false = 67, - sym_integer = 68, - sym_float = 69, - anon_sym_DQUOTE_DQUOTE_DQUOTE = 70, - anon_sym_DQUOTE_DQUOTE_DQUOTE2 = 71, - anon_sym_DQUOTE = 72, - anon_sym_DQUOTE2 = 73, - sym__string_content = 74, - sym__triple_content = 75, - sym_escape_sequence = 76, - sym_raw_string = 77, - aux_sym_fstring_token1 = 78, - anon_sym_f_DQUOTE = 79, - aux_sym_fstring_token2 = 80, - anon_sym_LBRACE2 = 81, - sym_hole = 82, - sym_constructor_identifier = 83, - sym_comment = 84, - sym__indent = 85, - sym__dedent = 86, - sym__sep = 87, - sym_source_file = 88, - sym__item = 89, - sym_let_binding = 90, - sym_parameter = 91, - sym_active_pattern_definition = 92, - sym_active_pattern_cases = 93, - sym_type_definition = 94, - sym__type_identifier = 95, - sym__type_variable = 96, - sym__module_identifier = 97, - sym_record_declaration = 98, - sym_field_declaration = 99, - sym__variant_list = 100, - sym__variant_block = 101, - sym_variant = 102, - sym_extern_type_definition = 103, - sym_opaque_type_definition = 104, - sym_measure_definition = 105, - sym_module_definition = 106, - sym_import_declaration = 107, - sym_extern_import_declaration = 108, - sym_python_path = 109, - sym__path_component = 110, - sym_extern_declaration = 111, - sym_extern_target = 112, - sym_extern_kwargs = 113, - sym_extern_kwarg = 114, - sym__extern_literal = 115, - sym__body = 116, - sym__block = 117, - sym__statement = 118, - sym__expression = 119, - sym_assignment = 120, - sym_lambda = 121, - sym_if_expression = 122, - sym_elif_clause = 123, - sym_match_expression = 124, - sym_case_clause = 125, - sym__pipe_expression = 126, - sym_pipe_expression = 127, - sym__compose_expression = 128, - sym_compose_expression = 129, - sym__or_expression = 130, - sym_or_expression = 131, - sym__and_expression = 132, - sym_and_expression = 133, - sym__not_expression = 134, - sym_not_expression = 135, - sym_try_expression = 136, - sym__comparison_expression = 137, - sym_comparison_expression = 138, - sym__additive_expression = 139, - sym_additive_expression = 140, - sym__multiplicative_expression = 141, - sym_multiplicative_expression = 142, - sym__unary_expression = 143, - sym_unary_expression = 144, - sym__power_expression = 145, - sym_power_expression = 146, - sym__application_expression = 147, - sym_application = 148, - sym__postfix_expression = 149, - sym_field_expression = 150, - sym__atom_expression = 151, - sym_unit = 152, - sym_parenthesized_expression = 153, - sym_tuple_expression = 154, - sym_list_expression = 155, - sym_record_expression = 156, - sym__constructor_path = 157, - sym_field_initializer = 158, - sym_record_update_expression = 159, - sym_field_update = 160, - sym_ce_expression = 161, - sym__ce_item = 162, - sym_ce_let = 163, - sym_ce_bind = 164, - sym_ce_do = 165, - sym_ce_return = 166, - sym_ce_yield = 167, - sym_operator_section = 168, - sym__pattern = 169, - sym_as_pattern = 170, - sym_or_pattern = 171, - sym_constructor_pattern = 172, - sym__atom_pattern = 173, - sym_negative_integer = 174, - sym_parenthesized_pattern = 175, - sym_tuple_pattern = 176, - sym_list_pattern = 177, - sym_rest_pattern = 178, - sym_record_pattern = 179, - sym_field_pattern = 180, - sym__type = 181, - sym_function_type = 182, - sym_effect_annotation = 183, - sym_effect_label = 184, - sym__type_app = 185, - sym_type_application = 186, - sym__type_atom = 187, - sym_tuple_type = 188, - sym_measure = 189, - sym_measure_factor = 190, - sym_unit_literal = 191, - sym_boolean = 192, - sym_string = 193, - sym_fstring = 194, - sym_interpolation = 195, - aux_sym_source_file_repeat1 = 196, - aux_sym_let_binding_repeat1 = 197, - aux_sym_let_binding_repeat2 = 198, - aux_sym_active_pattern_cases_repeat1 = 199, - aux_sym_type_definition_repeat1 = 200, - aux_sym_record_declaration_repeat1 = 201, - aux_sym__variant_list_repeat1 = 202, - aux_sym__variant_block_repeat1 = 203, - aux_sym_variant_repeat1 = 204, - aux_sym_python_path_repeat1 = 205, - aux_sym_extern_kwargs_repeat1 = 206, - aux_sym__block_repeat1 = 207, - aux_sym_if_expression_repeat1 = 208, - aux_sym_match_expression_repeat1 = 209, - aux_sym_match_expression_repeat2 = 210, - aux_sym_tuple_expression_repeat1 = 211, - aux_sym_record_expression_repeat1 = 212, - aux_sym_record_update_expression_repeat1 = 213, - aux_sym_field_update_repeat1 = 214, - aux_sym_ce_expression_repeat1 = 215, - aux_sym_constructor_pattern_repeat1 = 216, - aux_sym_tuple_pattern_repeat1 = 217, - aux_sym_list_pattern_repeat1 = 218, - aux_sym_record_pattern_repeat1 = 219, - aux_sym_effect_annotation_repeat1 = 220, - aux_sym_type_application_repeat1 = 221, - aux_sym_tuple_type_repeat1 = 222, - aux_sym_measure_repeat1 = 223, - aux_sym_string_repeat1 = 224, - aux_sym_string_repeat2 = 225, - aux_sym_fstring_repeat1 = 226, - alias_sym_constructor_pattern_name = 227, - alias_sym_debug_marker = 228, - alias_sym_dimensionless = 229, - alias_sym_module_identifier = 230, - alias_sym_type_identifier = 231, - alias_sym_type_variable = 232, + sym_extern_slot = 21, + anon_sym_DASH = 22, + anon_sym_LT_DASH = 23, + anon_sym_fun = 24, + anon_sym_DASH_GT = 25, + anon_sym_if = 26, + anon_sym_then = 27, + anon_sym_else = 28, + anon_sym_elif = 29, + anon_sym_match = 30, + anon_sym_case = 31, + anon_sym_PIPE_GT = 32, + anon_sym_LT_PIPE = 33, + anon_sym_GT_GT = 34, + anon_sym_LT_LT = 35, + anon_sym_or = 36, + anon_sym_and = 37, + anon_sym_not = 38, + anon_sym_try = 39, + anon_sym_EQ_EQ = 40, + anon_sym_BANG_EQ = 41, + anon_sym_LT = 42, + anon_sym_GT = 43, + anon_sym_LT_EQ = 44, + anon_sym_GT_EQ = 45, + anon_sym_PLUS = 46, + anon_sym_STAR = 47, + anon_sym_SLASH = 48, + anon_sym_SLASH_SLASH = 49, + anon_sym_PERCENT = 50, + anon_sym_STAR_STAR = 51, + anon_sym_LBRACK = 52, + anon_sym_RBRACK = 53, + anon_sym_with = 54, + anon_sym_async = 55, + anon_sym_seq = 56, + anon_sym_result = 57, + anon_sym_let_BANG = 58, + anon_sym_do_BANG = 59, + anon_sym_return = 60, + anon_sym_return_BANG = 61, + anon_sym_yield = 62, + anon_sym_yield_BANG = 63, + sym_wildcard = 64, + anon_sym_CARET = 65, + anon_sym_LT2 = 66, + anon_sym_true = 67, + anon_sym_false = 68, + sym_integer = 69, + sym_float = 70, + anon_sym_DQUOTE_DQUOTE_DQUOTE = 71, + anon_sym_DQUOTE_DQUOTE_DQUOTE2 = 72, + anon_sym_DQUOTE = 73, + anon_sym_DQUOTE2 = 74, + sym__string_content = 75, + sym__triple_content = 76, + sym_escape_sequence = 77, + sym_raw_string = 78, + aux_sym_fstring_token1 = 79, + anon_sym_f_DQUOTE = 80, + aux_sym_fstring_token2 = 81, + anon_sym_LBRACE2 = 82, + sym_hole = 83, + sym_constructor_identifier = 84, + sym_comment = 85, + sym__indent = 86, + sym__dedent = 87, + sym__sep = 88, + sym_source_file = 89, + sym__item = 90, + sym_let_binding = 91, + sym_parameter = 92, + sym_active_pattern_definition = 93, + sym_active_pattern_cases = 94, + sym_type_definition = 95, + sym__type_identifier = 96, + sym__type_variable = 97, + sym__module_identifier = 98, + sym_record_declaration = 99, + sym_field_declaration = 100, + sym__variant_list = 101, + sym__variant_block = 102, + sym_variant = 103, + sym_extern_type_definition = 104, + sym_opaque_type_definition = 105, + sym_measure_definition = 106, + sym_module_definition = 107, + sym_import_declaration = 108, + sym_extern_import_declaration = 109, + sym_python_path = 110, + sym__path_component = 111, + sym_extern_declaration = 112, + sym_extern_target = 113, + sym_extern_kwargs = 114, + sym_extern_kwarg = 115, + sym__extern_literal = 116, + sym__body = 117, + sym__block = 118, + sym__statement = 119, + sym__expression = 120, + sym_assignment = 121, + sym_lambda = 122, + sym_if_expression = 123, + sym_elif_clause = 124, + sym_match_expression = 125, + sym_case_clause = 126, + sym__pipe_expression = 127, + sym_pipe_expression = 128, + sym__compose_expression = 129, + sym_compose_expression = 130, + sym__or_expression = 131, + sym_or_expression = 132, + sym__and_expression = 133, + sym_and_expression = 134, + sym__not_expression = 135, + sym_not_expression = 136, + sym_try_expression = 137, + sym__comparison_expression = 138, + sym_comparison_expression = 139, + sym__additive_expression = 140, + sym_additive_expression = 141, + sym__multiplicative_expression = 142, + sym_multiplicative_expression = 143, + sym__unary_expression = 144, + sym_unary_expression = 145, + sym__power_expression = 146, + sym_power_expression = 147, + sym__application_expression = 148, + sym_application = 149, + sym__postfix_expression = 150, + sym_field_expression = 151, + sym__atom_expression = 152, + sym_unit = 153, + sym_parenthesized_expression = 154, + sym_tuple_expression = 155, + sym_list_expression = 156, + sym_record_expression = 157, + sym__constructor_path = 158, + sym_field_initializer = 159, + sym_record_update_expression = 160, + sym_field_update = 161, + sym_ce_expression = 162, + sym__ce_item = 163, + sym_ce_let = 164, + sym_ce_bind = 165, + sym_ce_do = 166, + sym_ce_return = 167, + sym_ce_yield = 168, + sym_operator_section = 169, + sym__pattern = 170, + sym_as_pattern = 171, + sym_or_pattern = 172, + sym_constructor_pattern = 173, + sym__atom_pattern = 174, + sym_negative_integer = 175, + sym_parenthesized_pattern = 176, + sym_tuple_pattern = 177, + sym_list_pattern = 178, + sym_rest_pattern = 179, + sym_record_pattern = 180, + sym_field_pattern = 181, + sym__type = 182, + sym_function_type = 183, + sym_effect_annotation = 184, + sym_effect_label = 185, + sym__type_app = 186, + sym_type_application = 187, + sym__type_atom = 188, + sym_tuple_type = 189, + sym_measure = 190, + sym_measure_factor = 191, + sym_unit_literal = 192, + sym_boolean = 193, + sym_string = 194, + sym_fstring = 195, + sym_interpolation = 196, + aux_sym_source_file_repeat1 = 197, + aux_sym_let_binding_repeat1 = 198, + aux_sym_let_binding_repeat2 = 199, + aux_sym_active_pattern_cases_repeat1 = 200, + aux_sym_type_definition_repeat1 = 201, + aux_sym_record_declaration_repeat1 = 202, + aux_sym__variant_list_repeat1 = 203, + aux_sym__variant_block_repeat1 = 204, + aux_sym_variant_repeat1 = 205, + aux_sym_python_path_repeat1 = 206, + aux_sym_extern_kwargs_repeat1 = 207, + aux_sym__block_repeat1 = 208, + aux_sym_if_expression_repeat1 = 209, + aux_sym_match_expression_repeat1 = 210, + aux_sym_match_expression_repeat2 = 211, + aux_sym_tuple_expression_repeat1 = 212, + aux_sym_record_expression_repeat1 = 213, + aux_sym_record_update_expression_repeat1 = 214, + aux_sym_field_update_repeat1 = 215, + aux_sym_ce_expression_repeat1 = 216, + aux_sym_constructor_pattern_repeat1 = 217, + aux_sym_tuple_pattern_repeat1 = 218, + aux_sym_list_pattern_repeat1 = 219, + aux_sym_record_pattern_repeat1 = 220, + aux_sym_effect_annotation_repeat1 = 221, + aux_sym_type_application_repeat1 = 222, + aux_sym_tuple_type_repeat1 = 223, + aux_sym_measure_repeat1 = 224, + aux_sym_string_repeat1 = 225, + aux_sym_string_repeat2 = 226, + aux_sym_fstring_repeat1 = 227, + alias_sym_constructor_pattern_name = 228, + alias_sym_debug_marker = 229, + alias_sym_dimensionless = 230, + alias_sym_module_identifier = 231, + alias_sym_type_identifier = 232, + alias_sym_type_variable = 233, }; static const char * const ts_symbol_names[] = { @@ -276,6 +277,7 @@ static const char * const ts_symbol_names[] = { [anon_sym_import] = "import", [anon_sym_as] = "as", [anon_sym_DOT] = ".", + [sym_extern_slot] = "extern_slot", [anon_sym_DASH] = "-", [anon_sym_LT_DASH] = "<-", [anon_sym_fun] = "fun", @@ -512,6 +514,7 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_import] = anon_sym_import, [anon_sym_as] = anon_sym_as, [anon_sym_DOT] = anon_sym_DOT, + [sym_extern_slot] = sym_extern_slot, [anon_sym_DASH] = anon_sym_DASH, [anon_sym_LT_DASH] = anon_sym_LT_DASH, [anon_sym_fun] = anon_sym_fun, @@ -811,6 +814,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [sym_extern_slot] = { + .visible = true, + .named = true, + }, [anon_sym_DASH] = { .visible = true, .named = false, @@ -2413,34 +2420,34 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [383] = 378, [384] = 384, [385] = 385, - [386] = 382, - [387] = 387, + [386] = 386, + [387] = 382, [388] = 388, - [389] = 388, - [390] = 390, - [391] = 379, - [392] = 385, - [393] = 388, - [394] = 379, - [395] = 368, - [396] = 366, - [397] = 397, - [398] = 390, - [399] = 399, - [400] = 370, - [401] = 401, - [402] = 369, - [403] = 403, - [404] = 339, - [405] = 340, - [406] = 295, - [407] = 340, + [389] = 389, + [390] = 389, + [391] = 391, + [392] = 379, + [393] = 385, + [394] = 389, + [395] = 379, + [396] = 368, + [397] = 366, + [398] = 398, + [399] = 391, + [400] = 400, + [401] = 369, + [402] = 402, + [403] = 370, + [404] = 340, + [405] = 295, + [406] = 340, + [407] = 294, [408] = 296, [409] = 295, - [410] = 296, - [411] = 294, + [410] = 339, + [411] = 339, [412] = 294, - [413] = 339, + [413] = 296, [414] = 414, [415] = 415, [416] = 416, @@ -2526,7 +2533,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [496] = 496, [497] = 497, [498] = 498, - [499] = 403, + [499] = 402, [500] = 488, [501] = 501, [502] = 502, @@ -2998,238 +3005,238 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (eof) ADVANCE(66); + if (eof) ADVANCE(68); ADVANCE_MAP( - '!', 23, - '"', 133, - '#', 173, - '%', 105, - '(', 72, - ')', 75, - '*', 101, - '+', 99, - ',', 77, - '-', 82, - '.', 80, - '/', 103, - '0', 120, - ':', 79, - '<', 118, - '=', 71, - '>', 96, - '?', 151, - '[', 107, - '\\', 38, - ']', 108, - '^', 117, - 'd', 165, - 'f', 154, - 'l', 158, - 'r', 155, - 'y', 162, - '{', 149, - '|', 74, - '}', 78, + '!', 25, + '"', 137, + '#', 177, + '%', 109, + '(', 74, + ')', 77, + '*', 105, + '+', 103, + ',', 79, + '-', 86, + '.', 83, + '/', 107, + '0', 124, + ':', 81, + '<', 122, + '=', 73, + '>', 100, + '?', 155, + '[', 111, + '\\', 40, + ']', 112, + '^', 121, + 'd', 169, + 'f', 158, + 'l', 162, + 'r', 159, + 'y', 166, + '{', 153, + '|', 76, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(57); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + lookahead == ' ') SKIP(59); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 1: if (lookahead == '\n') SKIP(22); - if (lookahead == '"') ADVANCE(133); - if (lookahead == '#') ADVANCE(148); - if (lookahead == '\\') ADVANCE(38); - if (lookahead == '{') ADVANCE(150); - if (lookahead == '}') ADVANCE(46); + if (lookahead == '"') ADVANCE(137); + if (lookahead == '#') ADVANCE(152); + if (lookahead == '\\') ADVANCE(40); + if (lookahead == '{') ADVANCE(154); + if (lookahead == '}') ADVANCE(48); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') ADVANCE(147); + lookahead == ' ') ADVANCE(151); if (lookahead != 0 && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(148); + lookahead != 0x212a) ADVANCE(152); END_STATE(); case 2: if (lookahead == '\n') SKIP(22); - if (lookahead == '"') ADVANCE(133); - if (lookahead == '#') ADVANCE(135); - if (lookahead == '\\') ADVANCE(38); + if (lookahead == '"') ADVANCE(137); + if (lookahead == '#') ADVANCE(139); + if (lookahead == '\\') ADVANCE(40); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') ADVANCE(134); + lookahead == ' ') ADVANCE(138); if (lookahead != 0 && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(135); + lookahead != 0x212a) ADVANCE(139); END_STATE(); case 3: ADVANCE_MAP( - '!', 23, - '"', 132, - '#', 173, - '%', 105, - '(', 72, - ')', 75, - '*', 101, - '+', 99, - '-', 81, - '/', 103, - '0', 120, - '<', 93, - '=', 24, - '>', 95, - '?', 151, - '[', 107, - ']', 108, - 'f', 154, - 'r', 156, - '{', 76, + '!', 25, + '"', 136, + '#', 177, + '%', 109, + '(', 74, + ')', 77, + '*', 105, + '+', 103, + '-', 85, + '/', 107, + '0', 124, + '<', 97, + '=', 26, + '>', 99, + '?', 155, + '[', 111, + ']', 112, + 'f', 158, + 'r', 160, + '{', 78, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(3); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 4: ADVANCE_MAP( - '!', 23, - '"', 132, - '#', 173, - '%', 105, - '(', 72, - '*', 101, - '+', 99, - '-', 81, - '.', 80, - '/', 103, - '0', 120, - '<', 91, - '=', 24, - '>', 96, - '?', 151, - '[', 107, - 'd', 165, - 'f', 154, - 'l', 158, - 'r', 155, - 'y', 162, - '{', 76, - '|', 26, - '}', 78, + '!', 25, + '"', 136, + '#', 177, + '%', 109, + '(', 74, + '*', 105, + '+', 103, + '-', 85, + '.', 82, + '/', 107, + '0', 124, + '<', 95, + '=', 26, + '>', 100, + '?', 155, + '[', 111, + 'd', 169, + 'f', 158, + 'l', 162, + 'r', 159, + 'y', 166, + '{', 78, + '|', 28, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(4); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 5: ADVANCE_MAP( - '!', 23, - '"', 132, - '#', 173, - '%', 105, - '(', 72, - '*', 101, - '+', 99, - '-', 81, - '.', 80, - '/', 103, - '0', 120, - '<', 92, - '=', 24, - '>', 96, - '?', 151, - '[', 107, - 'd', 165, - 'f', 154, - 'l', 158, - 'r', 155, - 'y', 162, - '{', 76, - '|', 26, - '}', 78, + '!', 25, + '"', 136, + '#', 177, + '%', 109, + '(', 74, + '*', 105, + '+', 103, + '-', 85, + '.', 82, + '/', 107, + '0', 124, + '<', 96, + '=', 26, + '>', 100, + '?', 155, + '[', 111, + 'd', 169, + 'f', 158, + 'l', 162, + 'r', 159, + 'y', 166, + '{', 78, + '|', 28, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(5); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 6: ADVANCE_MAP( - '!', 23, - '"', 132, - '#', 173, - '%', 105, - '(', 72, - '*', 101, - '+', 99, - '-', 81, - '.', 80, - '/', 103, - '0', 120, - '<', 119, - '=', 24, - '>', 96, - '?', 151, - '[', 107, - 'd', 165, - 'f', 154, - 'l', 158, - 'r', 155, - 'y', 162, - '{', 76, - '|', 26, - '}', 78, + '!', 25, + '"', 136, + '#', 177, + '%', 109, + '(', 74, + '*', 105, + '+', 103, + '-', 85, + '.', 82, + '/', 107, + '0', 124, + '<', 123, + '=', 26, + '>', 100, + '?', 155, + '[', 111, + 'd', 169, + 'f', 158, + 'l', 162, + 'r', 159, + 'y', 166, + '{', 78, + '|', 28, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(5); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 7: ADVANCE_MAP( - '!', 23, - '#', 173, - '%', 105, - ')', 75, - '*', 100, - '+', 99, - ',', 77, - '-', 81, - '/', 103, - '0', 122, - ':', 79, - '<', 92, - '=', 71, - '>', 96, - ']', 108, - 'd', 165, - 'l', 158, - 'r', 160, - 'y', 162, - '|', 26, - '}', 78, + '!', 25, + '#', 177, + '%', 109, + ')', 77, + '*', 104, + '+', 103, + ',', 79, + '-', 85, + '/', 107, + '0', 126, + ':', 81, + '<', 96, + '=', 73, + '>', 100, + ']', 112, + 'd', 169, + 'l', 162, + 'r', 164, + 'y', 166, + '|', 28, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(7); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(129); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); case 8: - if (lookahead == '!') ADVANCE(110); + if (lookahead == '!') ADVANCE(114); END_STATE(); case 9: - if (lookahead == '"') ADVANCE(143); - if (lookahead == '\\') ADVANCE(55); + if (lookahead == '"') ADVANCE(147); + if (lookahead == '\\') ADVANCE(57); if (lookahead != 0 && lookahead != '\n' && lookahead != 0x17f && @@ -3239,40 +3246,40 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == '"') ADVANCE(13); END_STATE(); case 11: - if (lookahead == '"') ADVANCE(142); - if (lookahead == '\\') ADVANCE(55); + if (lookahead == '"') ADVANCE(146); + if (lookahead == '\\') ADVANCE(57); if (lookahead != 0 && lookahead != '\n' && lookahead != 0x17f && lookahead != 0x212a) ADVANCE(11); END_STATE(); case 12: - if (lookahead == '"') ADVANCE(142); + if (lookahead == '"') ADVANCE(146); if (lookahead != 0 && lookahead != 0x17f && lookahead != 0x212a) ADVANCE(21); END_STATE(); case 13: if (lookahead == '"') ADVANCE(17); - if (lookahead == '\\') ADVANCE(54); + if (lookahead == '\\') ADVANCE(56); if (lookahead != 0 && lookahead != 0x17f && lookahead != 0x212a) ADVANCE(13); END_STATE(); case 14: - if (lookahead == '"') ADVANCE(144); + if (lookahead == '"') ADVANCE(148); if (lookahead != 0 && lookahead != 0x17f && lookahead != 0x212a) ADVANCE(13); END_STATE(); case 15: - if (lookahead == '"') ADVANCE(129); + if (lookahead == '"') ADVANCE(133); END_STATE(); case 16: - if (lookahead == '"') ADVANCE(130); + if (lookahead == '"') ADVANCE(134); if (lookahead != 0 && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(136); + lookahead != 0x212a) ADVANCE(140); END_STATE(); case 17: if (lookahead == '"') ADVANCE(14); @@ -3288,813 +3295,828 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 19: if (lookahead == '"') ADVANCE(20); - if (lookahead == '#') ADVANCE(137); - if (lookahead == '\\') ADVANCE(38); + if (lookahead == '#') ADVANCE(141); + if (lookahead == '\\') ADVANCE(40); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') ADVANCE(138); + lookahead == ' ') ADVANCE(142); if (lookahead != 0 && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(139); + lookahead != 0x212a) ADVANCE(143); END_STATE(); case 20: if (lookahead == '"') ADVANCE(16); if (lookahead != 0 && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(136); + lookahead != 0x212a) ADVANCE(140); END_STATE(); case 21: if (lookahead == '"') ADVANCE(18); - if (lookahead == '\\') ADVANCE(56); + if (lookahead == '\\') ADVANCE(58); if (lookahead != 0 && lookahead != 0x17f && lookahead != 0x212a) ADVANCE(21); END_STATE(); case 22: - if (lookahead == '#') ADVANCE(173); + if (lookahead == '#') ADVANCE(177); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(22); END_STATE(); case 23: - if (lookahead == '=') ADVANCE(90); + if (lookahead == '.') ADVANCE(24); END_STATE(); case 24: - if (lookahead == '=') ADVANCE(89); + if (lookahead == '.') ADVANCE(84); END_STATE(); case 25: - if (lookahead == '>') ADVANCE(84); + if (lookahead == '=') ADVANCE(94); END_STATE(); case 26: - if (lookahead == '>') ADVANCE(85); + if (lookahead == '=') ADVANCE(93); END_STATE(); case 27: - if (lookahead == 'd') ADVANCE(114); + if (lookahead == '>') ADVANCE(88); END_STATE(); case 28: - if (lookahead == 'e') ADVANCE(36); + if (lookahead == '>') ADVANCE(89); END_STATE(); case 29: - if (lookahead == 'e') ADVANCE(32); + if (lookahead == 'd') ADVANCE(118); END_STATE(); case 30: - if (lookahead == 'e') ADVANCE(37); + if (lookahead == 'e') ADVANCE(38); END_STATE(); case 31: - if (lookahead == 'i') ADVANCE(29); + if (lookahead == 'e') ADVANCE(34); END_STATE(); case 32: - if (lookahead == 'l') ADVANCE(27); + if (lookahead == 'e') ADVANCE(39); END_STATE(); case 33: - if (lookahead == 'n') ADVANCE(111); + if (lookahead == 'i') ADVANCE(31); END_STATE(); case 34: - if (lookahead == 'o') ADVANCE(8); + if (lookahead == 'l') ADVANCE(29); END_STATE(); case 35: - if (lookahead == 'r') ADVANCE(33); + if (lookahead == 'n') ADVANCE(115); END_STATE(); case 36: - if (lookahead == 't') ADVANCE(67); + if (lookahead == 'o') ADVANCE(8); END_STATE(); case 37: - if (lookahead == 't') ADVANCE(39); + if (lookahead == 'r') ADVANCE(35); END_STATE(); case 38: - if (lookahead == 'u') ADVANCE(141); - if (lookahead != 0 && - lookahead != '\n' && - lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(140); + if (lookahead == 't') ADVANCE(69); END_STATE(); case 39: - if (lookahead == 'u') ADVANCE(35); + if (lookahead == 't') ADVANCE(41); END_STATE(); case 40: - if (lookahead == '}') ADVANCE(140); + if (lookahead == 'u') ADVANCE(145); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != 0x17f && + lookahead != 0x212a) ADVANCE(144); END_STATE(); case 41: - if (lookahead == '}') ADVANCE(140); - if (('0' <= lookahead && lookahead <= '9') || - ('A' <= lookahead && lookahead <= 'F') || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(40); + if (lookahead == 'u') ADVANCE(37); END_STATE(); case 42: - if (lookahead == '}') ADVANCE(140); - if (('0' <= lookahead && lookahead <= '9') || - ('A' <= lookahead && lookahead <= 'F') || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(41); + if (lookahead == '}') ADVANCE(144); END_STATE(); case 43: - if (lookahead == '}') ADVANCE(140); + if (lookahead == '}') ADVANCE(144); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || ('a' <= lookahead && lookahead <= 'f')) ADVANCE(42); END_STATE(); case 44: - if (lookahead == '}') ADVANCE(140); + if (lookahead == '}') ADVANCE(144); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || ('a' <= lookahead && lookahead <= 'f')) ADVANCE(43); END_STATE(); case 45: - if (lookahead == '}') ADVANCE(140); + if (lookahead == '}') ADVANCE(144); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || ('a' <= lookahead && lookahead <= 'f')) ADVANCE(44); END_STATE(); case 46: - if (lookahead == '}') ADVANCE(146); + if (lookahead == '}') ADVANCE(144); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(45); END_STATE(); case 47: - if (lookahead == '+' || - lookahead == '-') ADVANCE(51); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(128); + if (lookahead == '}') ADVANCE(144); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(46); END_STATE(); case 48: - if (lookahead == '0' || - lookahead == '1') ADVANCE(123); + if (lookahead == '}') ADVANCE(150); END_STATE(); case 49: - if (('0' <= lookahead && lookahead <= '7')) ADVANCE(124); + if (lookahead == '+' || + lookahead == '-') ADVANCE(53); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(132); END_STATE(); case 50: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(127); + if (lookahead == '0' || + lookahead == '1') ADVANCE(127); END_STATE(); case 51: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(128); + if (('0' <= lookahead && lookahead <= '7')) ADVANCE(128); END_STATE(); case 52: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(131); + END_STATE(); + case 53: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(132); + END_STATE(); + case 54: if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(126); + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(130); END_STATE(); - case 53: + case 55: if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(45); + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(47); END_STATE(); - case 54: + case 56: if (lookahead != 0 && lookahead != '\n' && lookahead != 0x17f && lookahead != 0x212a) ADVANCE(13); END_STATE(); - case 55: + case 57: if (lookahead != 0 && lookahead != '\n' && lookahead != 0x17f && lookahead != 0x212a) ADVANCE(11); END_STATE(); - case 56: + case 58: if (lookahead != 0 && lookahead != '\n' && lookahead != 0x17f && lookahead != 0x212a) ADVANCE(21); END_STATE(); - case 57: - if (eof) ADVANCE(66); - ADVANCE_MAP( - '!', 23, - '"', 131, - '#', 173, - '%', 105, - '(', 72, - ')', 75, - '*', 101, - '+', 99, - ',', 77, - '-', 82, - '.', 80, - '/', 103, - '0', 120, - ':', 79, - '<', 91, - '=', 71, - '>', 96, - '?', 151, - '[', 107, - ']', 108, - '^', 117, - 'd', 165, - 'f', 154, - 'l', 158, - 'r', 155, - 'y', 162, - '{', 76, - '|', 74, - '}', 78, - ); - if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(57); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); - if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); - END_STATE(); - case 58: - if (eof) ADVANCE(66); - ADVANCE_MAP( - '!', 23, - '"', 132, - '#', 173, - '%', 105, - '(', 72, - ')', 75, - '*', 101, - '+', 99, - ',', 77, - '-', 81, - '.', 80, - '/', 103, - '0', 120, - ':', 79, - '<', 91, - '=', 71, - '>', 96, - '?', 151, - '[', 107, - ']', 108, - 'f', 154, - 'r', 156, - '{', 76, - '|', 26, - '}', 78, - ); - if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(58); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); - if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); - END_STATE(); case 59: - if (eof) ADVANCE(66); + if (eof) ADVANCE(68); ADVANCE_MAP( - '!', 23, - '"', 132, - '#', 173, - '%', 105, - '(', 72, - ')', 75, - '*', 101, - '+', 99, - ',', 77, - '-', 81, - '.', 80, - '/', 103, - '0', 120, - ':', 79, - '<', 92, - '=', 71, - '>', 96, - '?', 151, - '[', 107, - ']', 108, - 'f', 154, - 'r', 156, - '{', 76, - '|', 26, - '}', 78, + '!', 25, + '"', 135, + '#', 177, + '%', 109, + '(', 74, + ')', 77, + '*', 105, + '+', 103, + ',', 79, + '-', 86, + '.', 83, + '/', 107, + '0', 124, + ':', 81, + '<', 95, + '=', 73, + '>', 100, + '?', 155, + '[', 111, + ']', 112, + '^', 121, + 'd', 169, + 'f', 158, + 'l', 162, + 'r', 159, + 'y', 166, + '{', 78, + '|', 76, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(59); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 60: - if (eof) ADVANCE(66); + if (eof) ADVANCE(68); ADVANCE_MAP( - '!', 23, - '"', 132, - '#', 173, - '%', 105, - '(', 72, - ')', 75, - '*', 101, - '+', 99, - ',', 77, - '-', 81, - '.', 80, - '/', 103, - '0', 120, - ':', 79, - '<', 119, - '=', 71, - '>', 96, - '?', 151, - '[', 107, - ']', 108, - 'f', 154, - 'r', 156, - '{', 76, - '|', 26, - '}', 78, + '!', 25, + '"', 136, + '#', 177, + '%', 109, + '(', 74, + ')', 77, + '*', 105, + '+', 103, + ',', 79, + '-', 85, + '.', 82, + '/', 107, + '0', 124, + ':', 81, + '<', 95, + '=', 73, + '>', 100, + '?', 155, + '[', 111, + ']', 112, + 'f', 158, + 'r', 160, + '{', 78, + '|', 28, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(59); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + lookahead == ' ') SKIP(60); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 61: - if (eof) ADVANCE(66); + if (eof) ADVANCE(68); ADVANCE_MAP( - '!', 23, - '"', 132, - '#', 173, - '%', 105, - ')', 75, - '*', 100, - '+', 99, - ',', 77, - '-', 81, - '/', 103, - '0', 120, - ':', 79, - '<', 92, - '=', 71, - '>', 96, - ']', 108, - '|', 26, - '}', 78, + '!', 25, + '"', 136, + '#', 177, + '%', 109, + '(', 74, + ')', 77, + '*', 105, + '+', 103, + ',', 79, + '-', 85, + '.', 82, + '/', 107, + '0', 124, + ':', 81, + '<', 96, + '=', 73, + '>', 100, + '?', 155, + '[', 111, + ']', 112, + 'f', 158, + 'r', 160, + '{', 78, + '|', 28, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(61); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 62: - if (eof) ADVANCE(66); + if (eof) ADVANCE(68); ADVANCE_MAP( - '"', 132, - '#', 173, - '(', 72, - ')', 75, - '*', 100, - ',', 77, - '-', 81, - '.', 80, - '/', 102, - '0', 122, - ':', 79, - '=', 70, - '>', 94, - '[', 107, - ']', 108, - '^', 117, - '{', 76, - '|', 73, - '}', 78, + '!', 25, + '"', 136, + '#', 177, + '%', 109, + '(', 74, + ')', 77, + '*', 105, + '+', 103, + ',', 79, + '-', 85, + '.', 82, + '/', 107, + '0', 124, + ':', 81, + '<', 123, + '=', 73, + '>', 100, + '?', 155, + '[', 111, + ']', 112, + 'f', 158, + 'r', 160, + '{', 78, + '|', 28, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') SKIP(62); + lookahead == ' ') SKIP(61); if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 63: - if (eof) ADVANCE(66); + if (eof) ADVANCE(68); ADVANCE_MAP( - '"', 132, - '#', 173, - '(', 72, - '-', 81, - '.', 80, - '/', 102, - '0', 120, - '>', 94, - '?', 151, - '[', 107, - 'f', 154, - 'l', 161, - 'r', 156, - '{', 76, - '|', 73, + '!', 25, + '"', 136, + '#', 177, + '%', 109, + ')', 77, + '*', 104, + '+', 103, + ',', 79, + '-', 85, + '.', 23, + '/', 107, + '0', 124, + ':', 81, + '<', 96, + '=', 73, + '>', 100, + ']', 112, + '|', 28, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(63); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); case 64: - if (eof) ADVANCE(66); + if (eof) ADVANCE(68); ADVANCE_MAP( - '#', 173, - '(', 72, - ')', 75, - ',', 77, - '-', 25, - '=', 70, - '|', 73, - '}', 78, + '"', 136, + '#', 177, + '(', 74, + ')', 77, + '*', 104, + ',', 79, + '-', 85, + '.', 82, + '/', 106, + '0', 126, + ':', 81, + '=', 72, + '>', 98, + '[', 111, + ']', 112, + '^', 121, + '{', 78, + '|', 75, + '}', 80, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(64); - if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(172); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(129); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); if (lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); case 65: - if (eof) ADVANCE(66); + if (eof) ADVANCE(68); ADVANCE_MAP( - '#', 173, - ')', 75, - ',', 77, - '-', 25, - '=', 70, - 'd', 34, - 'l', 28, - 'r', 30, - 'y', 31, - '}', 78, + '"', 136, + '#', 177, + '(', 74, + '-', 85, + '.', 82, + '/', 106, + '0', 124, + '=', 72, + '>', 98, + '?', 155, + '[', 111, + 'f', 158, + 'l', 165, + 'r', 160, + '{', 78, + '|', 75, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(65); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); + if (lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); END_STATE(); case 66: - ACCEPT_TOKEN(ts_builtin_sym_end); + if (eof) ADVANCE(68); + ADVANCE_MAP( + '#', 177, + '(', 74, + ')', 77, + ',', 79, + '-', 27, + '=', 72, + '|', 75, + '}', 80, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(66); + if (('A' <= lookahead && lookahead <= 'Z')) ADVANCE(176); + if (lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); case 67: - ACCEPT_TOKEN(anon_sym_let); - if (lookahead == '!') ADVANCE(109); + if (eof) ADVANCE(68); + ADVANCE_MAP( + '#', 177, + ')', 77, + ',', 79, + '-', 27, + '=', 72, + 'd', 36, + 'l', 30, + 'r', 32, + 'y', 33, + '}', 80, + ); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ') SKIP(67); END_STATE(); case 68: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 69: ACCEPT_TOKEN(anon_sym_let); - if (lookahead == '!') ADVANCE(109); + if (lookahead == '!') ADVANCE(113); + END_STATE(); + case 70: + ACCEPT_TOKEN(anon_sym_let); + if (lookahead == '!') ADVANCE(113); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 69: + case 71: ACCEPT_TOKEN(anon_sym_let); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 70: + case 72: ACCEPT_TOKEN(anon_sym_EQ); END_STATE(); - case 71: + case 73: ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '=') ADVANCE(89); + if (lookahead == '=') ADVANCE(93); END_STATE(); - case 72: + case 74: ACCEPT_TOKEN(anon_sym_LPAREN); END_STATE(); - case 73: + case 75: ACCEPT_TOKEN(anon_sym_PIPE); END_STATE(); - case 74: + case 76: ACCEPT_TOKEN(anon_sym_PIPE); - if (lookahead == '>') ADVANCE(85); + if (lookahead == '>') ADVANCE(89); END_STATE(); - case 75: + case 77: ACCEPT_TOKEN(anon_sym_RPAREN); END_STATE(); - case 76: + case 78: ACCEPT_TOKEN(anon_sym_LBRACE); END_STATE(); - case 77: + case 79: ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); - case 78: + case 80: ACCEPT_TOKEN(anon_sym_RBRACE); END_STATE(); - case 79: + case 81: ACCEPT_TOKEN(anon_sym_COLON); END_STATE(); - case 80: + case 82: ACCEPT_TOKEN(anon_sym_DOT); END_STATE(); - case 81: + case 83: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(24); + END_STATE(); + case 84: + ACCEPT_TOKEN(sym_extern_slot); + END_STATE(); + case 85: ACCEPT_TOKEN(anon_sym_DASH); END_STATE(); - case 82: + case 86: ACCEPT_TOKEN(anon_sym_DASH); - if (lookahead == '>') ADVANCE(84); + if (lookahead == '>') ADVANCE(88); END_STATE(); - case 83: + case 87: ACCEPT_TOKEN(anon_sym_LT_DASH); END_STATE(); - case 84: + case 88: ACCEPT_TOKEN(anon_sym_DASH_GT); END_STATE(); - case 85: + case 89: ACCEPT_TOKEN(anon_sym_PIPE_GT); END_STATE(); - case 86: + case 90: ACCEPT_TOKEN(anon_sym_LT_PIPE); END_STATE(); - case 87: + case 91: ACCEPT_TOKEN(anon_sym_GT_GT); END_STATE(); - case 88: + case 92: ACCEPT_TOKEN(anon_sym_LT_LT); END_STATE(); - case 89: + case 93: ACCEPT_TOKEN(anon_sym_EQ_EQ); END_STATE(); - case 90: + case 94: ACCEPT_TOKEN(anon_sym_BANG_EQ); END_STATE(); - case 91: + case 95: ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '-') ADVANCE(83); - if (lookahead == '<') ADVANCE(88); - if (lookahead == '=') ADVANCE(97); - if (lookahead == '|') ADVANCE(86); + if (lookahead == '-') ADVANCE(87); + if (lookahead == '<') ADVANCE(92); + if (lookahead == '=') ADVANCE(101); + if (lookahead == '|') ADVANCE(90); END_STATE(); - case 92: + case 96: ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '<') ADVANCE(88); - if (lookahead == '=') ADVANCE(97); - if (lookahead == '|') ADVANCE(86); + if (lookahead == '<') ADVANCE(92); + if (lookahead == '=') ADVANCE(101); + if (lookahead == '|') ADVANCE(90); END_STATE(); - case 93: + case 97: ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '=') ADVANCE(97); + if (lookahead == '=') ADVANCE(101); END_STATE(); - case 94: + case 98: ACCEPT_TOKEN(anon_sym_GT); END_STATE(); - case 95: + case 99: ACCEPT_TOKEN(anon_sym_GT); - if (lookahead == '=') ADVANCE(98); + if (lookahead == '=') ADVANCE(102); END_STATE(); - case 96: + case 100: ACCEPT_TOKEN(anon_sym_GT); - if (lookahead == '=') ADVANCE(98); - if (lookahead == '>') ADVANCE(87); + if (lookahead == '=') ADVANCE(102); + if (lookahead == '>') ADVANCE(91); END_STATE(); - case 97: + case 101: ACCEPT_TOKEN(anon_sym_LT_EQ); END_STATE(); - case 98: + case 102: ACCEPT_TOKEN(anon_sym_GT_EQ); END_STATE(); - case 99: + case 103: ACCEPT_TOKEN(anon_sym_PLUS); END_STATE(); - case 100: + case 104: ACCEPT_TOKEN(anon_sym_STAR); END_STATE(); - case 101: + case 105: ACCEPT_TOKEN(anon_sym_STAR); - if (lookahead == '*') ADVANCE(106); + if (lookahead == '*') ADVANCE(110); END_STATE(); - case 102: + case 106: ACCEPT_TOKEN(anon_sym_SLASH); END_STATE(); - case 103: + case 107: ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(104); + if (lookahead == '/') ADVANCE(108); END_STATE(); - case 104: + case 108: ACCEPT_TOKEN(anon_sym_SLASH_SLASH); END_STATE(); - case 105: + case 109: ACCEPT_TOKEN(anon_sym_PERCENT); END_STATE(); - case 106: + case 110: ACCEPT_TOKEN(anon_sym_STAR_STAR); END_STATE(); - case 107: + case 111: ACCEPT_TOKEN(anon_sym_LBRACK); END_STATE(); - case 108: + case 112: ACCEPT_TOKEN(anon_sym_RBRACK); END_STATE(); - case 109: + case 113: ACCEPT_TOKEN(anon_sym_let_BANG); END_STATE(); - case 110: + case 114: ACCEPT_TOKEN(anon_sym_do_BANG); END_STATE(); - case 111: + case 115: ACCEPT_TOKEN(anon_sym_return); - if (lookahead == '!') ADVANCE(113); + if (lookahead == '!') ADVANCE(117); END_STATE(); - case 112: + case 116: ACCEPT_TOKEN(anon_sym_return); - if (lookahead == '!') ADVANCE(113); + if (lookahead == '!') ADVANCE(117); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 113: + case 117: ACCEPT_TOKEN(anon_sym_return_BANG); END_STATE(); - case 114: + case 118: ACCEPT_TOKEN(anon_sym_yield); - if (lookahead == '!') ADVANCE(116); + if (lookahead == '!') ADVANCE(120); END_STATE(); - case 115: + case 119: ACCEPT_TOKEN(anon_sym_yield); - if (lookahead == '!') ADVANCE(116); + if (lookahead == '!') ADVANCE(120); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 116: + case 120: ACCEPT_TOKEN(anon_sym_yield_BANG); END_STATE(); - case 117: + case 121: ACCEPT_TOKEN(anon_sym_CARET); END_STATE(); - case 118: + case 122: ACCEPT_TOKEN(anon_sym_LT2); - if (lookahead == '-') ADVANCE(83); - if (lookahead == '<') ADVANCE(88); - if (lookahead == '=') ADVANCE(97); - if (lookahead == '|') ADVANCE(86); + if (lookahead == '-') ADVANCE(87); + if (lookahead == '<') ADVANCE(92); + if (lookahead == '=') ADVANCE(101); + if (lookahead == '|') ADVANCE(90); END_STATE(); - case 119: + case 123: ACCEPT_TOKEN(anon_sym_LT2); - if (lookahead == '<') ADVANCE(88); - if (lookahead == '=') ADVANCE(97); - if (lookahead == '|') ADVANCE(86); + if (lookahead == '<') ADVANCE(92); + if (lookahead == '=') ADVANCE(101); + if (lookahead == '|') ADVANCE(90); END_STATE(); - case 120: + case 124: ACCEPT_TOKEN(sym_integer); ADVANCE_MAP( - '.', 50, - 'B', 48, - 'b', 48, - 'E', 47, - 'e', 47, - 'O', 49, - 'o', 49, - 'X', 52, - 'x', 52, + '.', 52, + 'B', 50, + 'b', 50, + 'E', 49, + 'e', 49, + 'O', 51, + 'o', 51, + 'X', 54, + 'x', 54, ); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(121); + lookahead == '_') ADVANCE(125); END_STATE(); - case 121: + case 125: ACCEPT_TOKEN(sym_integer); - if (lookahead == '.') ADVANCE(50); + if (lookahead == '.') ADVANCE(52); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(47); + lookahead == 'e') ADVANCE(49); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(121); + lookahead == '_') ADVANCE(125); END_STATE(); - case 122: + case 126: ACCEPT_TOKEN(sym_integer); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(48); + lookahead == 'b') ADVANCE(50); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(49); + lookahead == 'o') ADVANCE(51); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(52); + lookahead == 'x') ADVANCE(54); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(125); + lookahead == '_') ADVANCE(129); END_STATE(); - case 123: + case 127: ACCEPT_TOKEN(sym_integer); if (lookahead == '0' || lookahead == '1' || - lookahead == '_') ADVANCE(123); + lookahead == '_') ADVANCE(127); END_STATE(); - case 124: + case 128: ACCEPT_TOKEN(sym_integer); if (('0' <= lookahead && lookahead <= '7') || - lookahead == '_') ADVANCE(124); + lookahead == '_') ADVANCE(128); END_STATE(); - case 125: + case 129: ACCEPT_TOKEN(sym_integer); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(125); + lookahead == '_') ADVANCE(129); END_STATE(); - case 126: + case 130: ACCEPT_TOKEN(sym_integer); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(126); + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(130); END_STATE(); - case 127: + case 131: ACCEPT_TOKEN(sym_float); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(47); + lookahead == 'e') ADVANCE(49); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(127); + lookahead == '_') ADVANCE(131); END_STATE(); - case 128: + case 132: ACCEPT_TOKEN(sym_float); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(128); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(132); END_STATE(); - case 129: + case 133: ACCEPT_TOKEN(anon_sym_DQUOTE_DQUOTE_DQUOTE); END_STATE(); - case 130: + case 134: ACCEPT_TOKEN(anon_sym_DQUOTE_DQUOTE_DQUOTE2); END_STATE(); - case 131: + case 135: ACCEPT_TOKEN(anon_sym_DQUOTE); END_STATE(); - case 132: + case 136: ACCEPT_TOKEN(anon_sym_DQUOTE); if (lookahead == '"') ADVANCE(15); END_STATE(); - case 133: + case 137: ACCEPT_TOKEN(anon_sym_DQUOTE2); END_STATE(); - case 134: + case 138: ACCEPT_TOKEN(sym__string_content); - if (lookahead == '#') ADVANCE(135); + if (lookahead == '#') ADVANCE(139); if (lookahead == '\t' || (0x0b <= lookahead && lookahead <= '\r') || - lookahead == ' ') ADVANCE(134); + lookahead == ' ') ADVANCE(138); if (lookahead != 0 && (lookahead < '\t' || '\r' < lookahead) && lookahead != '"' && lookahead != '#' && lookahead != '\\' && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(135); + lookahead != 0x212a) ADVANCE(139); END_STATE(); - case 135: + case 139: ACCEPT_TOKEN(sym__string_content); if (lookahead != 0 && lookahead != '\n' && lookahead != '"' && lookahead != '\\' && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(135); + lookahead != 0x212a) ADVANCE(139); END_STATE(); - case 136: + case 140: ACCEPT_TOKEN(sym__triple_content); END_STATE(); - case 137: + case 141: ACCEPT_TOKEN(sym__triple_content); - if (lookahead == '\n') ADVANCE(139); + if (lookahead == '\n') ADVANCE(143); if (lookahead != 0 && lookahead != '"' && lookahead != '\\' && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(137); + lookahead != 0x212a) ADVANCE(141); END_STATE(); - case 138: + case 142: ACCEPT_TOKEN(sym__triple_content); - if (lookahead == '#') ADVANCE(137); + if (lookahead == '#') ADVANCE(141); if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ') ADVANCE(138); + lookahead == ' ') ADVANCE(142); if (lookahead != 0 && lookahead != '"' && lookahead != '#' && lookahead != '\\' && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(139); + lookahead != 0x212a) ADVANCE(143); END_STATE(); - case 139: + case 143: ACCEPT_TOKEN(sym__triple_content); if (lookahead != 0 && lookahead != '"' && lookahead != '\\' && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(139); + lookahead != 0x212a) ADVANCE(143); END_STATE(); - case 140: + case 144: ACCEPT_TOKEN(sym_escape_sequence); END_STATE(); - case 141: + case 145: ACCEPT_TOKEN(sym_escape_sequence); - if (lookahead == '{') ADVANCE(53); + if (lookahead == '{') ADVANCE(55); END_STATE(); - case 142: + case 146: ACCEPT_TOKEN(sym_raw_string); END_STATE(); - case 143: + case 147: ACCEPT_TOKEN(sym_raw_string); if (lookahead == '"') ADVANCE(21); END_STATE(); - case 144: + case 148: ACCEPT_TOKEN(aux_sym_fstring_token1); END_STATE(); - case 145: + case 149: ACCEPT_TOKEN(anon_sym_f_DQUOTE); if (lookahead == '"') ADVANCE(10); END_STATE(); - case 146: + case 150: ACCEPT_TOKEN(aux_sym_fstring_token2); END_STATE(); - case 147: + case 151: ACCEPT_TOKEN(aux_sym_fstring_token2); - if (lookahead == '#') ADVANCE(148); + if (lookahead == '#') ADVANCE(152); if (lookahead == '\t' || (0x0b <= lookahead && lookahead <= '\r') || - lookahead == ' ') ADVANCE(147); + lookahead == ' ') ADVANCE(151); if (lookahead != 0 && (lookahead < '\t' || '\r' < lookahead) && lookahead != '"' && @@ -4103,9 +4125,9 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead != '{' && lookahead != '}' && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(148); + lookahead != 0x212a) ADVANCE(152); END_STATE(); - case 148: + case 152: ACCEPT_TOKEN(aux_sym_fstring_token2); if (lookahead != 0 && lookahead != '\n' && @@ -4114,193 +4136,193 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead != '{' && lookahead != '}' && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(148); + lookahead != 0x212a) ADVANCE(152); END_STATE(); - case 149: + case 153: ACCEPT_TOKEN(anon_sym_LBRACE2); END_STATE(); - case 150: + case 154: ACCEPT_TOKEN(anon_sym_LBRACE2); - if (lookahead == '{') ADVANCE(146); + if (lookahead == '{') ADVANCE(150); END_STATE(); - case 151: + case 155: ACCEPT_TOKEN(sym_hole); if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(152); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(156); END_STATE(); - case 152: + case 156: ACCEPT_TOKEN(sym_hole); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(152); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(156); END_STATE(); - case 153: + case 157: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '!') ADVANCE(110); + if (lookahead == '!') ADVANCE(114); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 154: + case 158: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '"') ADVANCE(145); + if (lookahead == '"') ADVANCE(149); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 155: + case 159: ACCEPT_TOKEN(sym_identifier); if (lookahead == '"') ADVANCE(9); - if (lookahead == 'e') ADVANCE(168); + if (lookahead == 'e') ADVANCE(172); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 156: + case 160: ACCEPT_TOKEN(sym_identifier); if (lookahead == '"') ADVANCE(9); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 157: + case 161: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'd') ADVANCE(115); + if (lookahead == 'd') ADVANCE(119); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 158: + case 162: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'e') ADVANCE(167); + if (lookahead == 'e') ADVANCE(171); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 159: + case 163: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'e') ADVANCE(163); + if (lookahead == 'e') ADVANCE(167); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 160: + case 164: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'e') ADVANCE(168); + if (lookahead == 'e') ADVANCE(172); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 161: + case 165: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'e') ADVANCE(169); + if (lookahead == 'e') ADVANCE(173); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 162: + case 166: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'i') ADVANCE(159); + if (lookahead == 'i') ADVANCE(163); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 163: + case 167: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'l') ADVANCE(157); + if (lookahead == 'l') ADVANCE(161); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 164: + case 168: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'n') ADVANCE(112); + if (lookahead == 'n') ADVANCE(116); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 165: + case 169: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'o') ADVANCE(153); + if (lookahead == 'o') ADVANCE(157); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 166: + case 170: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'r') ADVANCE(164); + if (lookahead == 'r') ADVANCE(168); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 167: + case 171: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 't') ADVANCE(68); + if (lookahead == 't') ADVANCE(70); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 168: + case 172: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 't') ADVANCE(170); + if (lookahead == 't') ADVANCE(174); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 169: + case 173: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 't') ADVANCE(69); + if (lookahead == 't') ADVANCE(71); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 170: + case 174: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'u') ADVANCE(166); + if (lookahead == 'u') ADVANCE(170); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 171: + case 175: ACCEPT_TOKEN(sym_identifier); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(171); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(175); END_STATE(); - case 172: + case 176: ACCEPT_TOKEN(sym_constructor_identifier); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(172); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(176); END_STATE(); - case 173: + case 177: ACCEPT_TOKEN(sym_comment); if (lookahead != 0 && lookahead != '\n' && lookahead != 0x17f && - lookahead != 0x212a) ADVANCE(173); + lookahead != 0x212a) ADVANCE(177); END_STATE(); default: return false; @@ -4630,10 +4652,10 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [0] = {.lex_state = 0, .external_lex_state = 1}, - [1] = {.lex_state = 63}, - [2] = {.lex_state = 63}, - [3] = {.lex_state = 63}, - [4] = {.lex_state = 63}, + [1] = {.lex_state = 65}, + [2] = {.lex_state = 65}, + [3] = {.lex_state = 65}, + [4] = {.lex_state = 65}, [5] = {.lex_state = 3}, [6] = {.lex_state = 3}, [7] = {.lex_state = 3}, @@ -4644,7 +4666,7 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [12] = {.lex_state = 3, .external_lex_state = 2}, [13] = {.lex_state = 3, .external_lex_state = 2}, [14] = {.lex_state = 3, .external_lex_state = 2}, - [15] = {.lex_state = 63}, + [15] = {.lex_state = 65}, [16] = {.lex_state = 3, .external_lex_state = 2}, [17] = {.lex_state = 3, .external_lex_state = 2}, [18] = {.lex_state = 3, .external_lex_state = 2}, @@ -4671,11 +4693,11 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [39] = {.lex_state = 3, .external_lex_state = 2}, [40] = {.lex_state = 3, .external_lex_state = 2}, [41] = {.lex_state = 3, .external_lex_state = 2}, - [42] = {.lex_state = 63}, + [42] = {.lex_state = 65}, [43] = {.lex_state = 3, .external_lex_state = 2}, - [44] = {.lex_state = 63}, + [44] = {.lex_state = 65}, [45] = {.lex_state = 3, .external_lex_state = 2}, - [46] = {.lex_state = 63}, + [46] = {.lex_state = 65}, [47] = {.lex_state = 3, .external_lex_state = 2}, [48] = {.lex_state = 3}, [49] = {.lex_state = 3}, @@ -4732,7 +4754,7 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [100] = {.lex_state = 3}, [101] = {.lex_state = 3}, [102] = {.lex_state = 3}, - [103] = {.lex_state = 59}, + [103] = {.lex_state = 61}, [104] = {.lex_state = 5}, [105] = {.lex_state = 3}, [106] = {.lex_state = 3}, @@ -4742,8 +4764,8 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [110] = {.lex_state = 3}, [111] = {.lex_state = 3}, [112] = {.lex_state = 3}, - [113] = {.lex_state = 59, .external_lex_state = 3}, - [114] = {.lex_state = 59, .external_lex_state = 4}, + [113] = {.lex_state = 61, .external_lex_state = 3}, + [114] = {.lex_state = 61, .external_lex_state = 4}, [115] = {.lex_state = 3}, [116] = {.lex_state = 3}, [117] = {.lex_state = 3}, @@ -4764,34 +4786,34 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [132] = {.lex_state = 3}, [133] = {.lex_state = 3}, [134] = {.lex_state = 3}, - [135] = {.lex_state = 60}, - [136] = {.lex_state = 58}, - [137] = {.lex_state = 59}, - [138] = {.lex_state = 59}, - [139] = {.lex_state = 59}, - [140] = {.lex_state = 59}, - [141] = {.lex_state = 59}, - [142] = {.lex_state = 59}, - [143] = {.lex_state = 59}, - [144] = {.lex_state = 59}, - [145] = {.lex_state = 59}, - [146] = {.lex_state = 59}, - [147] = {.lex_state = 59}, - [148] = {.lex_state = 59}, - [149] = {.lex_state = 59}, - [150] = {.lex_state = 59}, - [151] = {.lex_state = 59}, - [152] = {.lex_state = 59}, - [153] = {.lex_state = 59}, - [154] = {.lex_state = 59}, - [155] = {.lex_state = 59}, - [156] = {.lex_state = 59}, - [157] = {.lex_state = 59}, - [158] = {.lex_state = 59}, - [159] = {.lex_state = 59}, - [160] = {.lex_state = 59}, - [161] = {.lex_state = 59}, - [162] = {.lex_state = 59}, + [135] = {.lex_state = 62}, + [136] = {.lex_state = 60}, + [137] = {.lex_state = 61}, + [138] = {.lex_state = 61}, + [139] = {.lex_state = 61}, + [140] = {.lex_state = 61}, + [141] = {.lex_state = 61}, + [142] = {.lex_state = 61}, + [143] = {.lex_state = 61}, + [144] = {.lex_state = 61}, + [145] = {.lex_state = 61}, + [146] = {.lex_state = 61}, + [147] = {.lex_state = 61}, + [148] = {.lex_state = 61}, + [149] = {.lex_state = 61}, + [150] = {.lex_state = 61}, + [151] = {.lex_state = 61}, + [152] = {.lex_state = 61}, + [153] = {.lex_state = 61}, + [154] = {.lex_state = 61}, + [155] = {.lex_state = 61}, + [156] = {.lex_state = 61}, + [157] = {.lex_state = 61}, + [158] = {.lex_state = 61}, + [159] = {.lex_state = 61}, + [160] = {.lex_state = 61}, + [161] = {.lex_state = 61}, + [162] = {.lex_state = 61}, [163] = {.lex_state = 6}, [164] = {.lex_state = 4}, [165] = {.lex_state = 5}, @@ -4832,130 +4854,130 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [200] = {.lex_state = 3}, [201] = {.lex_state = 3}, [202] = {.lex_state = 3}, - [203] = {.lex_state = 60, .external_lex_state = 4}, + [203] = {.lex_state = 62, .external_lex_state = 4}, [204] = {.lex_state = 3}, [205] = {.lex_state = 3}, [206] = {.lex_state = 3}, [207] = {.lex_state = 3}, [208] = {.lex_state = 3}, [209] = {.lex_state = 3}, - [210] = {.lex_state = 58, .external_lex_state = 4}, + [210] = {.lex_state = 60, .external_lex_state = 4}, [211] = {.lex_state = 3}, [212] = {.lex_state = 3}, [213] = {.lex_state = 3}, - [214] = {.lex_state = 60, .external_lex_state = 3}, + [214] = {.lex_state = 62, .external_lex_state = 3}, [215] = {.lex_state = 3}, [216] = {.lex_state = 3}, - [217] = {.lex_state = 58, .external_lex_state = 3}, + [217] = {.lex_state = 60, .external_lex_state = 3}, [218] = {.lex_state = 3}, - [219] = {.lex_state = 59, .external_lex_state = 3}, - [220] = {.lex_state = 59, .external_lex_state = 3}, - [221] = {.lex_state = 59, .external_lex_state = 3}, - [222] = {.lex_state = 59, .external_lex_state = 4}, - [223] = {.lex_state = 59, .external_lex_state = 4}, - [224] = {.lex_state = 59, .external_lex_state = 3}, - [225] = {.lex_state = 59, .external_lex_state = 4}, - [226] = {.lex_state = 59, .external_lex_state = 3}, - [227] = {.lex_state = 59, .external_lex_state = 4}, - [228] = {.lex_state = 59, .external_lex_state = 4}, - [229] = {.lex_state = 59, .external_lex_state = 4}, - [230] = {.lex_state = 59, .external_lex_state = 4}, - [231] = {.lex_state = 59, .external_lex_state = 4}, - [232] = {.lex_state = 59, .external_lex_state = 3}, - [233] = {.lex_state = 59, .external_lex_state = 3}, - [234] = {.lex_state = 59, .external_lex_state = 3}, - [235] = {.lex_state = 59, .external_lex_state = 3}, - [236] = {.lex_state = 59, .external_lex_state = 3}, - [237] = {.lex_state = 59, .external_lex_state = 3}, - [238] = {.lex_state = 59, .external_lex_state = 4}, - [239] = {.lex_state = 59, .external_lex_state = 4}, - [240] = {.lex_state = 59, .external_lex_state = 4}, - [241] = {.lex_state = 59, .external_lex_state = 3}, - [242] = {.lex_state = 59, .external_lex_state = 4}, - [243] = {.lex_state = 59, .external_lex_state = 4}, - [244] = {.lex_state = 59, .external_lex_state = 4}, - [245] = {.lex_state = 59, .external_lex_state = 4}, - [246] = {.lex_state = 59, .external_lex_state = 4}, - [247] = {.lex_state = 59, .external_lex_state = 4}, - [248] = {.lex_state = 59, .external_lex_state = 4}, - [249] = {.lex_state = 59, .external_lex_state = 4}, - [250] = {.lex_state = 59, .external_lex_state = 4}, - [251] = {.lex_state = 59, .external_lex_state = 4}, - [252] = {.lex_state = 59, .external_lex_state = 3}, - [253] = {.lex_state = 59, .external_lex_state = 4}, - [254] = {.lex_state = 59, .external_lex_state = 4}, - [255] = {.lex_state = 59, .external_lex_state = 4}, - [256] = {.lex_state = 59, .external_lex_state = 4}, - [257] = {.lex_state = 59, .external_lex_state = 3}, - [258] = {.lex_state = 59, .external_lex_state = 3}, - [259] = {.lex_state = 59, .external_lex_state = 4}, - [260] = {.lex_state = 59, .external_lex_state = 3}, - [261] = {.lex_state = 59, .external_lex_state = 3}, - [262] = {.lex_state = 59, .external_lex_state = 3}, - [263] = {.lex_state = 59, .external_lex_state = 3}, - [264] = {.lex_state = 59, .external_lex_state = 3}, - [265] = {.lex_state = 59, .external_lex_state = 3}, - [266] = {.lex_state = 59, .external_lex_state = 3}, - [267] = {.lex_state = 59, .external_lex_state = 3}, - [268] = {.lex_state = 59, .external_lex_state = 3}, - [269] = {.lex_state = 59, .external_lex_state = 3}, - [270] = {.lex_state = 59, .external_lex_state = 3}, + [219] = {.lex_state = 61, .external_lex_state = 3}, + [220] = {.lex_state = 61, .external_lex_state = 3}, + [221] = {.lex_state = 61, .external_lex_state = 3}, + [222] = {.lex_state = 61, .external_lex_state = 4}, + [223] = {.lex_state = 61, .external_lex_state = 4}, + [224] = {.lex_state = 61, .external_lex_state = 3}, + [225] = {.lex_state = 61, .external_lex_state = 4}, + [226] = {.lex_state = 61, .external_lex_state = 3}, + [227] = {.lex_state = 61, .external_lex_state = 4}, + [228] = {.lex_state = 61, .external_lex_state = 4}, + [229] = {.lex_state = 61, .external_lex_state = 4}, + [230] = {.lex_state = 61, .external_lex_state = 4}, + [231] = {.lex_state = 61, .external_lex_state = 4}, + [232] = {.lex_state = 61, .external_lex_state = 3}, + [233] = {.lex_state = 61, .external_lex_state = 3}, + [234] = {.lex_state = 61, .external_lex_state = 3}, + [235] = {.lex_state = 61, .external_lex_state = 3}, + [236] = {.lex_state = 61, .external_lex_state = 3}, + [237] = {.lex_state = 61, .external_lex_state = 3}, + [238] = {.lex_state = 61, .external_lex_state = 4}, + [239] = {.lex_state = 61, .external_lex_state = 4}, + [240] = {.lex_state = 61, .external_lex_state = 4}, + [241] = {.lex_state = 61, .external_lex_state = 3}, + [242] = {.lex_state = 61, .external_lex_state = 4}, + [243] = {.lex_state = 61, .external_lex_state = 4}, + [244] = {.lex_state = 61, .external_lex_state = 4}, + [245] = {.lex_state = 61, .external_lex_state = 4}, + [246] = {.lex_state = 61, .external_lex_state = 4}, + [247] = {.lex_state = 61, .external_lex_state = 4}, + [248] = {.lex_state = 61, .external_lex_state = 4}, + [249] = {.lex_state = 61, .external_lex_state = 4}, + [250] = {.lex_state = 61, .external_lex_state = 4}, + [251] = {.lex_state = 61, .external_lex_state = 4}, + [252] = {.lex_state = 61, .external_lex_state = 3}, + [253] = {.lex_state = 61, .external_lex_state = 4}, + [254] = {.lex_state = 61, .external_lex_state = 4}, + [255] = {.lex_state = 61, .external_lex_state = 4}, + [256] = {.lex_state = 61, .external_lex_state = 4}, + [257] = {.lex_state = 61, .external_lex_state = 3}, + [258] = {.lex_state = 61, .external_lex_state = 3}, + [259] = {.lex_state = 61, .external_lex_state = 4}, + [260] = {.lex_state = 61, .external_lex_state = 3}, + [261] = {.lex_state = 61, .external_lex_state = 3}, + [262] = {.lex_state = 61, .external_lex_state = 3}, + [263] = {.lex_state = 61, .external_lex_state = 3}, + [264] = {.lex_state = 61, .external_lex_state = 3}, + [265] = {.lex_state = 61, .external_lex_state = 3}, + [266] = {.lex_state = 61, .external_lex_state = 3}, + [267] = {.lex_state = 61, .external_lex_state = 3}, + [268] = {.lex_state = 61, .external_lex_state = 3}, + [269] = {.lex_state = 61, .external_lex_state = 3}, + [270] = {.lex_state = 61, .external_lex_state = 3}, [271] = {.lex_state = 7}, [272] = {.lex_state = 7}, [273] = {.lex_state = 7}, - [274] = {.lex_state = 62}, - [275] = {.lex_state = 62}, - [276] = {.lex_state = 62}, - [277] = {.lex_state = 61}, - [278] = {.lex_state = 61}, - [279] = {.lex_state = 62}, + [274] = {.lex_state = 64}, + [275] = {.lex_state = 64}, + [276] = {.lex_state = 64}, + [277] = {.lex_state = 63}, + [278] = {.lex_state = 63}, + [279] = {.lex_state = 64}, [280] = {.lex_state = 7}, [281] = {.lex_state = 7}, - [282] = {.lex_state = 62}, - [283] = {.lex_state = 62}, - [284] = {.lex_state = 62}, - [285] = {.lex_state = 62}, - [286] = {.lex_state = 62}, - [287] = {.lex_state = 62}, - [288] = {.lex_state = 62}, - [289] = {.lex_state = 61}, - [290] = {.lex_state = 62}, - [291] = {.lex_state = 62}, - [292] = {.lex_state = 62}, - [293] = {.lex_state = 61}, + [282] = {.lex_state = 64}, + [283] = {.lex_state = 64}, + [284] = {.lex_state = 64}, + [285] = {.lex_state = 64}, + [286] = {.lex_state = 64}, + [287] = {.lex_state = 64}, + [288] = {.lex_state = 64}, + [289] = {.lex_state = 63}, + [290] = {.lex_state = 64}, + [291] = {.lex_state = 64}, + [292] = {.lex_state = 64}, + [293] = {.lex_state = 63}, [294] = {.lex_state = 7}, [295] = {.lex_state = 7}, [296] = {.lex_state = 7}, [297] = {.lex_state = 7}, - [298] = {.lex_state = 61}, + [298] = {.lex_state = 63}, [299] = {.lex_state = 7}, - [300] = {.lex_state = 61, .external_lex_state = 4}, - [301] = {.lex_state = 61, .external_lex_state = 3}, - [302] = {.lex_state = 61, .external_lex_state = 3}, - [303] = {.lex_state = 62}, - [304] = {.lex_state = 61, .external_lex_state = 4}, - [305] = {.lex_state = 61, .external_lex_state = 3}, - [306] = {.lex_state = 61, .external_lex_state = 4}, - [307] = {.lex_state = 61, .external_lex_state = 3}, - [308] = {.lex_state = 61, .external_lex_state = 3}, - [309] = {.lex_state = 61, .external_lex_state = 4}, - [310] = {.lex_state = 61, .external_lex_state = 4}, + [300] = {.lex_state = 63, .external_lex_state = 4}, + [301] = {.lex_state = 63, .external_lex_state = 3}, + [302] = {.lex_state = 63, .external_lex_state = 3}, + [303] = {.lex_state = 64}, + [304] = {.lex_state = 63, .external_lex_state = 4}, + [305] = {.lex_state = 63, .external_lex_state = 3}, + [306] = {.lex_state = 63, .external_lex_state = 4}, + [307] = {.lex_state = 63, .external_lex_state = 3}, + [308] = {.lex_state = 63, .external_lex_state = 3}, + [309] = {.lex_state = 63, .external_lex_state = 4}, + [310] = {.lex_state = 63, .external_lex_state = 4}, [311] = {.lex_state = 7}, - [312] = {.lex_state = 62}, - [313] = {.lex_state = 62}, - [314] = {.lex_state = 62}, - [315] = {.lex_state = 62}, - [316] = {.lex_state = 62}, - [317] = {.lex_state = 62}, - [318] = {.lex_state = 62}, - [319] = {.lex_state = 62}, - [320] = {.lex_state = 62}, - [321] = {.lex_state = 62}, - [322] = {.lex_state = 62}, - [323] = {.lex_state = 62}, - [324] = {.lex_state = 62}, - [325] = {.lex_state = 62}, - [326] = {.lex_state = 62}, + [312] = {.lex_state = 64}, + [313] = {.lex_state = 64}, + [314] = {.lex_state = 64}, + [315] = {.lex_state = 64}, + [316] = {.lex_state = 64}, + [317] = {.lex_state = 64}, + [318] = {.lex_state = 64}, + [319] = {.lex_state = 64}, + [320] = {.lex_state = 64}, + [321] = {.lex_state = 64}, + [322] = {.lex_state = 64}, + [323] = {.lex_state = 64}, + [324] = {.lex_state = 64}, + [325] = {.lex_state = 64}, + [326] = {.lex_state = 64}, [327] = {.lex_state = 7}, [328] = {.lex_state = 7}, [329] = {.lex_state = 7}, @@ -4968,318 +4990,318 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [336] = {.lex_state = 7}, [337] = {.lex_state = 7}, [338] = {.lex_state = 7}, - [339] = {.lex_state = 61}, - [340] = {.lex_state = 61}, - [341] = {.lex_state = 61, .external_lex_state = 4}, - [342] = {.lex_state = 61, .external_lex_state = 4}, - [343] = {.lex_state = 61, .external_lex_state = 3}, - [344] = {.lex_state = 61, .external_lex_state = 3}, - [345] = {.lex_state = 61}, - [346] = {.lex_state = 61}, - [347] = {.lex_state = 65}, - [348] = {.lex_state = 65}, - [349] = {.lex_state = 61, .external_lex_state = 4}, - [350] = {.lex_state = 65}, + [339] = {.lex_state = 63}, + [340] = {.lex_state = 63}, + [341] = {.lex_state = 63, .external_lex_state = 4}, + [342] = {.lex_state = 63, .external_lex_state = 4}, + [343] = {.lex_state = 63, .external_lex_state = 3}, + [344] = {.lex_state = 63, .external_lex_state = 3}, + [345] = {.lex_state = 63}, + [346] = {.lex_state = 63}, + [347] = {.lex_state = 67}, + [348] = {.lex_state = 67}, + [349] = {.lex_state = 63, .external_lex_state = 4}, + [350] = {.lex_state = 67}, [351] = {.lex_state = 7}, - [352] = {.lex_state = 61}, - [353] = {.lex_state = 65}, + [352] = {.lex_state = 63}, + [353] = {.lex_state = 67}, [354] = {.lex_state = 7}, - [355] = {.lex_state = 65}, - [356] = {.lex_state = 61, .external_lex_state = 3}, + [355] = {.lex_state = 67}, + [356] = {.lex_state = 63, .external_lex_state = 3}, [357] = {.lex_state = 7}, - [358] = {.lex_state = 65}, - [359] = {.lex_state = 61}, - [360] = {.lex_state = 65}, + [358] = {.lex_state = 67}, + [359] = {.lex_state = 63}, + [360] = {.lex_state = 67}, [361] = {.lex_state = 7}, - [362] = {.lex_state = 65}, - [363] = {.lex_state = 65}, - [364] = {.lex_state = 62}, - [365] = {.lex_state = 62}, - [366] = {.lex_state = 62}, + [362] = {.lex_state = 67}, + [363] = {.lex_state = 67}, + [364] = {.lex_state = 64}, + [365] = {.lex_state = 64}, + [366] = {.lex_state = 64}, [367] = {.lex_state = 7}, - [368] = {.lex_state = 62}, - [369] = {.lex_state = 61}, - [370] = {.lex_state = 61}, - [371] = {.lex_state = 64, .external_lex_state = 3}, + [368] = {.lex_state = 64}, + [369] = {.lex_state = 63}, + [370] = {.lex_state = 63}, + [371] = {.lex_state = 66, .external_lex_state = 3}, [372] = {.lex_state = 7}, - [373] = {.lex_state = 64}, - [374] = {.lex_state = 64}, - [375] = {.lex_state = 64, .external_lex_state = 3}, - [376] = {.lex_state = 64}, - [377] = {.lex_state = 64, .external_lex_state = 3}, - [378] = {.lex_state = 62}, - [379] = {.lex_state = 62}, - [380] = {.lex_state = 62}, - [381] = {.lex_state = 62}, - [382] = {.lex_state = 62, .external_lex_state = 4}, - [383] = {.lex_state = 62}, - [384] = {.lex_state = 62}, - [385] = {.lex_state = 62, .external_lex_state = 4}, - [386] = {.lex_state = 62, .external_lex_state = 3}, - [387] = {.lex_state = 62}, - [388] = {.lex_state = 62}, - [389] = {.lex_state = 62}, - [390] = {.lex_state = 62, .external_lex_state = 4}, - [391] = {.lex_state = 62}, - [392] = {.lex_state = 62, .external_lex_state = 3}, - [393] = {.lex_state = 62}, - [394] = {.lex_state = 62}, - [395] = {.lex_state = 7}, + [373] = {.lex_state = 66}, + [374] = {.lex_state = 66}, + [375] = {.lex_state = 66, .external_lex_state = 3}, + [376] = {.lex_state = 66}, + [377] = {.lex_state = 66, .external_lex_state = 3}, + [378] = {.lex_state = 64}, + [379] = {.lex_state = 64}, + [380] = {.lex_state = 64}, + [381] = {.lex_state = 64}, + [382] = {.lex_state = 64, .external_lex_state = 4}, + [383] = {.lex_state = 64}, + [384] = {.lex_state = 64}, + [385] = {.lex_state = 64, .external_lex_state = 4}, + [386] = {.lex_state = 63}, + [387] = {.lex_state = 64, .external_lex_state = 3}, + [388] = {.lex_state = 64}, + [389] = {.lex_state = 64}, + [390] = {.lex_state = 64}, + [391] = {.lex_state = 64, .external_lex_state = 4}, + [392] = {.lex_state = 64}, + [393] = {.lex_state = 64, .external_lex_state = 3}, + [394] = {.lex_state = 64}, + [395] = {.lex_state = 64}, [396] = {.lex_state = 7}, - [397] = {.lex_state = 62}, - [398] = {.lex_state = 62, .external_lex_state = 3}, - [399] = {.lex_state = 62}, - [400] = {.lex_state = 7}, - [401] = {.lex_state = 61}, - [402] = {.lex_state = 7}, - [403] = {.lex_state = 62, .external_lex_state = 3}, - [404] = {.lex_state = 61, .external_lex_state = 3}, - [405] = {.lex_state = 61, .external_lex_state = 3}, - [406] = {.lex_state = 61, .external_lex_state = 3}, - [407] = {.lex_state = 61, .external_lex_state = 4}, - [408] = {.lex_state = 61, .external_lex_state = 3}, - [409] = {.lex_state = 61, .external_lex_state = 4}, - [410] = {.lex_state = 61, .external_lex_state = 4}, - [411] = {.lex_state = 61, .external_lex_state = 3}, - [412] = {.lex_state = 61, .external_lex_state = 4}, - [413] = {.lex_state = 61, .external_lex_state = 4}, - [414] = {.lex_state = 64, .external_lex_state = 3}, - [415] = {.lex_state = 64, .external_lex_state = 3}, - [416] = {.lex_state = 63, .external_lex_state = 2}, - [417] = {.lex_state = 64}, - [418] = {.lex_state = 64, .external_lex_state = 3}, - [419] = {.lex_state = 65}, - [420] = {.lex_state = 62, .external_lex_state = 3}, - [421] = {.lex_state = 65}, - [422] = {.lex_state = 61, .external_lex_state = 3}, - [423] = {.lex_state = 64, .external_lex_state = 3}, - [424] = {.lex_state = 61, .external_lex_state = 4}, - [425] = {.lex_state = 63, .external_lex_state = 2}, - [426] = {.lex_state = 62, .external_lex_state = 3}, - [427] = {.lex_state = 62}, - [428] = {.lex_state = 64}, - [429] = {.lex_state = 64, .external_lex_state = 3}, - [430] = {.lex_state = 65}, - [431] = {.lex_state = 65}, - [432] = {.lex_state = 65}, - [433] = {.lex_state = 62}, - [434] = {.lex_state = 61, .external_lex_state = 3}, - [435] = {.lex_state = 61, .external_lex_state = 4}, - [436] = {.lex_state = 62}, - [437] = {.lex_state = 62, .external_lex_state = 3}, - [438] = {.lex_state = 62, .external_lex_state = 3}, - [439] = {.lex_state = 62}, - [440] = {.lex_state = 62}, - [441] = {.lex_state = 64, .external_lex_state = 3}, - [442] = {.lex_state = 62}, - [443] = {.lex_state = 64}, - [444] = {.lex_state = 62}, - [445] = {.lex_state = 64}, - [446] = {.lex_state = 61, .external_lex_state = 3}, - [447] = {.lex_state = 62}, - [448] = {.lex_state = 62}, - [449] = {.lex_state = 62}, - [450] = {.lex_state = 61, .external_lex_state = 4}, - [451] = {.lex_state = 64}, - [452] = {.lex_state = 64}, - [453] = {.lex_state = 62}, + [397] = {.lex_state = 7}, + [398] = {.lex_state = 64}, + [399] = {.lex_state = 64, .external_lex_state = 3}, + [400] = {.lex_state = 64}, + [401] = {.lex_state = 7}, + [402] = {.lex_state = 64, .external_lex_state = 3}, + [403] = {.lex_state = 7}, + [404] = {.lex_state = 63, .external_lex_state = 3}, + [405] = {.lex_state = 63, .external_lex_state = 3}, + [406] = {.lex_state = 63, .external_lex_state = 4}, + [407] = {.lex_state = 63, .external_lex_state = 3}, + [408] = {.lex_state = 63, .external_lex_state = 3}, + [409] = {.lex_state = 63, .external_lex_state = 4}, + [410] = {.lex_state = 63, .external_lex_state = 3}, + [411] = {.lex_state = 63, .external_lex_state = 4}, + [412] = {.lex_state = 63, .external_lex_state = 4}, + [413] = {.lex_state = 63, .external_lex_state = 4}, + [414] = {.lex_state = 66, .external_lex_state = 3}, + [415] = {.lex_state = 66, .external_lex_state = 3}, + [416] = {.lex_state = 65, .external_lex_state = 2}, + [417] = {.lex_state = 66}, + [418] = {.lex_state = 66, .external_lex_state = 3}, + [419] = {.lex_state = 67}, + [420] = {.lex_state = 64, .external_lex_state = 3}, + [421] = {.lex_state = 67}, + [422] = {.lex_state = 63, .external_lex_state = 3}, + [423] = {.lex_state = 66, .external_lex_state = 3}, + [424] = {.lex_state = 63, .external_lex_state = 4}, + [425] = {.lex_state = 65, .external_lex_state = 2}, + [426] = {.lex_state = 64, .external_lex_state = 3}, + [427] = {.lex_state = 64}, + [428] = {.lex_state = 66}, + [429] = {.lex_state = 66, .external_lex_state = 3}, + [430] = {.lex_state = 67}, + [431] = {.lex_state = 67}, + [432] = {.lex_state = 67}, + [433] = {.lex_state = 64}, + [434] = {.lex_state = 63, .external_lex_state = 3}, + [435] = {.lex_state = 63, .external_lex_state = 4}, + [436] = {.lex_state = 64}, + [437] = {.lex_state = 64, .external_lex_state = 3}, + [438] = {.lex_state = 64, .external_lex_state = 3}, + [439] = {.lex_state = 64}, + [440] = {.lex_state = 64}, + [441] = {.lex_state = 66, .external_lex_state = 3}, + [442] = {.lex_state = 64}, + [443] = {.lex_state = 66}, + [444] = {.lex_state = 64}, + [445] = {.lex_state = 66}, + [446] = {.lex_state = 63, .external_lex_state = 3}, + [447] = {.lex_state = 64}, + [448] = {.lex_state = 64}, + [449] = {.lex_state = 64}, + [450] = {.lex_state = 63, .external_lex_state = 4}, + [451] = {.lex_state = 66}, + [452] = {.lex_state = 66}, + [453] = {.lex_state = 64}, [454] = {.lex_state = 1}, - [455] = {.lex_state = 62}, + [455] = {.lex_state = 64}, [456] = {.lex_state = 1}, - [457] = {.lex_state = 62, .external_lex_state = 3}, - [458] = {.lex_state = 62, .external_lex_state = 4}, - [459] = {.lex_state = 62, .external_lex_state = 4}, - [460] = {.lex_state = 62}, - [461] = {.lex_state = 62, .external_lex_state = 3}, + [457] = {.lex_state = 64, .external_lex_state = 3}, + [458] = {.lex_state = 64, .external_lex_state = 4}, + [459] = {.lex_state = 64, .external_lex_state = 4}, + [460] = {.lex_state = 64}, + [461] = {.lex_state = 64, .external_lex_state = 3}, [462] = {.lex_state = 1}, - [463] = {.lex_state = 62, .external_lex_state = 4}, + [463] = {.lex_state = 64, .external_lex_state = 4}, [464] = {.lex_state = 1}, [465] = {.lex_state = 1}, [466] = {.lex_state = 1}, - [467] = {.lex_state = 62}, - [468] = {.lex_state = 62}, + [467] = {.lex_state = 64}, + [468] = {.lex_state = 64}, [469] = {.lex_state = 1}, - [470] = {.lex_state = 62, .external_lex_state = 3}, - [471] = {.lex_state = 62, .external_lex_state = 4}, - [472] = {.lex_state = 62, .external_lex_state = 4}, - [473] = {.lex_state = 61, .external_lex_state = 3}, + [470] = {.lex_state = 64, .external_lex_state = 3}, + [471] = {.lex_state = 64, .external_lex_state = 4}, + [472] = {.lex_state = 64, .external_lex_state = 4}, + [473] = {.lex_state = 63, .external_lex_state = 3}, [474] = {.lex_state = 1}, [475] = {.lex_state = 1}, - [476] = {.lex_state = 62, .external_lex_state = 4}, - [477] = {.lex_state = 62, .external_lex_state = 3}, - [478] = {.lex_state = 61, .external_lex_state = 4}, - [479] = {.lex_state = 62, .external_lex_state = 3}, - [480] = {.lex_state = 62}, - [481] = {.lex_state = 62}, - [482] = {.lex_state = 62, .external_lex_state = 3}, - [483] = {.lex_state = 62, .external_lex_state = 3}, - [484] = {.lex_state = 62, .external_lex_state = 4}, - [485] = {.lex_state = 62}, - [486] = {.lex_state = 62, .external_lex_state = 3}, - [487] = {.lex_state = 62, .external_lex_state = 4}, - [488] = {.lex_state = 62}, - [489] = {.lex_state = 62}, - [490] = {.lex_state = 62, .external_lex_state = 3}, - [491] = {.lex_state = 62}, - [492] = {.lex_state = 62}, - [493] = {.lex_state = 62}, - [494] = {.lex_state = 62, .external_lex_state = 3}, - [495] = {.lex_state = 62}, - [496] = {.lex_state = 62, .external_lex_state = 3}, - [497] = {.lex_state = 62, .external_lex_state = 3}, - [498] = {.lex_state = 64}, - [499] = {.lex_state = 62}, - [500] = {.lex_state = 62}, - [501] = {.lex_state = 62}, - [502] = {.lex_state = 62}, - [503] = {.lex_state = 62}, - [504] = {.lex_state = 62}, - [505] = {.lex_state = 63, .external_lex_state = 4}, - [506] = {.lex_state = 62}, + [476] = {.lex_state = 64, .external_lex_state = 4}, + [477] = {.lex_state = 64, .external_lex_state = 3}, + [478] = {.lex_state = 63, .external_lex_state = 4}, + [479] = {.lex_state = 64, .external_lex_state = 3}, + [480] = {.lex_state = 64}, + [481] = {.lex_state = 64}, + [482] = {.lex_state = 64, .external_lex_state = 3}, + [483] = {.lex_state = 64, .external_lex_state = 3}, + [484] = {.lex_state = 64, .external_lex_state = 4}, + [485] = {.lex_state = 64}, + [486] = {.lex_state = 64, .external_lex_state = 3}, + [487] = {.lex_state = 64, .external_lex_state = 4}, + [488] = {.lex_state = 64}, + [489] = {.lex_state = 64}, + [490] = {.lex_state = 64, .external_lex_state = 3}, + [491] = {.lex_state = 64}, + [492] = {.lex_state = 64}, + [493] = {.lex_state = 64}, + [494] = {.lex_state = 64, .external_lex_state = 3}, + [495] = {.lex_state = 64}, + [496] = {.lex_state = 64, .external_lex_state = 3}, + [497] = {.lex_state = 64, .external_lex_state = 3}, + [498] = {.lex_state = 66}, + [499] = {.lex_state = 64}, + [500] = {.lex_state = 64}, + [501] = {.lex_state = 64}, + [502] = {.lex_state = 64}, + [503] = {.lex_state = 64}, + [504] = {.lex_state = 64}, + [505] = {.lex_state = 65, .external_lex_state = 4}, + [506] = {.lex_state = 64}, [507] = {.lex_state = 19}, [508] = {.lex_state = 2}, - [509] = {.lex_state = 63, .external_lex_state = 3}, - [510] = {.lex_state = 62}, - [511] = {.lex_state = 64}, + [509] = {.lex_state = 65, .external_lex_state = 3}, + [510] = {.lex_state = 64}, + [511] = {.lex_state = 66}, [512] = {.lex_state = 19}, [513] = {.lex_state = 2}, - [514] = {.lex_state = 65, .external_lex_state = 3}, - [515] = {.lex_state = 62, .external_lex_state = 2}, - [516] = {.lex_state = 61, .external_lex_state = 3}, - [517] = {.lex_state = 62}, - [518] = {.lex_state = 62}, - [519] = {.lex_state = 62}, - [520] = {.lex_state = 62, .external_lex_state = 2}, - [521] = {.lex_state = 62}, - [522] = {.lex_state = 63, .external_lex_state = 3}, - [523] = {.lex_state = 62}, - [524] = {.lex_state = 62}, + [514] = {.lex_state = 67, .external_lex_state = 3}, + [515] = {.lex_state = 64, .external_lex_state = 2}, + [516] = {.lex_state = 63, .external_lex_state = 3}, + [517] = {.lex_state = 64}, + [518] = {.lex_state = 64}, + [519] = {.lex_state = 64}, + [520] = {.lex_state = 64, .external_lex_state = 2}, + [521] = {.lex_state = 64}, + [522] = {.lex_state = 65, .external_lex_state = 3}, + [523] = {.lex_state = 64}, + [524] = {.lex_state = 64}, [525] = {.lex_state = 19}, - [526] = {.lex_state = 62}, - [527] = {.lex_state = 64}, - [528] = {.lex_state = 62}, + [526] = {.lex_state = 64}, + [527] = {.lex_state = 66}, + [528] = {.lex_state = 64}, [529] = {.lex_state = 2}, [530] = {.lex_state = 19}, [531] = {.lex_state = 2}, [532] = {.lex_state = 0, .external_lex_state = 3}, - [533] = {.lex_state = 62}, - [534] = {.lex_state = 64}, + [533] = {.lex_state = 64}, + [534] = {.lex_state = 66}, [535] = {.lex_state = 19}, [536] = {.lex_state = 2}, [537] = {.lex_state = 0}, - [538] = {.lex_state = 62}, - [539] = {.lex_state = 61, .external_lex_state = 3}, - [540] = {.lex_state = 62}, - [541] = {.lex_state = 62}, + [538] = {.lex_state = 64}, + [539] = {.lex_state = 63, .external_lex_state = 3}, + [540] = {.lex_state = 64}, + [541] = {.lex_state = 64}, [542] = {.lex_state = 2}, - [543] = {.lex_state = 62}, - [544] = {.lex_state = 62}, - [545] = {.lex_state = 62}, - [546] = {.lex_state = 62}, + [543] = {.lex_state = 64}, + [544] = {.lex_state = 64}, + [545] = {.lex_state = 64}, + [546] = {.lex_state = 64}, [547] = {.lex_state = 2}, [548] = {.lex_state = 19}, [549] = {.lex_state = 2}, - [550] = {.lex_state = 62}, + [550] = {.lex_state = 64}, [551] = {.lex_state = 19}, [552] = {.lex_state = 2}, - [553] = {.lex_state = 63, .external_lex_state = 3}, - [554] = {.lex_state = 62}, - [555] = {.lex_state = 62}, - [556] = {.lex_state = 62}, - [557] = {.lex_state = 64}, + [553] = {.lex_state = 65, .external_lex_state = 3}, + [554] = {.lex_state = 64}, + [555] = {.lex_state = 64}, + [556] = {.lex_state = 64}, + [557] = {.lex_state = 66}, [558] = {.lex_state = 19}, [559] = {.lex_state = 1}, [560] = {.lex_state = 2}, - [561] = {.lex_state = 61, .external_lex_state = 4}, - [562] = {.lex_state = 62}, - [563] = {.lex_state = 62}, - [564] = {.lex_state = 62, .external_lex_state = 2}, - [565] = {.lex_state = 62}, - [566] = {.lex_state = 62}, + [561] = {.lex_state = 63, .external_lex_state = 4}, + [562] = {.lex_state = 64}, + [563] = {.lex_state = 64}, + [564] = {.lex_state = 64, .external_lex_state = 2}, + [565] = {.lex_state = 64}, + [566] = {.lex_state = 64}, [567] = {.lex_state = 19}, - [568] = {.lex_state = 62}, + [568] = {.lex_state = 64}, [569] = {.lex_state = 1}, - [570] = {.lex_state = 62}, - [571] = {.lex_state = 62}, - [572] = {.lex_state = 62}, - [573] = {.lex_state = 63, .external_lex_state = 4}, - [574] = {.lex_state = 63, .external_lex_state = 4}, - [575] = {.lex_state = 63, .external_lex_state = 3}, + [570] = {.lex_state = 64}, + [571] = {.lex_state = 64}, + [572] = {.lex_state = 64}, + [573] = {.lex_state = 65, .external_lex_state = 4}, + [574] = {.lex_state = 65, .external_lex_state = 4}, + [575] = {.lex_state = 65, .external_lex_state = 3}, [576] = {.lex_state = 2}, - [577] = {.lex_state = 61, .external_lex_state = 4}, - [578] = {.lex_state = 62, .external_lex_state = 2}, - [579] = {.lex_state = 63, .external_lex_state = 4}, - [580] = {.lex_state = 63, .external_lex_state = 4}, + [577] = {.lex_state = 63, .external_lex_state = 4}, + [578] = {.lex_state = 64, .external_lex_state = 2}, + [579] = {.lex_state = 65, .external_lex_state = 4}, + [580] = {.lex_state = 65, .external_lex_state = 4}, [581] = {.lex_state = 0, .external_lex_state = 3}, - [582] = {.lex_state = 63, .external_lex_state = 3}, - [583] = {.lex_state = 65}, - [584] = {.lex_state = 62}, + [582] = {.lex_state = 65, .external_lex_state = 3}, + [583] = {.lex_state = 67}, + [584] = {.lex_state = 64}, [585] = {.lex_state = 19}, - [586] = {.lex_state = 62}, + [586] = {.lex_state = 64}, [587] = {.lex_state = 19}, [588] = {.lex_state = 0, .external_lex_state = 4}, [589] = {.lex_state = 0}, [590] = {.lex_state = 0, .external_lex_state = 3}, - [591] = {.lex_state = 62, .external_lex_state = 3}, - [592] = {.lex_state = 62, .external_lex_state = 3}, + [591] = {.lex_state = 64, .external_lex_state = 3}, + [592] = {.lex_state = 64, .external_lex_state = 3}, [593] = {.lex_state = 0, .external_lex_state = 4}, - [594] = {.lex_state = 64}, + [594] = {.lex_state = 66}, [595] = {.lex_state = 0}, - [596] = {.lex_state = 62}, - [597] = {.lex_state = 62, .external_lex_state = 4}, + [596] = {.lex_state = 64}, + [597] = {.lex_state = 64, .external_lex_state = 4}, [598] = {.lex_state = 0}, [599] = {.lex_state = 0}, [600] = {.lex_state = 0}, [601] = {.lex_state = 0, .external_lex_state = 3}, [602] = {.lex_state = 0, .external_lex_state = 4}, - [603] = {.lex_state = 62, .external_lex_state = 3}, - [604] = {.lex_state = 62, .external_lex_state = 4}, - [605] = {.lex_state = 62, .external_lex_state = 4}, - [606] = {.lex_state = 63, .external_lex_state = 4}, + [603] = {.lex_state = 64, .external_lex_state = 3}, + [604] = {.lex_state = 64, .external_lex_state = 4}, + [605] = {.lex_state = 64, .external_lex_state = 4}, + [606] = {.lex_state = 65, .external_lex_state = 4}, [607] = {.lex_state = 0}, [608] = {.lex_state = 0}, - [609] = {.lex_state = 62}, - [610] = {.lex_state = 62}, - [611] = {.lex_state = 62, .external_lex_state = 4}, + [609] = {.lex_state = 64}, + [610] = {.lex_state = 64}, + [611] = {.lex_state = 64, .external_lex_state = 4}, [612] = {.lex_state = 0}, - [613] = {.lex_state = 64}, - [614] = {.lex_state = 62, .external_lex_state = 4}, + [613] = {.lex_state = 66}, + [614] = {.lex_state = 64, .external_lex_state = 4}, [615] = {.lex_state = 0, .external_lex_state = 3}, - [616] = {.lex_state = 62, .external_lex_state = 4}, - [617] = {.lex_state = 62, .external_lex_state = 4}, - [618] = {.lex_state = 62, .external_lex_state = 4}, - [619] = {.lex_state = 62, .external_lex_state = 4}, - [620] = {.lex_state = 62, .external_lex_state = 4}, + [616] = {.lex_state = 64, .external_lex_state = 4}, + [617] = {.lex_state = 64, .external_lex_state = 4}, + [618] = {.lex_state = 64, .external_lex_state = 4}, + [619] = {.lex_state = 64, .external_lex_state = 4}, + [620] = {.lex_state = 64, .external_lex_state = 4}, [621] = {.lex_state = 0}, [622] = {.lex_state = 0}, - [623] = {.lex_state = 62, .external_lex_state = 4}, + [623] = {.lex_state = 64, .external_lex_state = 4}, [624] = {.lex_state = 0}, [625] = {.lex_state = 0}, [626] = {.lex_state = 0}, - [627] = {.lex_state = 62}, + [627] = {.lex_state = 64}, [628] = {.lex_state = 0}, [629] = {.lex_state = 0}, [630] = {.lex_state = 0}, [631] = {.lex_state = 0}, - [632] = {.lex_state = 62, .external_lex_state = 3}, + [632] = {.lex_state = 64, .external_lex_state = 3}, [633] = {.lex_state = 0}, [634] = {.lex_state = 0}, [635] = {.lex_state = 0}, - [636] = {.lex_state = 62, .external_lex_state = 3}, - [637] = {.lex_state = 0}, + [636] = {.lex_state = 64, .external_lex_state = 3}, + [637] = {.lex_state = 65}, [638] = {.lex_state = 0}, [639] = {.lex_state = 0, .external_lex_state = 3}, [640] = {.lex_state = 0}, - [641] = {.lex_state = 62}, + [641] = {.lex_state = 64}, [642] = {.lex_state = 0, .external_lex_state = 4}, - [643] = {.lex_state = 62, .external_lex_state = 3}, + [643] = {.lex_state = 64, .external_lex_state = 3}, [644] = {.lex_state = 0}, - [645] = {.lex_state = 63}, + [645] = {.lex_state = 65}, [646] = {.lex_state = 0}, - [647] = {.lex_state = 0}, + [647] = {.lex_state = 65}, [648] = {.lex_state = 0}, [649] = {.lex_state = 0}, - [650] = {.lex_state = 62, .external_lex_state = 3}, + [650] = {.lex_state = 64, .external_lex_state = 3}, [651] = {.lex_state = 0}, [652] = {.lex_state = 0}, [653] = {.lex_state = 0}, @@ -5289,18 +5311,18 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [657] = {.lex_state = 0}, [658] = {.lex_state = 0}, [659] = {.lex_state = 0, .external_lex_state = 4}, - [660] = {.lex_state = 62}, + [660] = {.lex_state = 64}, [661] = {.lex_state = 0, .external_lex_state = 4}, [662] = {.lex_state = 0}, [663] = {.lex_state = 0, .external_lex_state = 4}, [664] = {.lex_state = 0}, [665] = {.lex_state = 0}, - [666] = {.lex_state = 62}, - [667] = {.lex_state = 62, .external_lex_state = 3}, + [666] = {.lex_state = 64}, + [667] = {.lex_state = 64, .external_lex_state = 3}, [668] = {.lex_state = 0, .external_lex_state = 4}, [669] = {.lex_state = 0, .external_lex_state = 3}, [670] = {.lex_state = 0, .external_lex_state = 3}, - [671] = {.lex_state = 63}, + [671] = {.lex_state = 65}, [672] = {.lex_state = 0}, [673] = {.lex_state = 0}, [674] = {.lex_state = 0}, @@ -5308,67 +5330,67 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [676] = {.lex_state = 0}, [677] = {.lex_state = 0}, [678] = {.lex_state = 0}, - [679] = {.lex_state = 63, .external_lex_state = 3}, + [679] = {.lex_state = 65, .external_lex_state = 3}, [680] = {.lex_state = 0}, [681] = {.lex_state = 0, .external_lex_state = 4}, [682] = {.lex_state = 0}, [683] = {.lex_state = 0}, - [684] = {.lex_state = 62, .external_lex_state = 3}, + [684] = {.lex_state = 64, .external_lex_state = 3}, [685] = {.lex_state = 0, .external_lex_state = 4}, [686] = {.lex_state = 0, .external_lex_state = 4}, [687] = {.lex_state = 0}, [688] = {.lex_state = 0}, - [689] = {.lex_state = 0}, + [689] = {.lex_state = 65}, [690] = {.lex_state = 0}, - [691] = {.lex_state = 62, .external_lex_state = 3}, - [692] = {.lex_state = 62}, + [691] = {.lex_state = 64, .external_lex_state = 3}, + [692] = {.lex_state = 64}, [693] = {.lex_state = 0}, - [694] = {.lex_state = 62}, + [694] = {.lex_state = 64}, [695] = {.lex_state = 0, .external_lex_state = 3}, [696] = {.lex_state = 0}, [697] = {.lex_state = 0}, [698] = {.lex_state = 0}, [699] = {.lex_state = 0}, [700] = {.lex_state = 0}, - [701] = {.lex_state = 62, .external_lex_state = 3}, + [701] = {.lex_state = 64, .external_lex_state = 3}, [702] = {.lex_state = 0}, [703] = {.lex_state = 0}, [704] = {.lex_state = 0}, - [705] = {.lex_state = 62}, + [705] = {.lex_state = 64}, [706] = {.lex_state = 0, .external_lex_state = 3}, - [707] = {.lex_state = 62, .external_lex_state = 3}, + [707] = {.lex_state = 64, .external_lex_state = 3}, [708] = {.lex_state = 0}, [709] = {.lex_state = 0, .external_lex_state = 4}, - [710] = {.lex_state = 62}, + [710] = {.lex_state = 64}, [711] = {.lex_state = 0}, [712] = {.lex_state = 0}, - [713] = {.lex_state = 62}, - [714] = {.lex_state = 62, .external_lex_state = 4}, - [715] = {.lex_state = 62}, - [716] = {.lex_state = 62, .external_lex_state = 3}, + [713] = {.lex_state = 64}, + [714] = {.lex_state = 64, .external_lex_state = 4}, + [715] = {.lex_state = 64}, + [716] = {.lex_state = 64, .external_lex_state = 3}, [717] = {.lex_state = 0, .external_lex_state = 4}, - [718] = {.lex_state = 63, .external_lex_state = 4}, - [719] = {.lex_state = 62, .external_lex_state = 3}, + [718] = {.lex_state = 65, .external_lex_state = 4}, + [719] = {.lex_state = 64, .external_lex_state = 3}, [720] = {.lex_state = 0}, [721] = {.lex_state = 0}, - [722] = {.lex_state = 62}, - [723] = {.lex_state = 63}, + [722] = {.lex_state = 64}, + [723] = {.lex_state = 65}, [724] = {.lex_state = 0}, [725] = {.lex_state = 0, .external_lex_state = 3}, - [726] = {.lex_state = 62}, + [726] = {.lex_state = 64}, [727] = {.lex_state = 0}, [728] = {.lex_state = 0}, [729] = {.lex_state = 0, .external_lex_state = 3}, [730] = {.lex_state = 0, .external_lex_state = 3}, [731] = {.lex_state = 0}, [732] = {.lex_state = 0}, - [733] = {.lex_state = 62}, - [734] = {.lex_state = 63}, + [733] = {.lex_state = 64}, + [734] = {.lex_state = 65}, [735] = {.lex_state = 0}, [736] = {.lex_state = 0}, - [737] = {.lex_state = 62}, - [738] = {.lex_state = 62}, - [739] = {.lex_state = 63}, + [737] = {.lex_state = 64}, + [738] = {.lex_state = 64}, + [739] = {.lex_state = 65}, [740] = {.lex_state = 0}, [741] = {.lex_state = 0}, [742] = {.lex_state = 0, .external_lex_state = 3}, @@ -5382,8 +5404,8 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [750] = {.lex_state = 0}, [751] = {.lex_state = 0}, [752] = {.lex_state = 0, .external_lex_state = 3}, - [753] = {.lex_state = 62}, - [754] = {.lex_state = 62}, + [753] = {.lex_state = 64}, + [754] = {.lex_state = 64}, [755] = {.lex_state = 0, .external_lex_state = 3}, [756] = {.lex_state = 0}, [757] = {.lex_state = 0}, @@ -5392,21 +5414,21 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [760] = {.lex_state = 0, .external_lex_state = 3}, [761] = {.lex_state = 0, .external_lex_state = 3}, [762] = {.lex_state = 0, .external_lex_state = 3}, - [763] = {.lex_state = 62}, + [763] = {.lex_state = 64}, [764] = {.lex_state = 0}, - [765] = {.lex_state = 62}, + [765] = {.lex_state = 64}, [766] = {.lex_state = 0}, - [767] = {.lex_state = 0}, + [767] = {.lex_state = 65}, [768] = {.lex_state = 0, .external_lex_state = 3}, [769] = {.lex_state = 0, .external_lex_state = 4}, [770] = {.lex_state = 0, .external_lex_state = 3}, [771] = {.lex_state = 0, .external_lex_state = 4}, - [772] = {.lex_state = 62}, + [772] = {.lex_state = 64}, [773] = {.lex_state = 0}, [774] = {.lex_state = 0, .external_lex_state = 3}, [775] = {.lex_state = 0}, - [776] = {.lex_state = 63}, - [777] = {.lex_state = 62}, + [776] = {.lex_state = 65}, + [777] = {.lex_state = 64}, [778] = {.lex_state = 0}, [779] = {.lex_state = 0, .external_lex_state = 3}, [780] = {.lex_state = 0}, @@ -5414,86 +5436,86 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [782] = {.lex_state = 0, .external_lex_state = 3}, [783] = {.lex_state = 0, .external_lex_state = 3}, [784] = {.lex_state = 0, .external_lex_state = 3}, - [785] = {.lex_state = 62}, - [786] = {.lex_state = 62}, + [785] = {.lex_state = 64}, + [786] = {.lex_state = 64}, [787] = {.lex_state = 0, .external_lex_state = 3}, [788] = {.lex_state = 0, .external_lex_state = 3}, - [789] = {.lex_state = 62}, + [789] = {.lex_state = 64}, [790] = {.lex_state = 0}, [791] = {.lex_state = 0, .external_lex_state = 3}, - [792] = {.lex_state = 62}, + [792] = {.lex_state = 64}, [793] = {.lex_state = 0, .external_lex_state = 4}, [794] = {.lex_state = 0, .external_lex_state = 3}, [795] = {.lex_state = 0}, [796] = {.lex_state = 0}, - [797] = {.lex_state = 62}, - [798] = {.lex_state = 62}, + [797] = {.lex_state = 64}, + [798] = {.lex_state = 64}, [799] = {.lex_state = 0}, - [800] = {.lex_state = 62}, - [801] = {.lex_state = 63}, - [802] = {.lex_state = 62}, - [803] = {.lex_state = 62}, + [800] = {.lex_state = 64}, + [801] = {.lex_state = 65}, + [802] = {.lex_state = 64}, + [803] = {.lex_state = 64}, [804] = {.lex_state = 0, .external_lex_state = 3}, - [805] = {.lex_state = 62}, - [806] = {.lex_state = 62}, + [805] = {.lex_state = 64}, + [806] = {.lex_state = 64}, [807] = {.lex_state = 0, .external_lex_state = 3}, [808] = {.lex_state = 0}, - [809] = {.lex_state = 62}, - [810] = {.lex_state = 62}, - [811] = {.lex_state = 62}, + [809] = {.lex_state = 64}, + [810] = {.lex_state = 64}, + [811] = {.lex_state = 64}, [812] = {.lex_state = 0}, - [813] = {.lex_state = 62}, - [814] = {.lex_state = 62}, - [815] = {.lex_state = 62}, + [813] = {.lex_state = 64}, + [814] = {.lex_state = 64}, + [815] = {.lex_state = 64}, [816] = {.lex_state = 0}, - [817] = {.lex_state = 62}, - [818] = {.lex_state = 62}, + [817] = {.lex_state = 64}, + [818] = {.lex_state = 64}, [819] = {.lex_state = 0, .external_lex_state = 4}, - [820] = {.lex_state = 62}, + [820] = {.lex_state = 64}, [821] = {.lex_state = 0}, [822] = {.lex_state = 0, .external_lex_state = 3}, - [823] = {.lex_state = 63}, + [823] = {.lex_state = 65}, [824] = {.lex_state = 0}, - [825] = {.lex_state = 62}, + [825] = {.lex_state = 64}, [826] = {.lex_state = 0, .external_lex_state = 2}, - [827] = {.lex_state = 63}, + [827] = {.lex_state = 65}, [828] = {.lex_state = 0}, - [829] = {.lex_state = 63}, + [829] = {.lex_state = 65}, [830] = {.lex_state = 0}, [831] = {.lex_state = 0, .external_lex_state = 3}, [832] = {.lex_state = 0}, [833] = {.lex_state = 0}, [834] = {.lex_state = 0, .external_lex_state = 3}, [835] = {.lex_state = 0, .external_lex_state = 4}, - [836] = {.lex_state = 62}, - [837] = {.lex_state = 62}, + [836] = {.lex_state = 64}, + [837] = {.lex_state = 64}, [838] = {.lex_state = 0}, [839] = {.lex_state = 0}, [840] = {.lex_state = 0}, [841] = {.lex_state = 0}, [842] = {.lex_state = 0}, - [843] = {.lex_state = 62}, + [843] = {.lex_state = 64}, [844] = {.lex_state = 0}, - [845] = {.lex_state = 63}, + [845] = {.lex_state = 65}, [846] = {.lex_state = 0}, - [847] = {.lex_state = 63}, - [848] = {.lex_state = 62}, + [847] = {.lex_state = 65}, + [848] = {.lex_state = 64}, [849] = {.lex_state = 0}, [850] = {.lex_state = 0}, [851] = {.lex_state = 7}, - [852] = {.lex_state = 62}, - [853] = {.lex_state = 62}, - [854] = {.lex_state = 63}, - [855] = {.lex_state = 62}, + [852] = {.lex_state = 64}, + [853] = {.lex_state = 64}, + [854] = {.lex_state = 65}, + [855] = {.lex_state = 64}, [856] = {.lex_state = 0}, [857] = {.lex_state = 0}, [858] = {.lex_state = 7}, [859] = {.lex_state = 0}, - [860] = {.lex_state = 63}, - [861] = {.lex_state = 63}, + [860] = {.lex_state = 65}, + [861] = {.lex_state = 65}, [862] = {.lex_state = 0}, - [863] = {.lex_state = 63}, - [864] = {.lex_state = 62}, + [863] = {.lex_state = 65}, + [864] = {.lex_state = 64}, [865] = {.lex_state = 0}, [866] = {.lex_state = 0}, [867] = {.lex_state = 0}, @@ -5501,33 +5523,33 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [869] = {.lex_state = 0}, [870] = {.lex_state = 0}, [871] = {.lex_state = 0}, - [872] = {.lex_state = 63}, - [873] = {.lex_state = 62}, - [874] = {.lex_state = 63}, - [875] = {.lex_state = 62}, - [876] = {.lex_state = 62}, + [872] = {.lex_state = 65}, + [873] = {.lex_state = 64}, + [874] = {.lex_state = 65}, + [875] = {.lex_state = 64}, + [876] = {.lex_state = 64}, [877] = {.lex_state = 0}, - [878] = {.lex_state = 63}, - [879] = {.lex_state = 0}, + [878] = {.lex_state = 65}, + [879] = {.lex_state = 65}, [880] = {.lex_state = 0}, [881] = {.lex_state = 0}, - [882] = {.lex_state = 63}, - [883] = {.lex_state = 62}, - [884] = {.lex_state = 63}, - [885] = {.lex_state = 62}, - [886] = {.lex_state = 62}, + [882] = {.lex_state = 65}, + [883] = {.lex_state = 64}, + [884] = {.lex_state = 65}, + [885] = {.lex_state = 64}, + [886] = {.lex_state = 64}, [887] = {.lex_state = 0}, - [888] = {.lex_state = 63}, - [889] = {.lex_state = 63}, - [890] = {.lex_state = 63}, - [891] = {.lex_state = 62}, - [892] = {.lex_state = 62}, + [888] = {.lex_state = 65}, + [889] = {.lex_state = 65}, + [890] = {.lex_state = 65}, + [891] = {.lex_state = 64}, + [892] = {.lex_state = 64}, [893] = {.lex_state = 0}, - [894] = {.lex_state = 63}, + [894] = {.lex_state = 65}, [895] = {.lex_state = 0}, [896] = {.lex_state = 0}, [897] = {.lex_state = 0}, - [898] = {.lex_state = 63}, + [898] = {.lex_state = 65}, [899] = {.lex_state = 0}, }; @@ -5554,6 +5576,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_import] = ACTIONS(1), [anon_sym_as] = ACTIONS(1), [anon_sym_DOT] = ACTIONS(1), + [sym_extern_slot] = ACTIONS(1), [anon_sym_DASH] = ACTIONS(1), [anon_sym_LT_DASH] = ACTIONS(1), [anon_sym_fun] = ACTIONS(1), @@ -5642,11 +5665,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -5733,11 +5756,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -5824,11 +5847,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -5915,11 +5938,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -6336,11 +6359,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -6411,11 +6434,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -6486,11 +6509,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -6561,11 +6584,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -6636,11 +6659,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -6711,11 +6734,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -6786,11 +6809,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -6861,11 +6884,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -6936,11 +6959,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -7086,11 +7109,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -7161,11 +7184,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -7311,11 +7334,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -7386,11 +7409,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -7461,11 +7484,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -7536,11 +7559,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -7830,8 +7853,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -7905,8 +7928,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -7980,8 +8003,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -8061,11 +8084,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -8136,11 +8159,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -8211,11 +8234,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -8286,11 +8309,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -8361,11 +8384,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -8430,8 +8453,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -8505,8 +8528,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -8586,11 +8609,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -8811,11 +8834,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -8961,11 +8984,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -9111,11 +9134,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -11073,8 +11096,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -11151,11 +11174,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(450), [sym__or_expression] = STATE(424), [sym_or_expression] = STATE(424), - [sym__and_expression] = STATE(413), - [sym_and_expression] = STATE(413), - [sym__not_expression] = STATE(413), - [sym_not_expression] = STATE(413), - [sym_try_expression] = STATE(413), + [sym__and_expression] = STATE(411), + [sym_and_expression] = STATE(411), + [sym__not_expression] = STATE(411), + [sym_not_expression] = STATE(411), + [sym_try_expression] = STATE(411), [sym__comparison_expression] = STATE(349), [sym_comparison_expression] = STATE(349), [sym__additive_expression] = STATE(342), @@ -11217,8 +11240,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -11367,11 +11390,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_compose_expression] = STATE(446), [sym__or_expression] = STATE(422), [sym_or_expression] = STATE(422), - [sym__and_expression] = STATE(404), - [sym_and_expression] = STATE(404), - [sym__not_expression] = STATE(404), - [sym_not_expression] = STATE(404), - [sym_try_expression] = STATE(404), + [sym__and_expression] = STATE(410), + [sym_and_expression] = STATE(410), + [sym__not_expression] = STATE(410), + [sym_not_expression] = STATE(410), + [sym_try_expression] = STATE(410), [sym__comparison_expression] = STATE(356), [sym_comparison_expression] = STATE(356), [sym__additive_expression] = STATE(343), @@ -11505,8 +11528,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -11577,8 +11600,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -11721,8 +11744,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -12441,8 +12464,8 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_lambda] = STATE(337), [sym_if_expression] = STATE(337), [sym_match_expression] = STATE(337), - [sym__pipe_expression] = STATE(400), - [sym_pipe_expression] = STATE(400), + [sym__pipe_expression] = STATE(403), + [sym_pipe_expression] = STATE(403), [sym__compose_expression] = STATE(367), [sym_compose_expression] = STATE(367), [sym__or_expression] = STATE(361), @@ -13446,7 +13469,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(413), 5, + STATE(411), 5, sym__and_expression, sym_and_expression, sym__not_expression, @@ -13630,7 +13653,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(404), 5, + STATE(410), 5, sym__and_expression, sym_and_expression, sym__not_expression, @@ -13715,7 +13738,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(367), 2, sym__compose_expression, sym_compose_expression, - STATE(402), 2, + STATE(401), 2, sym__pipe_expression, sym_pipe_expression, ACTIONS(205), 3, @@ -13989,7 +14012,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(413), 5, + STATE(411), 5, sym__and_expression, sym_and_expression, sym__not_expression, @@ -14078,7 +14101,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(404), 5, + STATE(410), 5, sym__and_expression, sym_and_expression, sym__not_expression, @@ -14324,7 +14347,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(413), 5, + STATE(411), 5, sym__and_expression, sym_and_expression, sym__not_expression, @@ -14582,7 +14605,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(404), 5, + STATE(410), 5, sym__and_expression, sym_and_expression, sym__not_expression, @@ -14665,7 +14688,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(405), 5, + STATE(404), 5, sym__and_expression, sym_and_expression, sym__not_expression, @@ -14914,7 +14937,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(407), 5, + STATE(406), 5, sym__and_expression, sym_and_expression, sym__not_expression, @@ -15078,7 +15101,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(411), 3, + STATE(407), 3, sym__not_expression, sym_not_expression, sym_try_expression, @@ -15159,7 +15182,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(410), 3, + STATE(413), 3, sym__not_expression, sym_not_expression, sym_try_expression, @@ -15321,7 +15344,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, anon_sym_seq, anon_sym_result, - STATE(406), 3, + STATE(405), 3, sym__not_expression, sym_not_expression, sym_try_expression, @@ -26168,7 +26191,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(833), 1, sym_constructor_identifier, - STATE(390), 1, + STATE(391), 1, aux_sym_variant_repeat1, ACTIONS(835), 3, sym__dedent, @@ -26179,7 +26202,28 @@ static const uint16_t ts_small_parse_table[] = { sym__type_variable, sym__type_atom, sym_tuple_type, - [15251] = 7, + [15251] = 8, + ACTIONS(3), 1, + sym_comment, + ACTIONS(99), 1, + anon_sym_DQUOTE_DQUOTE_DQUOTE, + ACTIONS(101), 1, + anon_sym_DQUOTE, + ACTIONS(839), 1, + anon_sym_DASH, + ACTIONS(843), 1, + sym_integer, + ACTIONS(837), 2, + sym_extern_slot, + sym_float, + ACTIONS(841), 2, + anon_sym_true, + anon_sym_false, + STATE(740), 3, + sym__extern_literal, + sym_boolean, + sym_string, + [15280] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(770), 1, @@ -26188,7 +26232,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(776), 1, sym_constructor_identifier, - STATE(392), 1, + STATE(393), 1, aux_sym_variant_repeat1, ACTIONS(831), 3, sym__sep, @@ -26199,7 +26243,7 @@ static const uint16_t ts_small_parse_table[] = { sym__type_variable, sym__type_atom, sym_tuple_type, - [15278] = 7, + [15307] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(770), 1, @@ -26219,7 +26263,7 @@ static const uint16_t ts_small_parse_table[] = { sym_type_application, sym__type_atom, sym_tuple_type, - [15305] = 7, + [15334] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -26239,7 +26283,7 @@ static const uint16_t ts_small_parse_table[] = { sym_type_application, sym__type_atom, sym_tuple_type, - [15332] = 7, + [15361] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -26259,18 +26303,18 @@ static const uint16_t ts_small_parse_table[] = { sym_type_application, sym__type_atom, sym_tuple_type, - [15359] = 7, + [15388] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(837), 1, + ACTIONS(845), 1, sym_identifier, - ACTIONS(840), 1, + ACTIONS(848), 1, anon_sym_LPAREN, - ACTIONS(845), 1, + ACTIONS(853), 1, sym_constructor_identifier, - STATE(390), 1, + STATE(391), 1, aux_sym_variant_repeat1, - ACTIONS(843), 3, + ACTIONS(851), 3, sym__dedent, sym__sep, anon_sym_PIPE, @@ -26279,7 +26323,7 @@ static const uint16_t ts_small_parse_table[] = { sym__type_variable, sym__type_atom, sym_tuple_type, - [15386] = 7, + [15415] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -26299,7 +26343,7 @@ static const uint16_t ts_small_parse_table[] = { sym_type_application, sym__type_atom, sym_tuple_type, - [15413] = 7, + [15442] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(770), 1, @@ -26308,7 +26352,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, ACTIONS(776), 1, sym_constructor_identifier, - STATE(398), 1, + STATE(399), 1, aux_sym_variant_repeat1, ACTIONS(835), 3, sym__sep, @@ -26319,7 +26363,7 @@ static const uint16_t ts_small_parse_table[] = { sym__type_variable, sym__type_atom, sym_tuple_type, - [15440] = 7, + [15469] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -26339,7 +26383,7 @@ static const uint16_t ts_small_parse_table[] = { sym_type_application, sym__type_atom, sym_tuple_type, - [15467] = 7, + [15496] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -26359,16 +26403,16 @@ static const uint16_t ts_small_parse_table[] = { sym_type_application, sym__type_atom, sym_tuple_type, - [15494] = 6, + [15523] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(850), 1, + ACTIONS(858), 1, anon_sym_case, STATE(332), 1, sym_case_clause, - STATE(396), 1, + STATE(397), 1, aux_sym_match_expression_repeat2, - ACTIONS(848), 3, + ACTIONS(856), 3, anon_sym_let, anon_sym_return, anon_sym_yield, @@ -26378,16 +26422,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_do_BANG, anon_sym_return_BANG, anon_sym_yield_BANG, - [15519] = 6, + [15548] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(854), 1, + ACTIONS(862), 1, anon_sym_case, STATE(332), 1, sym_case_clause, - STATE(396), 1, + STATE(397), 1, aux_sym_match_expression_repeat2, - ACTIONS(852), 3, + ACTIONS(860), 3, anon_sym_let, anon_sym_return, anon_sym_yield, @@ -26397,7 +26441,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_do_BANG, anon_sym_return_BANG, anon_sym_yield_BANG, - [15544] = 7, + [15573] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -26417,18 +26461,18 @@ static const uint16_t ts_small_parse_table[] = { sym_type_application, sym__type_atom, sym_tuple_type, - [15571] = 7, + [15600] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(857), 1, + ACTIONS(865), 1, sym_identifier, - ACTIONS(860), 1, + ACTIONS(868), 1, anon_sym_LPAREN, - ACTIONS(863), 1, + ACTIONS(871), 1, sym_constructor_identifier, - STATE(398), 1, + STATE(399), 1, aux_sym_variant_repeat1, - ACTIONS(843), 3, + ACTIONS(851), 3, sym__sep, ts_builtin_sym_end, anon_sym_PIPE, @@ -26437,7 +26481,7 @@ static const uint16_t ts_small_parse_table[] = { sym__type_variable, sym__type_atom, sym_tuple_type, - [15598] = 7, + [15627] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(770), 1, @@ -26457,46 +26501,10 @@ static const uint16_t ts_small_parse_table[] = { sym_type_application, sym__type_atom, sym_tuple_type, - [15625] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(866), 1, - anon_sym_PIPE_GT, - ACTIONS(673), 3, - anon_sym_let, - anon_sym_return, - anon_sym_yield, - ACTIONS(675), 6, - anon_sym_RBRACE, - anon_sym_case, - anon_sym_let_BANG, - anon_sym_do_BANG, - anon_sym_return_BANG, - anon_sym_yield_BANG, - [15645] = 8, + [15654] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(99), 1, - anon_sym_DQUOTE_DQUOTE_DQUOTE, - ACTIONS(101), 1, - anon_sym_DQUOTE, - ACTIONS(868), 1, - anon_sym_DASH, - ACTIONS(872), 1, - sym_integer, ACTIONS(874), 1, - sym_float, - ACTIONS(870), 2, - anon_sym_true, - anon_sym_false, - STATE(741), 3, - sym__extern_literal, - sym_boolean, - sym_string, - [15673] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(866), 1, anon_sym_PIPE_GT, ACTIONS(803), 3, anon_sym_let, @@ -26509,7 +26517,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_do_BANG, anon_sym_return_BANG, anon_sym_yield_BANG, - [15693] = 3, + [15674] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(878), 2, @@ -26524,21 +26532,23 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_CARET, sym_constructor_identifier, - [15711] = 3, + [15692] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(880), 1, - anon_sym_and, - ACTIONS(681), 8, - sym__sep, - ts_builtin_sym_end, - anon_sym_case, + ACTIONS(874), 1, anon_sym_PIPE_GT, - anon_sym_LT_PIPE, - anon_sym_GT_GT, - anon_sym_LT_LT, - anon_sym_or, - [15728] = 3, + ACTIONS(673), 3, + anon_sym_let, + anon_sym_return, + anon_sym_yield, + ACTIONS(675), 6, + anon_sym_RBRACE, + anon_sym_case, + anon_sym_let_BANG, + anon_sym_do_BANG, + anon_sym_return_BANG, + anon_sym_yield_BANG, + [15712] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(880), 1, @@ -26552,7 +26562,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_GT, anon_sym_LT_LT, anon_sym_or, - [15745] = 2, + [15729] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(555), 9, @@ -26565,7 +26575,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_LT, anon_sym_or, anon_sym_and, - [15760] = 3, + [15744] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(882), 1, @@ -26579,10 +26589,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_GT, anon_sym_LT_LT, anon_sym_or, - [15777] = 2, + [15761] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(559), 9, + ACTIONS(551), 9, sym__sep, ts_builtin_sym_end, anon_sym_case, @@ -26592,12 +26602,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_LT, anon_sym_or, anon_sym_and, - [15792] = 2, + [15776] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(555), 9, - sym__dedent, + ACTIONS(559), 9, sym__sep, + ts_builtin_sym_end, anon_sym_case, anon_sym_PIPE_GT, anon_sym_LT_PIPE, @@ -26605,10 +26615,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_LT, anon_sym_or, anon_sym_and, - [15807] = 2, + [15791] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(559), 9, + ACTIONS(555), 9, sym__dedent, sym__sep, anon_sym_case, @@ -26618,10 +26628,12 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_LT, anon_sym_or, anon_sym_and, - [15822] = 2, + [15806] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(551), 9, + ACTIONS(880), 1, + anon_sym_and, + ACTIONS(681), 8, sym__sep, ts_builtin_sym_end, anon_sym_case, @@ -26630,8 +26642,21 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_GT, anon_sym_LT_LT, anon_sym_or, + [15823] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(882), 1, anon_sym_and, - [15837] = 2, + ACTIONS(681), 8, + sym__dedent, + sym__sep, + anon_sym_case, + anon_sym_PIPE_GT, + anon_sym_LT_PIPE, + anon_sym_GT_GT, + anon_sym_LT_LT, + anon_sym_or, + [15840] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(551), 9, @@ -26644,12 +26669,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_LT, anon_sym_or, anon_sym_and, - [15852] = 3, + [15855] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(882), 1, - anon_sym_and, - ACTIONS(681), 8, + ACTIONS(559), 9, sym__dedent, sym__sep, anon_sym_case, @@ -26658,7 +26681,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT_GT, anon_sym_LT_LT, anon_sym_or, - [15869] = 2, + anon_sym_and, + [15870] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(884), 8, @@ -26670,7 +26694,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [15883] = 2, + [15884] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(886), 8, @@ -26682,7 +26706,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [15897] = 7, + [15898] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(888), 1, @@ -26699,7 +26723,7 @@ static const uint16_t ts_small_parse_table[] = { sym_record_declaration, sym__variant_list, sym__variant_block, - [15921] = 2, + [15922] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(896), 8, @@ -26711,7 +26735,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [15935] = 2, + [15936] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(896), 8, @@ -26723,7 +26747,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [15949] = 3, + [15950] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(898), 3, @@ -26736,7 +26760,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_do_BANG, anon_sym_return_BANG, anon_sym_yield_BANG, - [15965] = 7, + [15966] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(904), 1, @@ -26753,7 +26777,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(426), 2, sym_measure_factor, aux_sym_measure_repeat1, - [15989] = 3, + [15990] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(910), 3, @@ -26766,7 +26790,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_do_BANG, anon_sym_return_BANG, anon_sym_yield_BANG, - [16005] = 3, + [16006] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(914), 1, @@ -26779,7 +26803,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_PIPE, anon_sym_GT_GT, anon_sym_LT_LT, - [16021] = 2, + [16022] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(916), 8, @@ -26791,7 +26815,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [16035] = 3, + [16036] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(918), 1, @@ -26804,7 +26828,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_PIPE, anon_sym_GT_GT, anon_sym_LT_LT, - [16051] = 9, + [16052] = 9, ACTIONS(3), 1, sym_comment, ACTIONS(888), 1, @@ -26823,7 +26847,7 @@ static const uint16_t ts_small_parse_table[] = { sym__variant_list, STATE(760), 1, sym__variant_block, - [16079] = 6, + [16080] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(922), 1, @@ -26839,7 +26863,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, ts_builtin_sym_end, anon_sym_SLASH, - [16101] = 2, + [16102] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(928), 8, @@ -26851,7 +26875,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_as, anon_sym_if, anon_sym_RBRACK, - [16115] = 2, + [16116] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(930), 8, @@ -26863,7 +26887,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [16129] = 2, + [16130] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(930), 8, @@ -26875,7 +26899,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [16143] = 3, + [16144] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(932), 3, @@ -26888,7 +26912,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_do_BANG, anon_sym_return_BANG, anon_sym_yield_BANG, - [16159] = 3, + [16160] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(936), 3, @@ -26901,7 +26925,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_do_BANG, anon_sym_return_BANG, anon_sym_yield_BANG, - [16175] = 3, + [16176] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(940), 3, @@ -26914,7 +26938,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_do_BANG, anon_sym_return_BANG, anon_sym_yield_BANG, - [16191] = 2, + [16192] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(944), 8, @@ -26926,7 +26950,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_as, anon_sym_if, anon_sym_RBRACK, - [16205] = 3, + [16206] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(914), 1, @@ -26939,7 +26963,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_PIPE, anon_sym_GT_GT, anon_sym_LT_LT, - [16221] = 3, + [16222] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(918), 1, @@ -26952,7 +26976,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_PIPE, anon_sym_GT_GT, anon_sym_LT_LT, - [16237] = 2, + [16238] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(946), 8, @@ -26964,7 +26988,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_as, anon_sym_if, anon_sym_RBRACK, - [16251] = 6, + [16252] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(904), 1, @@ -26979,7 +27003,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(426), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16272] = 6, + [16273] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(904), 1, @@ -26994,7 +27018,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(426), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16293] = 7, + [16294] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(952), 1, @@ -27010,7 +27034,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(453), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16316] = 7, + [16317] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(952), 1, @@ -27026,7 +27050,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(453), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16339] = 2, + [16340] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(958), 7, @@ -27037,7 +27061,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [16352] = 7, + [16353] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(952), 1, @@ -27053,7 +27077,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(453), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16375] = 2, + [16376] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(884), 7, @@ -27064,7 +27088,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [16388] = 6, + [16389] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(964), 1, @@ -27079,7 +27103,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(962), 2, anon_sym_mut, anon_sym_pure, - [16409] = 2, + [16410] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(958), 7, @@ -27090,7 +27114,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [16422] = 4, + [16423] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(966), 1, @@ -27103,7 +27127,7 @@ static const uint16_t ts_small_parse_table[] = { ts_builtin_sym_end, anon_sym_case, anon_sym_PIPE_GT, - [16439] = 7, + [16440] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(952), 1, @@ -27119,7 +27143,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(453), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16462] = 6, + [16463] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(970), 1, @@ -27134,7 +27158,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(448), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16483] = 7, + [16484] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(904), 1, @@ -27150,7 +27174,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(420), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16506] = 4, + [16507] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(978), 1, @@ -27163,7 +27187,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, anon_sym_case, anon_sym_PIPE_GT, - [16523] = 2, + [16524] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(886), 7, @@ -27174,7 +27198,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [16536] = 2, + [16537] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(916), 7, @@ -27185,7 +27209,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DASH_GT, sym_identifier, sym_constructor_identifier, - [16549] = 7, + [16550] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(902), 1, @@ -27201,7 +27225,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(448), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16572] = 5, + [16573] = 5, ACTIONS(984), 1, anon_sym_DQUOTE2, ACTIONS(988), 1, @@ -27214,7 +27238,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(469), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16590] = 7, + [16591] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(908), 1, @@ -27229,7 +27253,7 @@ static const uint16_t ts_small_parse_table[] = { sym_python_path, STATE(834), 1, sym_extern_target, - [16612] = 5, + [16613] = 5, ACTIONS(988), 1, anon_sym_LBRACE2, ACTIONS(990), 1, @@ -27242,7 +27266,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(469), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16630] = 3, + [16631] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1000), 1, @@ -27253,7 +27277,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, sym_identifier, sym_constructor_identifier, - [16644] = 2, + [16645] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1002), 6, @@ -27263,7 +27287,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, sym_identifier, sym_constructor_identifier, - [16656] = 2, + [16657] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(896), 6, @@ -27273,7 +27297,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, sym_identifier, sym_constructor_identifier, - [16668] = 7, + [16669] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(908), 1, @@ -27288,7 +27312,7 @@ static const uint16_t ts_small_parse_table[] = { sym_python_path, STATE(783), 1, sym_extern_target, - [16690] = 2, + [16691] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1002), 6, @@ -27298,7 +27322,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, sym_identifier, sym_constructor_identifier, - [16702] = 5, + [16703] = 5, ACTIONS(988), 1, anon_sym_LBRACE2, ACTIONS(990), 1, @@ -27311,7 +27335,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(464), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16720] = 2, + [16721] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(930), 6, @@ -27321,7 +27345,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, sym_identifier, sym_constructor_identifier, - [16732] = 5, + [16733] = 5, ACTIONS(988), 1, anon_sym_LBRACE2, ACTIONS(990), 1, @@ -27334,7 +27358,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(469), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16750] = 5, + [16751] = 5, ACTIONS(988), 1, anon_sym_LBRACE2, ACTIONS(990), 1, @@ -27347,7 +27371,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(466), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16768] = 5, + [16769] = 5, ACTIONS(988), 1, anon_sym_LBRACE2, ACTIONS(990), 1, @@ -27360,7 +27384,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(469), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16786] = 6, + [16787] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(948), 1, @@ -27374,7 +27398,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(448), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16806] = 6, + [16807] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(950), 1, @@ -27388,7 +27412,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(448), 2, sym_measure_factor, aux_sym_measure_repeat1, - [16826] = 5, + [16827] = 5, ACTIONS(990), 1, sym_comment, ACTIONS(1016), 1, @@ -27401,7 +27425,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(469), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16844] = 4, + [16845] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1026), 1, @@ -27413,7 +27437,7 @@ static const uint16_t ts_small_parse_table[] = { ts_builtin_sym_end, anon_sym_LPAREN, anon_sym_as, - [16860] = 2, + [16861] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(884), 6, @@ -27423,7 +27447,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, sym_identifier, sym_constructor_identifier, - [16872] = 2, + [16873] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(886), 6, @@ -27433,7 +27457,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, sym_identifier, sym_constructor_identifier, - [16884] = 3, + [16885] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(968), 2, @@ -27444,7 +27468,7 @@ static const uint16_t ts_small_parse_table[] = { ts_builtin_sym_end, anon_sym_case, anon_sym_PIPE_GT, - [16898] = 5, + [16899] = 5, ACTIONS(988), 1, anon_sym_LBRACE2, ACTIONS(990), 1, @@ -27457,7 +27481,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(454), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16916] = 5, + [16917] = 5, ACTIONS(988), 1, anon_sym_LBRACE2, ACTIONS(990), 1, @@ -27470,7 +27494,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(456), 2, sym_interpolation, aux_sym_fstring_repeat1, - [16934] = 2, + [16935] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(916), 6, @@ -27480,7 +27504,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, sym_identifier, sym_constructor_identifier, - [16946] = 4, + [16947] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1038), 1, @@ -27492,7 +27516,7 @@ static const uint16_t ts_small_parse_table[] = { ts_builtin_sym_end, anon_sym_LPAREN, anon_sym_as, - [16962] = 3, + [16963] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(980), 2, @@ -27503,7 +27527,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, anon_sym_case, anon_sym_PIPE_GT, - [16976] = 4, + [16977] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1026), 1, @@ -27515,7 +27539,7 @@ static const uint16_t ts_small_parse_table[] = { ts_builtin_sym_end, anon_sym_LPAREN, anon_sym_as, - [16992] = 4, + [16993] = 4, ACTIONS(3), 1, sym_comment, STATE(480), 1, @@ -27526,7 +27550,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1045), 2, anon_sym_mut, anon_sym_pure, - [17007] = 5, + [17008] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(904), 1, @@ -27538,7 +27562,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(438), 2, sym_measure_factor, aux_sym_measure_repeat1, - [17024] = 5, + [17025] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1050), 1, @@ -27550,7 +27574,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1048), 2, sym__sep, ts_builtin_sym_end, - [17041] = 5, + [17042] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1053), 1, @@ -27562,7 +27586,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(784), 2, sym__sep, ts_builtin_sym_end, - [17058] = 5, + [17059] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1056), 1, @@ -27574,7 +27598,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(795), 2, sym__dedent, sym__sep, - [17075] = 4, + [17076] = 4, ACTIONS(3), 1, sym_comment, STATE(480), 1, @@ -27585,7 +27609,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1060), 2, anon_sym_mut, anon_sym_pure, - [17090] = 5, + [17091] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1062), 1, @@ -27597,7 +27621,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(795), 2, sym__sep, ts_builtin_sym_end, - [17107] = 5, + [17108] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1064), 1, @@ -27609,7 +27633,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(784), 2, sym__dedent, sym__sep, - [17124] = 5, + [17125] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(952), 1, @@ -27621,7 +27645,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(467), 2, sym_measure_factor, aux_sym_measure_repeat1, - [17141] = 4, + [17142] = 4, ACTIONS(3), 1, sym_comment, STATE(480), 1, @@ -27632,7 +27656,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1067), 2, sym_wildcard, sym_identifier, - [17156] = 5, + [17157] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(770), 1, @@ -27644,7 +27668,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1069), 2, sym__sep, ts_builtin_sym_end, - [17173] = 6, + [17174] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -27657,7 +27681,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, STATE(598), 1, aux_sym_list_pattern_repeat1, - [17192] = 5, + [17193] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(952), 1, @@ -27669,7 +27693,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(468), 2, sym_measure_factor, aux_sym_measure_repeat1, - [17209] = 3, + [17210] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1079), 1, @@ -27679,7 +27703,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, sym_identifier, sym_constructor_identifier, - [17222] = 2, + [17223] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1036), 5, @@ -27688,7 +27712,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, anon_sym_as, anon_sym_DOT, - [17233] = 4, + [17234] = 4, ACTIONS(3), 1, sym_comment, STATE(485), 1, @@ -27699,7 +27723,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1083), 2, anon_sym_mut, anon_sym_pure, - [17248] = 2, + [17249] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1085), 5, @@ -27708,7 +27732,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, sym_identifier, sym_constructor_identifier, - [17259] = 5, + [17260] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(770), 1, @@ -27720,7 +27744,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1087), 2, sym__sep, ts_builtin_sym_end, - [17276] = 5, + [17277] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1089), 1, @@ -27732,7 +27756,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1092), 2, anon_sym_EQ, anon_sym_DASH_GT, - [17293] = 2, + [17294] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(876), 5, @@ -27741,7 +27765,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_CARET, sym_identifier, sym_constructor_identifier, - [17304] = 5, + [17305] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(904), 1, @@ -27753,7 +27777,7 @@ static const uint16_t ts_small_parse_table[] = { STATE(437), 2, sym_measure_factor, aux_sym_measure_repeat1, - [17321] = 6, + [17322] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -27766,7 +27790,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(630), 1, aux_sym_tuple_pattern_repeat1, - [17340] = 5, + [17341] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -27777,7 +27801,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [17356] = 4, + [17357] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -27787,7 +27811,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1102), 2, anon_sym_COMMA, anon_sym_RBRACK, - [17370] = 5, + [17371] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -27798,7 +27822,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_type_definition_repeat1, STATE(772), 1, sym__type_variable, - [17386] = 5, + [17387] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1106), 1, @@ -27809,7 +27833,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(574), 1, aux_sym__variant_block_repeat1, - [17402] = 5, + [17403] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -27820,7 +27844,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, ACTIONS(1114), 1, anon_sym_if, - [17418] = 4, + [17419] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1116), 1, @@ -27830,7 +27854,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1118), 2, sym__triple_content, sym_escape_sequence, - [17432] = 4, + [17433] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1116), 1, @@ -27840,7 +27864,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1120), 2, sym__string_content, sym_escape_sequence, - [17446] = 4, + [17447] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1124), 1, @@ -27850,7 +27874,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1122), 2, sym__sep, ts_builtin_sym_end, - [17460] = 5, + [17461] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(908), 1, @@ -27861,7 +27885,7 @@ static const uint16_t ts_small_parse_table[] = { sym__path_component, STATE(643), 1, sym_python_path, - [17476] = 5, + [17477] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -27872,7 +27896,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [17492] = 4, + [17493] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1128), 1, @@ -27882,7 +27906,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1130), 2, sym__triple_content, sym_escape_sequence, - [17506] = 4, + [17507] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1128), 1, @@ -27892,7 +27916,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1132), 2, sym__string_content, sym_escape_sequence, - [17520] = 3, + [17521] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1136), 1, @@ -27901,7 +27925,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, ts_builtin_sym_end, anon_sym_EQ, - [17532] = 5, + [17533] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1056), 1, @@ -27912,7 +27936,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_match_expression_repeat2, STATE(605), 1, sym_case_clause, - [17548] = 3, + [17549] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1140), 1, @@ -27921,7 +27945,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, ts_builtin_sym_end, anon_sym_case, - [17560] = 5, + [17561] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -27932,7 +27956,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_type_definition_repeat1, STATE(772), 1, sym__type_variable, - [17576] = 5, + [17577] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1144), 1, @@ -27943,7 +27967,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [17592] = 5, + [17593] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1146), 1, @@ -27954,7 +27978,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [17608] = 5, + [17609] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1062), 1, @@ -27965,7 +27989,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_match_expression_repeat2, STATE(691), 1, sym_case_clause, - [17624] = 5, + [17625] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1146), 1, @@ -27976,7 +28000,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [17640] = 4, + [17641] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1124), 1, @@ -27986,7 +28010,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1122), 2, sym__sep, ts_builtin_sym_end, - [17654] = 5, + [17655] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -27997,7 +28021,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, ACTIONS(1156), 1, anon_sym_if, - [17670] = 5, + [17671] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28008,7 +28032,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [17686] = 4, + [17687] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1160), 1, @@ -28018,7 +28042,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1130), 2, sym__triple_content, sym_escape_sequence, - [17700] = 5, + [17701] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28029,7 +28053,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [17716] = 5, + [17717] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28040,7 +28064,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [17732] = 5, + [17733] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28051,7 +28075,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [17748] = 4, + [17749] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1160), 1, @@ -28061,7 +28085,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1132), 2, sym__string_content, sym_escape_sequence, - [17762] = 4, + [17763] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1168), 1, @@ -28071,7 +28095,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1170), 2, sym__triple_content, sym_escape_sequence, - [17776] = 4, + [17777] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1168), 1, @@ -28081,7 +28105,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1172), 2, sym__string_content, sym_escape_sequence, - [17790] = 4, + [17791] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1176), 1, @@ -28091,7 +28115,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1174), 2, sym__sep, ts_builtin_sym_end, - [17804] = 5, + [17805] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -28102,7 +28126,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_type_definition_repeat1, STATE(772), 1, sym__type_variable, - [17820] = 5, + [17821] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28113,7 +28137,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [17836] = 4, + [17837] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1182), 1, @@ -28123,7 +28147,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1130), 2, sym__triple_content, sym_escape_sequence, - [17850] = 4, + [17851] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1182), 1, @@ -28133,7 +28157,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1132), 2, sym__string_content, sym_escape_sequence, - [17864] = 4, + [17865] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1186), 1, @@ -28143,7 +28167,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1184), 2, anon_sym_RPAREN, anon_sym_RBRACK, - [17878] = 5, + [17879] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1189), 1, @@ -28154,7 +28178,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_type, ACTIONS(1195), 1, anon_sym_import, - [17894] = 3, + [17895] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1140), 1, @@ -28163,7 +28187,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, ts_builtin_sym_end, anon_sym_case, - [17906] = 5, + [17907] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1146), 1, @@ -28174,7 +28198,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [17922] = 5, + [17923] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28185,7 +28209,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [17938] = 4, + [17939] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1201), 1, @@ -28195,7 +28219,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1203), 2, sym__string_content, sym_escape_sequence, - [17952] = 5, + [17953] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1146), 1, @@ -28206,7 +28230,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [17968] = 5, + [17969] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -28217,7 +28241,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, ACTIONS(1210), 1, anon_sym_if, - [17984] = 5, + [17985] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28228,7 +28252,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [18000] = 5, + [18001] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28239,7 +28263,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [18016] = 4, + [18017] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1216), 1, @@ -28249,7 +28273,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1218), 2, sym__string_content, sym_escape_sequence, - [18030] = 4, + [18031] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1220), 1, @@ -28259,7 +28283,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1130), 2, sym__triple_content, sym_escape_sequence, - [18044] = 4, + [18045] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1220), 1, @@ -28269,7 +28293,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1132), 2, sym__string_content, sym_escape_sequence, - [18058] = 4, + [18059] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -28279,7 +28303,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1222), 2, anon_sym_COMMA, anon_sym_RBRACE, - [18072] = 4, + [18073] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1224), 1, @@ -28289,7 +28313,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1226), 2, sym__triple_content, sym_escape_sequence, - [18086] = 4, + [18087] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1224), 1, @@ -28299,7 +28323,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1228), 2, sym__string_content, sym_escape_sequence, - [18100] = 4, + [18101] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1124), 1, @@ -28309,7 +28333,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1230), 2, sym__sep, ts_builtin_sym_end, - [18114] = 2, + [18115] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1085), 4, @@ -28317,7 +28341,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, sym_identifier, sym_constructor_identifier, - [18124] = 5, + [18125] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28328,7 +28352,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [18140] = 5, + [18141] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(778), 1, @@ -28339,7 +28363,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_type_definition_repeat1, STATE(772), 1, sym__type_variable, - [18156] = 5, + [18157] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28350,7 +28374,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [18172] = 4, + [18173] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1238), 1, @@ -28360,7 +28384,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1130), 2, sym__triple_content, sym_escape_sequence, - [18186] = 3, + [18187] = 3, ACTIONS(990), 1, sym_comment, ACTIONS(1242), 1, @@ -28369,7 +28393,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE2, sym_escape_sequence, aux_sym_fstring_token2, - [18198] = 4, + [18199] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1238), 1, @@ -28379,7 +28403,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1132), 2, sym__string_content, sym_escape_sequence, - [18212] = 3, + [18213] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1244), 1, @@ -28388,7 +28412,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, sym__sep, anon_sym_case, - [18224] = 5, + [18225] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28399,7 +28423,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [18240] = 5, + [18241] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -28410,7 +28434,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [18256] = 5, + [18257] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(797), 1, @@ -28421,7 +28445,7 @@ static const uint16_t ts_small_parse_table[] = { sym_case_clause, STATE(368), 1, aux_sym_match_expression_repeat2, - [18272] = 5, + [18273] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1146), 1, @@ -28432,7 +28456,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [18288] = 4, + [18289] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -28442,7 +28466,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1254), 2, anon_sym_RPAREN, anon_sym_COMMA, - [18302] = 4, + [18303] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1256), 1, @@ -28452,7 +28476,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1258), 2, sym__triple_content, sym_escape_sequence, - [18316] = 5, + [18317] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1146), 1, @@ -28463,7 +28487,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [18332] = 3, + [18333] = 3, ACTIONS(990), 1, sym_comment, ACTIONS(1265), 1, @@ -28472,7 +28496,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE2, sym_escape_sequence, aux_sym_fstring_token2, - [18344] = 5, + [18345] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1048), 1, @@ -28483,7 +28507,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_type_definition_repeat1, STATE(772), 1, sym__type_variable, - [18360] = 5, + [18361] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1146), 1, @@ -28494,7 +28518,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [18376] = 5, + [18377] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -28505,7 +28529,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COLON, ACTIONS(1274), 1, anon_sym_if, - [18392] = 5, + [18393] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1106), 1, @@ -28516,7 +28540,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(579), 1, aux_sym__variant_block_repeat1, - [18408] = 5, + [18409] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1106), 1, @@ -28527,7 +28551,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(580), 1, aux_sym__variant_block_repeat1, - [18424] = 4, + [18425] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1124), 1, @@ -28537,7 +28561,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1278), 2, sym__sep, ts_builtin_sym_end, - [18438] = 4, + [18439] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1280), 1, @@ -28547,7 +28571,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1282), 2, sym__string_content, sym_escape_sequence, - [18452] = 3, + [18453] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1244), 1, @@ -28556,18 +28580,18 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, sym__sep, anon_sym_case, - [18464] = 5, + [18465] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(850), 1, + ACTIONS(858), 1, anon_sym_case, ACTIONS(1250), 1, sym__indent, STATE(332), 1, sym_case_clause, - STATE(395), 1, + STATE(396), 1, aux_sym_match_expression_repeat2, - [18480] = 5, + [18481] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1106), 1, @@ -28578,7 +28602,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(580), 1, aux_sym__variant_block_repeat1, - [18496] = 5, + [18497] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1286), 1, @@ -28589,7 +28613,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(580), 1, aux_sym__variant_block_repeat1, - [18512] = 4, + [18513] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1176), 1, @@ -28599,7 +28623,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1294), 2, sym__sep, ts_builtin_sym_end, - [18526] = 4, + [18527] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1298), 1, @@ -28609,7 +28633,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1296), 2, sym__sep, ts_builtin_sym_end, - [18540] = 3, + [18541] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1301), 1, @@ -28618,7 +28642,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [18552] = 5, + [18553] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1303), 1, @@ -28629,7 +28653,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_expression_repeat1, STATE(789), 1, sym_elif_clause, - [18568] = 4, + [18569] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1280), 1, @@ -28639,7 +28663,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1308), 2, sym__triple_content, sym_escape_sequence, - [18582] = 5, + [18583] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1071), 1, @@ -28650,7 +28674,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, ACTIONS(1312), 1, anon_sym_COMMA, - [18598] = 4, + [18599] = 4, ACTIONS(990), 1, sym_comment, ACTIONS(1216), 1, @@ -28660,7 +28684,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1314), 2, sym__triple_content, sym_escape_sequence, - [18612] = 4, + [18613] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1316), 1, @@ -28669,7 +28693,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(686), 1, aux_sym_match_expression_repeat1, - [18625] = 4, + [18626] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1320), 1, @@ -28678,28 +28702,28 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(612), 1, aux_sym_effect_annotation_repeat1, - [18638] = 2, + [18639] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1324), 3, sym__sep, ts_builtin_sym_end, anon_sym_EQ, - [18647] = 2, + [18648] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(647), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [18656] = 2, + [18657] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(663), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [18665] = 4, + [18666] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1326), 1, @@ -28708,14 +28732,14 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(593), 1, aux_sym_match_expression_repeat1, - [18678] = 2, + [18679] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1331), 3, anon_sym_EQ, anon_sym_DASH_GT, sym_identifier, - [18687] = 4, + [18688] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1333), 1, @@ -28724,7 +28748,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(662), 1, aux_sym_record_expression_repeat1, - [18700] = 4, + [18701] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1337), 1, @@ -28733,14 +28757,14 @@ static const uint16_t ts_small_parse_table[] = { sym_wildcard, ACTIONS(1341), 1, sym_constructor_identifier, - [18713] = 2, + [18714] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(643), 3, sym__dedent, sym__sep, anon_sym_case, - [18722] = 4, + [18723] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1073), 1, @@ -28749,7 +28773,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, STATE(621), 1, aux_sym_list_pattern_repeat1, - [18735] = 3, + [18736] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1345), 1, @@ -28757,7 +28781,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1347), 2, anon_sym_COMMA, anon_sym_RBRACE, - [18746] = 4, + [18747] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1349), 1, @@ -28766,7 +28790,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(624), 1, aux_sym_record_pattern_repeat1, - [18759] = 4, + [18760] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1353), 1, @@ -28775,7 +28799,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(601), 1, aux_sym_source_file_repeat1, - [18772] = 4, + [18773] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1358), 1, @@ -28784,35 +28808,35 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(668), 1, aux_sym__block_repeat1, - [18785] = 2, + [18786] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(667), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [18794] = 2, + [18795] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(671), 3, sym__dedent, sym__sep, anon_sym_case, - [18803] = 2, + [18804] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(655), 3, sym__dedent, sym__sep, anon_sym_case, - [18812] = 2, + [18813] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1362), 3, sym__dedent, sym__sep, anon_sym_PIPE, - [18821] = 4, + [18822] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1364), 1, @@ -28821,7 +28845,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(625), 1, aux_sym_tuple_type_repeat1, - [18834] = 4, + [18835] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1368), 1, @@ -28830,7 +28854,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(626), 1, aux_sym_extern_kwargs_repeat1, - [18847] = 4, + [18848] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1372), 1, @@ -28839,21 +28863,21 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, STATE(727), 1, sym_effect_label, - [18860] = 2, + [18861] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1376), 3, anon_sym_LPAREN, sym_identifier, sym_constructor_identifier, - [18869] = 2, + [18870] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(659), 3, sym__dedent, sym__sep, anon_sym_case, - [18878] = 4, + [18879] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1320), 1, @@ -28862,21 +28886,21 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(628), 1, aux_sym_effect_annotation_repeat1, - [18891] = 2, + [18892] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1380), 3, anon_sym_EQ, anon_sym_DASH_GT, sym_identifier, - [18900] = 2, + [18901] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(635), 3, sym__dedent, sym__sep, anon_sym_case, - [18909] = 4, + [18910] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1382), 1, @@ -28885,42 +28909,42 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(669), 1, aux_sym_source_file_repeat1, - [18922] = 2, + [18923] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(651), 3, sym__dedent, sym__sep, anon_sym_case, - [18931] = 2, + [18932] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(679), 3, sym__dedent, sym__sep, anon_sym_case, - [18940] = 2, + [18941] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(647), 3, sym__dedent, sym__sep, anon_sym_case, - [18949] = 2, + [18950] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(663), 3, sym__dedent, sym__sep, anon_sym_case, - [18958] = 2, + [18959] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(667), 3, sym__dedent, sym__sep, anon_sym_case, - [18967] = 4, + [18968] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1102), 1, @@ -28929,7 +28953,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(621), 1, aux_sym_list_pattern_repeat1, - [18980] = 4, + [18981] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(241), 1, @@ -28938,14 +28962,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(537), 1, aux_sym_tuple_expression_repeat1, - [18993] = 2, + [18994] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(639), 3, sym__dedent, sym__sep, anon_sym_case, - [19002] = 4, + [19003] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1349), 1, @@ -28954,7 +28978,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(631), 1, aux_sym_record_pattern_repeat1, - [19015] = 4, + [19016] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1393), 1, @@ -28963,7 +28987,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(625), 1, aux_sym_tuple_type_repeat1, - [19028] = 4, + [19029] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1370), 1, @@ -28972,14 +28996,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(633), 1, aux_sym_extern_kwargs_repeat1, - [19041] = 2, + [19042] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1400), 3, anon_sym_LPAREN, sym_identifier, sym_constructor_identifier, - [19050] = 4, + [19051] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1402), 1, @@ -28988,7 +29012,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(628), 1, aux_sym_effect_annotation_repeat1, - [19063] = 4, + [19064] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1407), 1, @@ -28997,7 +29021,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(674), 1, aux_sym_record_declaration_repeat1, - [19076] = 4, + [19077] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1096), 1, @@ -29006,7 +29030,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(635), 1, aux_sym_tuple_pattern_repeat1, - [19089] = 4, + [19090] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1413), 1, @@ -29015,14 +29039,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(631), 1, aux_sym_record_pattern_repeat1, - [19102] = 2, + [19103] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(639), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [19111] = 4, + [19112] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1418), 1, @@ -29031,7 +29055,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(633), 1, aux_sym_extern_kwargs_repeat1, - [19124] = 4, + [19125] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1423), 1, @@ -29040,7 +29064,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, STATE(673), 1, aux_sym_tuple_expression_repeat1, - [19137] = 4, + [19138] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1254), 1, @@ -29049,14 +29073,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(635), 1, aux_sym_tuple_pattern_repeat1, - [19150] = 2, + [19151] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(675), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [19159] = 4, + [19160] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1430), 1, @@ -29065,7 +29089,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DOT, STATE(689), 1, aux_sym_field_update_repeat1, - [19172] = 4, + [19173] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1434), 1, @@ -29074,7 +29098,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(690), 1, aux_sym_record_update_expression_repeat1, - [19185] = 3, + [19186] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1440), 1, @@ -29082,7 +29106,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1438), 2, sym__sep, ts_builtin_sym_end, - [19196] = 4, + [19197] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1333), 1, @@ -29091,7 +29115,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(595), 1, aux_sym_record_expression_repeat1, - [19209] = 4, + [19210] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(908), 1, @@ -29100,7 +29124,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(706), 1, sym__path_component, - [19222] = 4, + [19223] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1318), 1, @@ -29109,7 +29133,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(709), 1, aux_sym_match_expression_repeat1, - [19235] = 3, + [19236] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1450), 1, @@ -29117,7 +29141,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1448), 2, sym__sep, ts_builtin_sym_end, - [19246] = 4, + [19247] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1452), 1, @@ -29126,7 +29150,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(622), 1, aux_sym_tuple_expression_repeat1, - [19259] = 4, + [19260] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1456), 1, @@ -29135,7 +29159,7 @@ static const uint16_t ts_small_parse_table[] = { sym_constructor_identifier, STATE(505), 1, sym_variant, - [19272] = 4, + [19273] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1460), 1, @@ -29144,7 +29168,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, STATE(649), 1, aux_sym_tuple_expression_repeat1, - [19285] = 4, + [19286] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1432), 1, @@ -29153,7 +29177,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ, STATE(637), 1, aux_sym_field_update_repeat1, - [19298] = 4, + [19299] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1434), 1, @@ -29162,7 +29186,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(638), 1, aux_sym_record_update_expression_repeat1, - [19311] = 4, + [19312] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(259), 1, @@ -29171,14 +29195,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(537), 1, aux_sym_tuple_expression_repeat1, - [19324] = 2, + [19325] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1470), 3, sym__sep, ts_builtin_sym_end, sym_identifier, - [19333] = 4, + [19334] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1333), 1, @@ -29187,7 +29211,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(655), 1, aux_sym_record_expression_repeat1, - [19346] = 4, + [19347] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1474), 1, @@ -29196,7 +29220,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(657), 1, aux_sym_tuple_expression_repeat1, - [19359] = 4, + [19360] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1434), 1, @@ -29205,7 +29229,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(658), 1, aux_sym_record_update_expression_repeat1, - [19372] = 3, + [19373] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1482), 1, @@ -29213,7 +29237,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1480), 2, sym__sep, ts_builtin_sym_end, - [19383] = 4, + [19384] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1333), 1, @@ -29222,7 +29246,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(662), 1, aux_sym_record_expression_repeat1, - [19396] = 4, + [19397] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1360), 1, @@ -29231,7 +29255,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(661), 1, aux_sym__block_repeat1, - [19409] = 4, + [19410] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(263), 1, @@ -29240,7 +29264,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(537), 1, aux_sym_tuple_expression_repeat1, - [19422] = 4, + [19423] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1434), 1, @@ -29249,7 +29273,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(690), 1, aux_sym_record_update_expression_repeat1, - [19435] = 4, + [19436] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1318), 1, @@ -29258,7 +29282,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(663), 1, aux_sym_match_expression_repeat1, - [19448] = 4, + [19449] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1494), 1, @@ -29267,7 +29291,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(608), 1, sym_extern_kwarg, - [19461] = 4, + [19462] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1360), 1, @@ -29276,7 +29300,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(717), 1, aux_sym__block_repeat1, - [19474] = 4, + [19475] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1500), 1, @@ -29285,7 +29309,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(662), 1, aux_sym_record_expression_repeat1, - [19487] = 4, + [19488] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1318), 1, @@ -29294,7 +29318,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(593), 1, aux_sym_match_expression_repeat1, - [19500] = 4, + [19501] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1366), 1, @@ -29303,7 +29327,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(665), 1, aux_sym_tuple_type_repeat1, - [19513] = 4, + [19514] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1366), 1, @@ -29312,7 +29336,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(625), 1, aux_sym_tuple_type_repeat1, - [19526] = 4, + [19527] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1341), 1, @@ -29321,14 +29345,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, ACTIONS(1513), 1, sym_wildcard, - [19539] = 2, + [19540] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(659), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [19548] = 4, + [19549] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1360), 1, @@ -29337,7 +29361,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(717), 1, aux_sym__block_repeat1, - [19561] = 4, + [19562] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(63), 1, @@ -29346,7 +29370,7 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(601), 1, aux_sym_source_file_repeat1, - [19574] = 3, + [19575] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1521), 1, @@ -29354,7 +29378,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1519), 2, sym__sep, ts_builtin_sym_end, - [19585] = 4, + [19586] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1458), 1, @@ -29363,7 +29387,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PIPE, STATE(718), 1, sym_variant, - [19598] = 4, + [19599] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1525), 1, @@ -29372,7 +29396,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, STATE(675), 1, aux_sym_tuple_expression_repeat1, - [19611] = 4, + [19612] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(235), 1, @@ -29381,7 +29405,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(537), 1, aux_sym_tuple_expression_repeat1, - [19624] = 4, + [19625] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1407), 1, @@ -29390,7 +29414,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(720), 1, aux_sym_record_declaration_repeat1, - [19637] = 4, + [19638] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(233), 1, @@ -29399,7 +29423,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(537), 1, aux_sym_tuple_expression_repeat1, - [19650] = 4, + [19651] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1333), 1, @@ -29408,7 +29432,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(680), 1, aux_sym_record_expression_repeat1, - [19663] = 4, + [19664] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1537), 1, @@ -29417,7 +29441,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(682), 1, aux_sym_tuple_expression_repeat1, - [19676] = 4, + [19677] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1434), 1, @@ -29426,14 +29450,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(683), 1, aux_sym_record_update_expression_repeat1, - [19689] = 2, + [19690] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1296), 3, sym__sep, ts_builtin_sym_end, anon_sym_PIPE, - [19698] = 4, + [19699] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1333), 1, @@ -29442,7 +29466,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(662), 1, aux_sym_record_expression_repeat1, - [19711] = 4, + [19712] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1360), 1, @@ -29451,7 +29475,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(685), 1, aux_sym__block_repeat1, - [19724] = 4, + [19725] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(239), 1, @@ -29460,7 +29484,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(537), 1, aux_sym_tuple_expression_repeat1, - [19737] = 4, + [19738] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1434), 1, @@ -29469,14 +29493,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(690), 1, aux_sym_record_update_expression_repeat1, - [19750] = 2, + [19751] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(671), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [19759] = 4, + [19760] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1360), 1, @@ -29485,7 +29509,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(717), 1, aux_sym__block_repeat1, - [19772] = 4, + [19773] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1318), 1, @@ -29494,7 +29518,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(593), 1, aux_sym_match_expression_repeat1, - [19785] = 4, + [19786] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1366), 1, @@ -29503,7 +29527,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(688), 1, aux_sym_tuple_type_repeat1, - [19798] = 4, + [19799] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1366), 1, @@ -29512,7 +29536,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(625), 1, aux_sym_tuple_type_repeat1, - [19811] = 4, + [19812] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1559), 1, @@ -29521,7 +29545,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DOT, STATE(689), 1, aux_sym_field_update_repeat1, - [19824] = 4, + [19825] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1564), 1, @@ -29530,14 +29554,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(690), 1, aux_sym_record_update_expression_repeat1, - [19837] = 2, + [19838] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(655), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [19846] = 4, + [19847] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(908), 1, @@ -29546,7 +29570,7 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(581), 1, sym__path_component, - [19859] = 4, + [19860] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1571), 1, @@ -29555,7 +29579,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, STATE(697), 1, aux_sym_tuple_expression_repeat1, - [19872] = 4, + [19873] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1372), 1, @@ -29564,21 +29588,21 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_async, STATE(589), 1, sym_effect_label, - [19885] = 2, + [19886] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1575), 3, sym__sep, ts_builtin_sym_end, anon_sym_EQ, - [19894] = 2, + [19895] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1184), 3, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACK, - [19903] = 4, + [19904] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(249), 1, @@ -29587,7 +29611,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(537), 1, aux_sym_tuple_expression_repeat1, - [19916] = 4, + [19917] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1333), 1, @@ -29596,7 +29620,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(702), 1, aux_sym_record_expression_repeat1, - [19929] = 4, + [19930] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1581), 1, @@ -29605,7 +29629,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(703), 1, aux_sym_tuple_expression_repeat1, - [19942] = 4, + [19943] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1434), 1, @@ -29614,14 +29638,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(704), 1, aux_sym_record_update_expression_repeat1, - [19955] = 2, + [19956] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(635), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [19964] = 4, + [19965] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1333), 1, @@ -29630,7 +29654,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(662), 1, aux_sym_record_expression_repeat1, - [19977] = 4, + [19978] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(253), 1, @@ -29639,7 +29663,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, STATE(537), 1, aux_sym_tuple_expression_repeat1, - [19990] = 4, + [19991] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1434), 1, @@ -29648,7 +29672,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(690), 1, aux_sym_record_update_expression_repeat1, - [20003] = 4, + [20004] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -29657,7 +29681,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [20016] = 3, + [20017] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1595), 1, @@ -29665,21 +29689,21 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(1593), 2, sym__sep, ts_builtin_sym_end, - [20027] = 2, + [20028] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(651), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [20036] = 2, + [20037] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1575), 3, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [20045] = 4, + [20046] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1318), 1, @@ -29688,7 +29712,7 @@ static const uint16_t ts_small_parse_table[] = { sym__dedent, STATE(593), 1, aux_sym_match_expression_repeat1, - [20058] = 4, + [20059] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -29697,7 +29721,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [20071] = 4, + [20072] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1073), 1, @@ -29706,14 +29730,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, STATE(598), 1, aux_sym_list_pattern_repeat1, - [20084] = 2, + [20085] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1324), 3, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [20093] = 4, + [20094] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -29722,14 +29746,14 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [20106] = 2, + [20107] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(675), 3, sym__dedent, sym__sep, anon_sym_case, - [20115] = 4, + [20116] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1098), 1, @@ -29738,14 +29762,14 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_let_binding_repeat2, STATE(613), 1, sym_parameter, - [20128] = 2, + [20129] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(679), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [20137] = 4, + [20138] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1599), 1, @@ -29754,21 +29778,21 @@ static const uint16_t ts_small_parse_table[] = { sym__sep, STATE(717), 1, aux_sym__block_repeat1, - [20150] = 2, + [20151] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1289), 3, sym__dedent, sym__sep, anon_sym_PIPE, - [20159] = 2, + [20160] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(643), 3, sym__sep, ts_builtin_sym_end, anon_sym_case, - [20168] = 4, + [20169] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1604), 1, @@ -29777,7 +29801,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, STATE(720), 1, aux_sym_record_declaration_repeat1, - [20181] = 4, + [20182] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1366), 1, @@ -29786,7 +29810,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(607), 1, aux_sym_tuple_type_repeat1, - [20194] = 4, + [20195] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(908), 1, @@ -29795,1047 +29819,1047 @@ static const uint16_t ts_small_parse_table[] = { sym_identifier, STATE(494), 1, sym__path_component, - [20207] = 3, + [20208] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1613), 1, anon_sym_PIPE, STATE(739), 1, aux_sym_active_pattern_cases_repeat1, - [20217] = 2, + [20218] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1615), 2, anon_sym_COMMA, anon_sym_RBRACK, - [20225] = 2, + [20226] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1617), 2, sym__sep, ts_builtin_sym_end, - [20233] = 3, + [20234] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1494), 1, sym_identifier, STATE(743), 1, sym_extern_kwarg, - [20243] = 2, + [20244] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1405), 2, anon_sym_COMMA, anon_sym_RBRACE, - [20251] = 2, + [20252] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1619), 2, anon_sym_COMMA, anon_sym_RBRACE, - [20259] = 2, + [20260] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1353), 2, sym__sep, ts_builtin_sym_end, - [20267] = 2, + [20268] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1621), 2, sym__sep, ts_builtin_sym_end, - [20275] = 3, + [20276] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1623), 1, anon_sym_RPAREN, ACTIONS(1625), 1, anon_sym_COMMA, - [20285] = 2, + [20286] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1503), 2, anon_sym_COMMA, anon_sym_RBRACE, - [20293] = 2, + [20294] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1627), 2, anon_sym_else, anon_sym_elif, - [20301] = 3, + [20302] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1629), 1, anon_sym_LBRACE, ACTIONS(1631), 1, anon_sym_DOT, - [20311] = 2, + [20312] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1416), 2, anon_sym_COMMA, anon_sym_RBRACE, - [20319] = 3, + [20320] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(892), 1, sym_constructor_identifier, STATE(679), 1, sym_variant, - [20329] = 2, + [20330] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1633), 2, anon_sym_EQ, sym_identifier, - [20337] = 2, + [20338] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1635), 2, anon_sym_EQ, sym_identifier, - [20345] = 3, + [20346] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1637), 1, anon_sym_PIPE, STATE(739), 1, aux_sym_active_pattern_cases_repeat1, - [20355] = 3, + [20356] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1640), 1, - sym_integer, - ACTIONS(1642), 1, - sym_float, - [20365] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1644), 2, + ACTIONS(1640), 2, anon_sym_RPAREN, anon_sym_COMMA, - [20373] = 2, + [20364] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1642), 1, + sym_integer, + ACTIONS(1644), 1, + sym_float, + [20374] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1646), 2, sym__sep, ts_builtin_sym_end, - [20381] = 2, + [20382] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1418), 2, anon_sym_RPAREN, anon_sym_COMMA, - [20389] = 2, + [20390] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1648), 2, sym__dedent, sym__sep, - [20397] = 2, + [20398] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1650), 2, sym__sep, ts_builtin_sym_end, - [20405] = 2, + [20406] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1652), 2, sym__sep, ts_builtin_sym_end, - [20413] = 2, + [20414] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1294), 2, sym__sep, ts_builtin_sym_end, - [20421] = 3, + [20422] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1458), 1, sym_constructor_identifier, STATE(718), 1, sym_variant, - [20431] = 3, + [20432] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1654), 1, anon_sym_RPAREN, ACTIONS(1656), 1, anon_sym_COMMA, - [20441] = 3, + [20442] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(776), 1, sym_constructor_identifier, STATE(490), 1, sym__type_identifier, - [20451] = 2, + [20452] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1658), 2, anon_sym_COMMA, anon_sym_RBRACE, - [20459] = 2, + [20460] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1660), 2, sym__sep, ts_builtin_sym_end, - [20467] = 3, + [20468] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1662), 1, sym_identifier, STATE(830), 1, sym_field_declaration, - [20477] = 2, + [20478] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1664), 2, sym_identifier, sym_constructor_identifier, - [20485] = 2, + [20486] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1666), 2, sym__sep, ts_builtin_sym_end, - [20493] = 2, + [20494] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1102), 2, anon_sym_COMMA, anon_sym_RBRACK, - [20501] = 2, + [20502] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1668), 2, anon_sym_RPAREN, anon_sym_COMMA, - [20509] = 2, + [20510] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1670), 2, sym__sep, ts_builtin_sym_end, - [20517] = 2, + [20518] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1660), 2, sym__sep, ts_builtin_sym_end, - [20525] = 2, + [20526] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1660), 2, sym__sep, ts_builtin_sym_end, - [20533] = 2, + [20534] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1672), 2, sym__sep, ts_builtin_sym_end, - [20541] = 2, + [20542] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1674), 2, sym__sep, ts_builtin_sym_end, - [20549] = 3, + [20550] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1676), 1, sym_identifier, STATE(775), 1, sym_field_update, - [20559] = 2, + [20560] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1678), 2, anon_sym_COMMA, anon_sym_RBRACE, - [20567] = 3, + [20568] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1680), 1, sym_identifier, STATE(732), 1, sym_field_initializer, - [20577] = 3, + [20578] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1682), 1, anon_sym_RPAREN, ACTIONS(1684), 1, anon_sym_COMMA, - [20587] = 2, + [20588] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1559), 2, anon_sym_EQ, anon_sym_DOT, - [20595] = 2, + [20596] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1686), 2, sym__sep, ts_builtin_sym_end, - [20603] = 2, + [20604] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1621), 2, sym__dedent, sym__sep, - [20611] = 2, + [20612] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1688), 2, sym__sep, ts_builtin_sym_end, - [20619] = 2, + [20620] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1690), 2, sym__dedent, sym__sep, - [20627] = 2, + [20628] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1470), 2, anon_sym_EQ, sym_identifier, - [20635] = 3, + [20636] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1692), 1, anon_sym_RPAREN, ACTIONS(1694), 1, anon_sym_COMMA, - [20645] = 2, + [20646] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1690), 2, sym__sep, ts_builtin_sym_end, - [20653] = 2, + [20654] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1567), 2, anon_sym_COMMA, anon_sym_RBRACE, - [20661] = 3, + [20662] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1696), 1, anon_sym_PIPE, STATE(723), 1, aux_sym_active_pattern_cases_repeat1, - [20671] = 3, + [20672] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1056), 1, anon_sym_case, STATE(642), 1, sym_case_clause, - [20681] = 2, + [20682] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1698), 2, anon_sym_COMMA, anon_sym_RBRACE, - [20689] = 2, + [20690] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1648), 2, sym__sep, ts_builtin_sym_end, - [20697] = 3, + [20698] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1700), 1, anon_sym_RPAREN, ACTIONS(1702), 1, anon_sym_COMMA, - [20707] = 3, + [20708] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(782), 1, sym_constructor_identifier, STATE(556), 1, sym__type_identifier, - [20717] = 2, + [20718] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1704), 2, sym__sep, ts_builtin_sym_end, - [20725] = 2, + [20726] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1706), 2, sym__sep, ts_builtin_sym_end, - [20733] = 2, + [20734] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(575), 2, sym__sep, ts_builtin_sym_end, - [20741] = 3, + [20742] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1676), 1, sym_identifier, STATE(648), 1, sym_field_update, - [20751] = 2, + [20752] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1708), 2, sym_identifier, sym_constructor_identifier, - [20759] = 2, + [20760] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1710), 2, sym__sep, ts_builtin_sym_end, - [20767] = 2, + [20768] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1712), 2, sym__sep, ts_builtin_sym_end, - [20775] = 2, + [20776] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1714), 2, anon_sym_else, anon_sym_elif, - [20783] = 3, + [20784] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1716), 1, sym_constructor_identifier, STATE(846), 1, sym__module_identifier, - [20793] = 2, + [20794] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1718), 2, sym__sep, ts_builtin_sym_end, - [20801] = 3, + [20802] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1720), 1, sym_identifier, STATE(735), 1, sym_field_pattern, - [20811] = 2, + [20812] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1646), 2, sym__dedent, sym__sep, - [20819] = 2, + [20820] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1722), 2, sym__sep, ts_builtin_sym_end, - [20827] = 3, + [20828] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1458), 1, sym_constructor_identifier, STATE(573), 1, sym_variant, - [20837] = 3, + [20838] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(892), 1, sym_constructor_identifier, STATE(509), 1, sym_variant, - [20847] = 3, + [20848] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1662), 1, sym_identifier, STATE(629), 1, sym_field_declaration, - [20857] = 3, + [20858] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1056), 1, anon_sym_case, STATE(835), 1, sym_case_clause, - [20867] = 3, + [20868] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1724), 1, anon_sym_RPAREN, ACTIONS(1726), 1, anon_sym_COMMA, - [20877] = 2, + [20878] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1728), 2, sym_wildcard, sym_identifier, - [20885] = 3, + [20886] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1480), 1, anon_sym_GT, ACTIONS(1730), 1, anon_sym_SLASH, - [20895] = 3, + [20896] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1680), 1, sym_identifier, STATE(651), 1, sym_field_initializer, - [20905] = 3, + [20906] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1676), 1, sym_identifier, STATE(653), 1, sym_field_update, - [20915] = 2, + [20916] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1732), 2, sym__sep, ts_builtin_sym_end, - [20923] = 3, + [20924] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1720), 1, sym_identifier, STATE(600), 1, sym_field_pattern, - [20933] = 3, + [20934] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1056), 1, anon_sym_case, STATE(659), 1, sym_case_clause, - [20943] = 2, + [20944] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1734), 2, sym__sep, ts_builtin_sym_end, - [20951] = 3, + [20952] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1736), 1, anon_sym_RPAREN, ACTIONS(1738), 1, anon_sym_COMMA, - [20961] = 3, + [20962] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1680), 1, sym_identifier, STATE(676), 1, sym_field_initializer, - [20971] = 3, + [20972] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1676), 1, sym_identifier, STATE(678), 1, sym_field_update, - [20981] = 2, + [20982] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1740), 2, sym_identifier, sym_constructor_identifier, - [20989] = 3, + [20990] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1742), 1, anon_sym_EQ, ACTIONS(1744), 1, anon_sym_RBRACE, - [20999] = 3, + [21000] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1680), 1, sym_identifier, STATE(640), 1, sym_field_initializer, - [21009] = 3, + [21010] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1056), 1, anon_sym_case, STATE(588), 1, sym_case_clause, - [21019] = 2, + [21020] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1746), 2, anon_sym_EQ, sym_identifier, - [21027] = 3, + [21028] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1748), 1, sym_constructor_identifier, STATE(807), 1, sym__module_identifier, - [21037] = 2, + [21038] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1750), 2, sym_identifier, sym_constructor_identifier, - [21045] = 3, + [21046] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1680), 1, sym_identifier, STATE(698), 1, sym_field_initializer, - [21055] = 2, + [21056] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1599), 2, sym__dedent, sym__sep, - [21063] = 3, + [21064] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1676), 1, sym_identifier, STATE(700), 1, sym_field_update, - [21073] = 3, + [21074] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(782), 1, sym_constructor_identifier, STATE(533), 1, sym__type_identifier, - [21083] = 2, + [21084] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1752), 2, sym__sep, ts_builtin_sym_end, - [21091] = 3, + [21092] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1631), 1, anon_sym_DOT, ACTIONS(1754), 1, anon_sym_LBRACE, - [21101] = 3, + [21102] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1458), 1, sym_constructor_identifier, STATE(606), 1, sym_variant, - [21111] = 2, + [21112] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1756), 2, anon_sym_EQ, sym_identifier, - [21119] = 3, + [21120] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(135), 1, sym__indent, STATE(762), 1, sym__block, - [21129] = 3, + [21130] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1631), 1, anon_sym_DOT, ACTIONS(1758), 1, anon_sym_LBRACE, - [21139] = 2, + [21140] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1760), 2, anon_sym_COMMA, anon_sym_RBRACE, - [21147] = 3, + [21148] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1631), 1, anon_sym_DOT, ACTIONS(1762), 1, anon_sym_LBRACE, - [21157] = 2, + [21158] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1607), 2, anon_sym_COMMA, anon_sym_RBRACE, - [21165] = 2, + [21166] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1764), 2, sym__sep, ts_builtin_sym_end, - [21173] = 2, + [21174] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1393), 2, anon_sym_RPAREN, anon_sym_COMMA, - [21181] = 2, + [21182] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1766), 2, anon_sym_COMMA, anon_sym_RBRACE, - [21189] = 2, + [21190] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1768), 2, sym__sep, ts_builtin_sym_end, - [21197] = 2, + [21198] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1770), 2, sym__dedent, sym__sep, - [21205] = 2, + [21206] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1772), 1, anon_sym_then, - [21212] = 2, + [21213] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1774), 1, sym_identifier, - [21219] = 2, + [21220] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1776), 1, anon_sym_COLON, - [21226] = 2, + [21227] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(575), 1, anon_sym_EQ, - [21233] = 2, + [21234] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(424), 1, anon_sym_RPAREN, - [21240] = 2, + [21241] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1778), 1, anon_sym_EQ, - [21247] = 2, + [21248] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(428), 1, anon_sym_RPAREN, - [21254] = 2, + [21255] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1780), 1, anon_sym_then, - [21261] = 2, + [21262] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1782), 1, anon_sym_RPAREN, - [21268] = 2, + [21269] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1784), 1, anon_sym_GT, - [21275] = 2, + [21276] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1786), 1, anon_sym_EQ, - [21282] = 2, + [21283] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1788), 1, anon_sym_PIPE, - [21289] = 2, + [21290] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1790), 1, anon_sym_type, - [21296] = 2, + [21297] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1792), 1, anon_sym_COLON, - [21303] = 2, + [21304] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1794), 1, ts_builtin_sym_end, - [21310] = 2, + [21311] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1796), 1, sym_integer, - [21317] = 2, + [21318] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1798), 1, sym_identifier, - [21324] = 2, + [21325] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1800), 1, sym_identifier, - [21331] = 2, + [21332] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1629), 1, anon_sym_LBRACE, - [21338] = 2, + [21339] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1802), 1, sym_identifier, - [21345] = 2, + [21346] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1804), 1, anon_sym_COLON, - [21352] = 2, + [21353] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1806), 1, anon_sym_COLON, - [21359] = 2, + [21360] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1808), 1, sym_integer, - [21366] = 2, + [21367] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1810), 1, anon_sym_RPAREN, - [21373] = 2, + [21374] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1812), 1, anon_sym_GT, - [21380] = 2, + [21381] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1814), 1, anon_sym_GT, - [21387] = 2, + [21388] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1816), 1, sym_constructor_identifier, - [21394] = 2, + [21395] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1818), 1, anon_sym_PIPE, - [21401] = 2, + [21402] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1820), 1, sym_identifier, - [21408] = 2, + [21409] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1822), 1, anon_sym_COLON, - [21415] = 2, + [21416] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1824), 1, anon_sym_EQ, - [21422] = 2, + [21423] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1826), 1, anon_sym_COLON, - [21429] = 2, + [21430] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1828), 1, sym_integer, - [21436] = 2, + [21437] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1830), 1, anon_sym_COLON, - [21443] = 2, + [21444] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1832), 1, anon_sym_RBRACE, - [21450] = 2, + [21451] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1834), 1, anon_sym_COLON, - [21457] = 2, + [21458] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1754), 1, anon_sym_LBRACE, - [21464] = 2, + [21465] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1836), 1, anon_sym_with, - [21471] = 2, + [21472] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1838), 1, anon_sym_LBRACE, - [21478] = 2, + [21479] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1840), 1, anon_sym_with, - [21485] = 2, + [21486] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1842), 1, anon_sym_then, - [21492] = 2, + [21493] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1844), 1, sym_constructor_identifier, - [21499] = 2, + [21500] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1846), 1, anon_sym_GT, - [21506] = 2, + [21507] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1631), 1, anon_sym_DOT, - [21513] = 2, + [21514] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1848), 1, anon_sym_COLON, - [21520] = 2, + [21521] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1850), 1, anon_sym_COLON, - [21527] = 2, + [21528] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1758), 1, anon_sym_LBRACE, - [21534] = 2, + [21535] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1852), 1, sym_identifier, - [21541] = 2, + [21542] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1854), 1, anon_sym_LBRACE, - [21548] = 2, + [21549] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1856), 1, anon_sym_with, - [21555] = 2, + [21556] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1858), 1, anon_sym_then, - [21562] = 2, + [21563] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1860), 1, anon_sym_COLON, - [21569] = 2, + [21570] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1762), 1, anon_sym_LBRACE, - [21576] = 2, + [21577] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1862), 1, anon_sym_PIPE, - [21583] = 2, + [21584] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1864), 1, anon_sym_LBRACE, - [21590] = 2, + [21591] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1866), 1, anon_sym_with, - [21597] = 2, + [21598] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1868), 1, anon_sym_then, - [21604] = 2, + [21605] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(426), 1, anon_sym_RPAREN, - [21611] = 2, + [21612] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1870), 1, anon_sym_PIPE, - [21618] = 2, + [21619] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1872), 1, anon_sym_EQ, - [21625] = 2, + [21626] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(430), 1, anon_sym_RPAREN, - [21632] = 2, + [21633] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1874), 1, anon_sym_EQ, - [21639] = 2, + [21640] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1876), 1, anon_sym_LBRACE, - [21646] = 2, + [21647] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1341), 1, @@ -31126,519 +31150,519 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(384)] = 15197, [SMALL_STATE(385)] = 15224, [SMALL_STATE(386)] = 15251, - [SMALL_STATE(387)] = 15278, - [SMALL_STATE(388)] = 15305, - [SMALL_STATE(389)] = 15332, - [SMALL_STATE(390)] = 15359, - [SMALL_STATE(391)] = 15386, - [SMALL_STATE(392)] = 15413, - [SMALL_STATE(393)] = 15440, - [SMALL_STATE(394)] = 15467, - [SMALL_STATE(395)] = 15494, - [SMALL_STATE(396)] = 15519, - [SMALL_STATE(397)] = 15544, - [SMALL_STATE(398)] = 15571, - [SMALL_STATE(399)] = 15598, - [SMALL_STATE(400)] = 15625, - [SMALL_STATE(401)] = 15645, - [SMALL_STATE(402)] = 15673, - [SMALL_STATE(403)] = 15693, - [SMALL_STATE(404)] = 15711, - [SMALL_STATE(405)] = 15728, - [SMALL_STATE(406)] = 15745, - [SMALL_STATE(407)] = 15760, - [SMALL_STATE(408)] = 15777, - [SMALL_STATE(409)] = 15792, - [SMALL_STATE(410)] = 15807, - [SMALL_STATE(411)] = 15822, - [SMALL_STATE(412)] = 15837, - [SMALL_STATE(413)] = 15852, - [SMALL_STATE(414)] = 15869, - [SMALL_STATE(415)] = 15883, - [SMALL_STATE(416)] = 15897, - [SMALL_STATE(417)] = 15921, - [SMALL_STATE(418)] = 15935, - [SMALL_STATE(419)] = 15949, - [SMALL_STATE(420)] = 15965, - [SMALL_STATE(421)] = 15989, - [SMALL_STATE(422)] = 16005, - [SMALL_STATE(423)] = 16021, - [SMALL_STATE(424)] = 16035, - [SMALL_STATE(425)] = 16051, - [SMALL_STATE(426)] = 16079, - [SMALL_STATE(427)] = 16101, - [SMALL_STATE(428)] = 16115, - [SMALL_STATE(429)] = 16129, - [SMALL_STATE(430)] = 16143, - [SMALL_STATE(431)] = 16159, - [SMALL_STATE(432)] = 16175, - [SMALL_STATE(433)] = 16191, - [SMALL_STATE(434)] = 16205, - [SMALL_STATE(435)] = 16221, - [SMALL_STATE(436)] = 16237, - [SMALL_STATE(437)] = 16251, - [SMALL_STATE(438)] = 16272, - [SMALL_STATE(439)] = 16293, - [SMALL_STATE(440)] = 16316, - [SMALL_STATE(441)] = 16339, - [SMALL_STATE(442)] = 16352, - [SMALL_STATE(443)] = 16375, - [SMALL_STATE(444)] = 16388, - [SMALL_STATE(445)] = 16409, - [SMALL_STATE(446)] = 16422, - [SMALL_STATE(447)] = 16439, - [SMALL_STATE(448)] = 16462, - [SMALL_STATE(449)] = 16483, - [SMALL_STATE(450)] = 16506, - [SMALL_STATE(451)] = 16523, - [SMALL_STATE(452)] = 16536, - [SMALL_STATE(453)] = 16549, - [SMALL_STATE(454)] = 16572, - [SMALL_STATE(455)] = 16590, - [SMALL_STATE(456)] = 16612, - [SMALL_STATE(457)] = 16630, - [SMALL_STATE(458)] = 16644, - [SMALL_STATE(459)] = 16656, - [SMALL_STATE(460)] = 16668, - [SMALL_STATE(461)] = 16690, - [SMALL_STATE(462)] = 16702, - [SMALL_STATE(463)] = 16720, - [SMALL_STATE(464)] = 16732, - [SMALL_STATE(465)] = 16750, - [SMALL_STATE(466)] = 16768, - [SMALL_STATE(467)] = 16786, - [SMALL_STATE(468)] = 16806, - [SMALL_STATE(469)] = 16826, - [SMALL_STATE(470)] = 16844, - [SMALL_STATE(471)] = 16860, - [SMALL_STATE(472)] = 16872, - [SMALL_STATE(473)] = 16884, - [SMALL_STATE(474)] = 16898, - [SMALL_STATE(475)] = 16916, - [SMALL_STATE(476)] = 16934, - [SMALL_STATE(477)] = 16946, - [SMALL_STATE(478)] = 16962, - [SMALL_STATE(479)] = 16976, - [SMALL_STATE(480)] = 16992, - [SMALL_STATE(481)] = 17007, - [SMALL_STATE(482)] = 17024, - [SMALL_STATE(483)] = 17041, - [SMALL_STATE(484)] = 17058, - [SMALL_STATE(485)] = 17075, - [SMALL_STATE(486)] = 17090, - [SMALL_STATE(487)] = 17107, - [SMALL_STATE(488)] = 17124, - [SMALL_STATE(489)] = 17141, - [SMALL_STATE(490)] = 17156, - [SMALL_STATE(491)] = 17173, - [SMALL_STATE(492)] = 17192, - [SMALL_STATE(493)] = 17209, - [SMALL_STATE(494)] = 17222, - [SMALL_STATE(495)] = 17233, - [SMALL_STATE(496)] = 17248, - [SMALL_STATE(497)] = 17259, - [SMALL_STATE(498)] = 17276, - [SMALL_STATE(499)] = 17293, - [SMALL_STATE(500)] = 17304, - [SMALL_STATE(501)] = 17321, - [SMALL_STATE(502)] = 17340, - [SMALL_STATE(503)] = 17356, - [SMALL_STATE(504)] = 17370, - [SMALL_STATE(505)] = 17386, - [SMALL_STATE(506)] = 17402, - [SMALL_STATE(507)] = 17418, - [SMALL_STATE(508)] = 17432, - [SMALL_STATE(509)] = 17446, - [SMALL_STATE(510)] = 17460, - [SMALL_STATE(511)] = 17476, - [SMALL_STATE(512)] = 17492, - [SMALL_STATE(513)] = 17506, - [SMALL_STATE(514)] = 17520, - [SMALL_STATE(515)] = 17532, - [SMALL_STATE(516)] = 17548, - [SMALL_STATE(517)] = 17560, - [SMALL_STATE(518)] = 17576, - [SMALL_STATE(519)] = 17592, - [SMALL_STATE(520)] = 17608, - [SMALL_STATE(521)] = 17624, - [SMALL_STATE(522)] = 17640, - [SMALL_STATE(523)] = 17654, - [SMALL_STATE(524)] = 17670, - [SMALL_STATE(525)] = 17686, - [SMALL_STATE(526)] = 17700, - [SMALL_STATE(527)] = 17716, - [SMALL_STATE(528)] = 17732, - [SMALL_STATE(529)] = 17748, - [SMALL_STATE(530)] = 17762, - [SMALL_STATE(531)] = 17776, - [SMALL_STATE(532)] = 17790, - [SMALL_STATE(533)] = 17804, - [SMALL_STATE(534)] = 17820, - [SMALL_STATE(535)] = 17836, - [SMALL_STATE(536)] = 17850, - [SMALL_STATE(537)] = 17864, - [SMALL_STATE(538)] = 17878, - [SMALL_STATE(539)] = 17894, - [SMALL_STATE(540)] = 17906, - [SMALL_STATE(541)] = 17922, - [SMALL_STATE(542)] = 17938, - [SMALL_STATE(543)] = 17952, - [SMALL_STATE(544)] = 17968, - [SMALL_STATE(545)] = 17984, - [SMALL_STATE(546)] = 18000, - [SMALL_STATE(547)] = 18016, - [SMALL_STATE(548)] = 18030, - [SMALL_STATE(549)] = 18044, - [SMALL_STATE(550)] = 18058, - [SMALL_STATE(551)] = 18072, - [SMALL_STATE(552)] = 18086, - [SMALL_STATE(553)] = 18100, - [SMALL_STATE(554)] = 18114, - [SMALL_STATE(555)] = 18124, - [SMALL_STATE(556)] = 18140, - [SMALL_STATE(557)] = 18156, - [SMALL_STATE(558)] = 18172, - [SMALL_STATE(559)] = 18186, - [SMALL_STATE(560)] = 18198, - [SMALL_STATE(561)] = 18212, - [SMALL_STATE(562)] = 18224, - [SMALL_STATE(563)] = 18240, - [SMALL_STATE(564)] = 18256, - [SMALL_STATE(565)] = 18272, - [SMALL_STATE(566)] = 18288, - [SMALL_STATE(567)] = 18302, - [SMALL_STATE(568)] = 18316, - [SMALL_STATE(569)] = 18332, - [SMALL_STATE(570)] = 18344, - [SMALL_STATE(571)] = 18360, - [SMALL_STATE(572)] = 18376, - [SMALL_STATE(573)] = 18392, - [SMALL_STATE(574)] = 18408, - [SMALL_STATE(575)] = 18424, - [SMALL_STATE(576)] = 18438, - [SMALL_STATE(577)] = 18452, - [SMALL_STATE(578)] = 18464, - [SMALL_STATE(579)] = 18480, - [SMALL_STATE(580)] = 18496, - [SMALL_STATE(581)] = 18512, - [SMALL_STATE(582)] = 18526, - [SMALL_STATE(583)] = 18540, - [SMALL_STATE(584)] = 18552, - [SMALL_STATE(585)] = 18568, - [SMALL_STATE(586)] = 18582, - [SMALL_STATE(587)] = 18598, - [SMALL_STATE(588)] = 18612, - [SMALL_STATE(589)] = 18625, - [SMALL_STATE(590)] = 18638, - [SMALL_STATE(591)] = 18647, - [SMALL_STATE(592)] = 18656, - [SMALL_STATE(593)] = 18665, - [SMALL_STATE(594)] = 18678, - [SMALL_STATE(595)] = 18687, - [SMALL_STATE(596)] = 18700, - [SMALL_STATE(597)] = 18713, - [SMALL_STATE(598)] = 18722, - [SMALL_STATE(599)] = 18735, - [SMALL_STATE(600)] = 18746, - [SMALL_STATE(601)] = 18759, - [SMALL_STATE(602)] = 18772, - [SMALL_STATE(603)] = 18785, - [SMALL_STATE(604)] = 18794, - [SMALL_STATE(605)] = 18803, - [SMALL_STATE(606)] = 18812, - [SMALL_STATE(607)] = 18821, - [SMALL_STATE(608)] = 18834, - [SMALL_STATE(609)] = 18847, - [SMALL_STATE(610)] = 18860, - [SMALL_STATE(611)] = 18869, - [SMALL_STATE(612)] = 18878, - [SMALL_STATE(613)] = 18891, - [SMALL_STATE(614)] = 18900, - [SMALL_STATE(615)] = 18909, - [SMALL_STATE(616)] = 18922, - [SMALL_STATE(617)] = 18931, - [SMALL_STATE(618)] = 18940, - [SMALL_STATE(619)] = 18949, - [SMALL_STATE(620)] = 18958, - [SMALL_STATE(621)] = 18967, - [SMALL_STATE(622)] = 18980, - [SMALL_STATE(623)] = 18993, - [SMALL_STATE(624)] = 19002, - [SMALL_STATE(625)] = 19015, - [SMALL_STATE(626)] = 19028, - [SMALL_STATE(627)] = 19041, - [SMALL_STATE(628)] = 19050, - [SMALL_STATE(629)] = 19063, - [SMALL_STATE(630)] = 19076, - [SMALL_STATE(631)] = 19089, - [SMALL_STATE(632)] = 19102, - [SMALL_STATE(633)] = 19111, - [SMALL_STATE(634)] = 19124, - [SMALL_STATE(635)] = 19137, - [SMALL_STATE(636)] = 19150, - [SMALL_STATE(637)] = 19159, - [SMALL_STATE(638)] = 19172, - [SMALL_STATE(639)] = 19185, - [SMALL_STATE(640)] = 19196, - [SMALL_STATE(641)] = 19209, - [SMALL_STATE(642)] = 19222, - [SMALL_STATE(643)] = 19235, - [SMALL_STATE(644)] = 19246, - [SMALL_STATE(645)] = 19259, - [SMALL_STATE(646)] = 19272, - [SMALL_STATE(647)] = 19285, - [SMALL_STATE(648)] = 19298, - [SMALL_STATE(649)] = 19311, - [SMALL_STATE(650)] = 19324, - [SMALL_STATE(651)] = 19333, - [SMALL_STATE(652)] = 19346, - [SMALL_STATE(653)] = 19359, - [SMALL_STATE(654)] = 19372, - [SMALL_STATE(655)] = 19383, - [SMALL_STATE(656)] = 19396, - [SMALL_STATE(657)] = 19409, - [SMALL_STATE(658)] = 19422, - [SMALL_STATE(659)] = 19435, - [SMALL_STATE(660)] = 19448, - [SMALL_STATE(661)] = 19461, - [SMALL_STATE(662)] = 19474, - [SMALL_STATE(663)] = 19487, - [SMALL_STATE(664)] = 19500, - [SMALL_STATE(665)] = 19513, - [SMALL_STATE(666)] = 19526, - [SMALL_STATE(667)] = 19539, - [SMALL_STATE(668)] = 19548, - [SMALL_STATE(669)] = 19561, - [SMALL_STATE(670)] = 19574, - [SMALL_STATE(671)] = 19585, - [SMALL_STATE(672)] = 19598, - [SMALL_STATE(673)] = 19611, - [SMALL_STATE(674)] = 19624, - [SMALL_STATE(675)] = 19637, - [SMALL_STATE(676)] = 19650, - [SMALL_STATE(677)] = 19663, - [SMALL_STATE(678)] = 19676, - [SMALL_STATE(679)] = 19689, - [SMALL_STATE(680)] = 19698, - [SMALL_STATE(681)] = 19711, - [SMALL_STATE(682)] = 19724, - [SMALL_STATE(683)] = 19737, - [SMALL_STATE(684)] = 19750, - [SMALL_STATE(685)] = 19759, - [SMALL_STATE(686)] = 19772, - [SMALL_STATE(687)] = 19785, - [SMALL_STATE(688)] = 19798, - [SMALL_STATE(689)] = 19811, - [SMALL_STATE(690)] = 19824, - [SMALL_STATE(691)] = 19837, - [SMALL_STATE(692)] = 19846, - [SMALL_STATE(693)] = 19859, - [SMALL_STATE(694)] = 19872, - [SMALL_STATE(695)] = 19885, - [SMALL_STATE(696)] = 19894, - [SMALL_STATE(697)] = 19903, - [SMALL_STATE(698)] = 19916, - [SMALL_STATE(699)] = 19929, - [SMALL_STATE(700)] = 19942, - [SMALL_STATE(701)] = 19955, - [SMALL_STATE(702)] = 19964, - [SMALL_STATE(703)] = 19977, - [SMALL_STATE(704)] = 19990, - [SMALL_STATE(705)] = 20003, - [SMALL_STATE(706)] = 20016, - [SMALL_STATE(707)] = 20027, - [SMALL_STATE(708)] = 20036, - [SMALL_STATE(709)] = 20045, - [SMALL_STATE(710)] = 20058, - [SMALL_STATE(711)] = 20071, - [SMALL_STATE(712)] = 20084, - [SMALL_STATE(713)] = 20093, - [SMALL_STATE(714)] = 20106, - [SMALL_STATE(715)] = 20115, - [SMALL_STATE(716)] = 20128, - [SMALL_STATE(717)] = 20137, - [SMALL_STATE(718)] = 20150, - [SMALL_STATE(719)] = 20159, - [SMALL_STATE(720)] = 20168, - [SMALL_STATE(721)] = 20181, - [SMALL_STATE(722)] = 20194, - [SMALL_STATE(723)] = 20207, - [SMALL_STATE(724)] = 20217, - [SMALL_STATE(725)] = 20225, - [SMALL_STATE(726)] = 20233, - [SMALL_STATE(727)] = 20243, - [SMALL_STATE(728)] = 20251, - [SMALL_STATE(729)] = 20259, - [SMALL_STATE(730)] = 20267, - [SMALL_STATE(731)] = 20275, - [SMALL_STATE(732)] = 20285, - [SMALL_STATE(733)] = 20293, - [SMALL_STATE(734)] = 20301, - [SMALL_STATE(735)] = 20311, - [SMALL_STATE(736)] = 20319, - [SMALL_STATE(737)] = 20329, - [SMALL_STATE(738)] = 20337, - [SMALL_STATE(739)] = 20345, - [SMALL_STATE(740)] = 20355, - [SMALL_STATE(741)] = 20365, - [SMALL_STATE(742)] = 20373, - [SMALL_STATE(743)] = 20381, - [SMALL_STATE(744)] = 20389, - [SMALL_STATE(745)] = 20397, - [SMALL_STATE(746)] = 20405, - [SMALL_STATE(747)] = 20413, - [SMALL_STATE(748)] = 20421, - [SMALL_STATE(749)] = 20431, - [SMALL_STATE(750)] = 20441, - [SMALL_STATE(751)] = 20451, - [SMALL_STATE(752)] = 20459, - [SMALL_STATE(753)] = 20467, - [SMALL_STATE(754)] = 20477, - [SMALL_STATE(755)] = 20485, - [SMALL_STATE(756)] = 20493, - [SMALL_STATE(757)] = 20501, - [SMALL_STATE(758)] = 20509, - [SMALL_STATE(759)] = 20517, - [SMALL_STATE(760)] = 20525, - [SMALL_STATE(761)] = 20533, - [SMALL_STATE(762)] = 20541, - [SMALL_STATE(763)] = 20549, - [SMALL_STATE(764)] = 20559, - [SMALL_STATE(765)] = 20567, - [SMALL_STATE(766)] = 20577, - [SMALL_STATE(767)] = 20587, - [SMALL_STATE(768)] = 20595, - [SMALL_STATE(769)] = 20603, - [SMALL_STATE(770)] = 20611, - [SMALL_STATE(771)] = 20619, - [SMALL_STATE(772)] = 20627, - [SMALL_STATE(773)] = 20635, - [SMALL_STATE(774)] = 20645, - [SMALL_STATE(775)] = 20653, - [SMALL_STATE(776)] = 20661, - [SMALL_STATE(777)] = 20671, - [SMALL_STATE(778)] = 20681, - [SMALL_STATE(779)] = 20689, - [SMALL_STATE(780)] = 20697, - [SMALL_STATE(781)] = 20707, - [SMALL_STATE(782)] = 20717, - [SMALL_STATE(783)] = 20725, - [SMALL_STATE(784)] = 20733, - [SMALL_STATE(785)] = 20741, - [SMALL_STATE(786)] = 20751, - [SMALL_STATE(787)] = 20759, - [SMALL_STATE(788)] = 20767, - [SMALL_STATE(789)] = 20775, - [SMALL_STATE(790)] = 20783, - [SMALL_STATE(791)] = 20793, - [SMALL_STATE(792)] = 20801, - [SMALL_STATE(793)] = 20811, - [SMALL_STATE(794)] = 20819, - [SMALL_STATE(795)] = 20827, - [SMALL_STATE(796)] = 20837, - [SMALL_STATE(797)] = 20847, - [SMALL_STATE(798)] = 20857, - [SMALL_STATE(799)] = 20867, - [SMALL_STATE(800)] = 20877, - [SMALL_STATE(801)] = 20885, - [SMALL_STATE(802)] = 20895, - [SMALL_STATE(803)] = 20905, - [SMALL_STATE(804)] = 20915, - [SMALL_STATE(805)] = 20923, - [SMALL_STATE(806)] = 20933, - [SMALL_STATE(807)] = 20943, - [SMALL_STATE(808)] = 20951, - [SMALL_STATE(809)] = 20961, - [SMALL_STATE(810)] = 20971, - [SMALL_STATE(811)] = 20981, - [SMALL_STATE(812)] = 20989, - [SMALL_STATE(813)] = 20999, - [SMALL_STATE(814)] = 21009, - [SMALL_STATE(815)] = 21019, - [SMALL_STATE(816)] = 21027, - [SMALL_STATE(817)] = 21037, - [SMALL_STATE(818)] = 21045, - [SMALL_STATE(819)] = 21055, - [SMALL_STATE(820)] = 21063, - [SMALL_STATE(821)] = 21073, - [SMALL_STATE(822)] = 21083, - [SMALL_STATE(823)] = 21091, - [SMALL_STATE(824)] = 21101, - [SMALL_STATE(825)] = 21111, - [SMALL_STATE(826)] = 21119, - [SMALL_STATE(827)] = 21129, - [SMALL_STATE(828)] = 21139, - [SMALL_STATE(829)] = 21147, - [SMALL_STATE(830)] = 21157, - [SMALL_STATE(831)] = 21165, - [SMALL_STATE(832)] = 21173, - [SMALL_STATE(833)] = 21181, - [SMALL_STATE(834)] = 21189, - [SMALL_STATE(835)] = 21197, - [SMALL_STATE(836)] = 21205, - [SMALL_STATE(837)] = 21212, - [SMALL_STATE(838)] = 21219, - [SMALL_STATE(839)] = 21226, - [SMALL_STATE(840)] = 21233, - [SMALL_STATE(841)] = 21240, - [SMALL_STATE(842)] = 21247, - [SMALL_STATE(843)] = 21254, - [SMALL_STATE(844)] = 21261, - [SMALL_STATE(845)] = 21268, - [SMALL_STATE(846)] = 21275, - [SMALL_STATE(847)] = 21282, - [SMALL_STATE(848)] = 21289, - [SMALL_STATE(849)] = 21296, - [SMALL_STATE(850)] = 21303, - [SMALL_STATE(851)] = 21310, - [SMALL_STATE(852)] = 21317, - [SMALL_STATE(853)] = 21324, - [SMALL_STATE(854)] = 21331, - [SMALL_STATE(855)] = 21338, - [SMALL_STATE(856)] = 21345, - [SMALL_STATE(857)] = 21352, - [SMALL_STATE(858)] = 21359, - [SMALL_STATE(859)] = 21366, - [SMALL_STATE(860)] = 21373, - [SMALL_STATE(861)] = 21380, - [SMALL_STATE(862)] = 21387, - [SMALL_STATE(863)] = 21394, - [SMALL_STATE(864)] = 21401, - [SMALL_STATE(865)] = 21408, - [SMALL_STATE(866)] = 21415, - [SMALL_STATE(867)] = 21422, - [SMALL_STATE(868)] = 21429, - [SMALL_STATE(869)] = 21436, - [SMALL_STATE(870)] = 21443, - [SMALL_STATE(871)] = 21450, - [SMALL_STATE(872)] = 21457, - [SMALL_STATE(873)] = 21464, - [SMALL_STATE(874)] = 21471, - [SMALL_STATE(875)] = 21478, - [SMALL_STATE(876)] = 21485, - [SMALL_STATE(877)] = 21492, - [SMALL_STATE(878)] = 21499, - [SMALL_STATE(879)] = 21506, - [SMALL_STATE(880)] = 21513, - [SMALL_STATE(881)] = 21520, - [SMALL_STATE(882)] = 21527, - [SMALL_STATE(883)] = 21534, - [SMALL_STATE(884)] = 21541, - [SMALL_STATE(885)] = 21548, - [SMALL_STATE(886)] = 21555, - [SMALL_STATE(887)] = 21562, - [SMALL_STATE(888)] = 21569, - [SMALL_STATE(889)] = 21576, - [SMALL_STATE(890)] = 21583, - [SMALL_STATE(891)] = 21590, - [SMALL_STATE(892)] = 21597, - [SMALL_STATE(893)] = 21604, - [SMALL_STATE(894)] = 21611, - [SMALL_STATE(895)] = 21618, - [SMALL_STATE(896)] = 21625, - [SMALL_STATE(897)] = 21632, - [SMALL_STATE(898)] = 21639, - [SMALL_STATE(899)] = 21646, + [SMALL_STATE(387)] = 15280, + [SMALL_STATE(388)] = 15307, + [SMALL_STATE(389)] = 15334, + [SMALL_STATE(390)] = 15361, + [SMALL_STATE(391)] = 15388, + [SMALL_STATE(392)] = 15415, + [SMALL_STATE(393)] = 15442, + [SMALL_STATE(394)] = 15469, + [SMALL_STATE(395)] = 15496, + [SMALL_STATE(396)] = 15523, + [SMALL_STATE(397)] = 15548, + [SMALL_STATE(398)] = 15573, + [SMALL_STATE(399)] = 15600, + [SMALL_STATE(400)] = 15627, + [SMALL_STATE(401)] = 15654, + [SMALL_STATE(402)] = 15674, + [SMALL_STATE(403)] = 15692, + [SMALL_STATE(404)] = 15712, + [SMALL_STATE(405)] = 15729, + [SMALL_STATE(406)] = 15744, + [SMALL_STATE(407)] = 15761, + [SMALL_STATE(408)] = 15776, + [SMALL_STATE(409)] = 15791, + [SMALL_STATE(410)] = 15806, + [SMALL_STATE(411)] = 15823, + [SMALL_STATE(412)] = 15840, + [SMALL_STATE(413)] = 15855, + [SMALL_STATE(414)] = 15870, + [SMALL_STATE(415)] = 15884, + [SMALL_STATE(416)] = 15898, + [SMALL_STATE(417)] = 15922, + [SMALL_STATE(418)] = 15936, + [SMALL_STATE(419)] = 15950, + [SMALL_STATE(420)] = 15966, + [SMALL_STATE(421)] = 15990, + [SMALL_STATE(422)] = 16006, + [SMALL_STATE(423)] = 16022, + [SMALL_STATE(424)] = 16036, + [SMALL_STATE(425)] = 16052, + [SMALL_STATE(426)] = 16080, + [SMALL_STATE(427)] = 16102, + [SMALL_STATE(428)] = 16116, + [SMALL_STATE(429)] = 16130, + [SMALL_STATE(430)] = 16144, + [SMALL_STATE(431)] = 16160, + [SMALL_STATE(432)] = 16176, + [SMALL_STATE(433)] = 16192, + [SMALL_STATE(434)] = 16206, + [SMALL_STATE(435)] = 16222, + [SMALL_STATE(436)] = 16238, + [SMALL_STATE(437)] = 16252, + [SMALL_STATE(438)] = 16273, + [SMALL_STATE(439)] = 16294, + [SMALL_STATE(440)] = 16317, + [SMALL_STATE(441)] = 16340, + [SMALL_STATE(442)] = 16353, + [SMALL_STATE(443)] = 16376, + [SMALL_STATE(444)] = 16389, + [SMALL_STATE(445)] = 16410, + [SMALL_STATE(446)] = 16423, + [SMALL_STATE(447)] = 16440, + [SMALL_STATE(448)] = 16463, + [SMALL_STATE(449)] = 16484, + [SMALL_STATE(450)] = 16507, + [SMALL_STATE(451)] = 16524, + [SMALL_STATE(452)] = 16537, + [SMALL_STATE(453)] = 16550, + [SMALL_STATE(454)] = 16573, + [SMALL_STATE(455)] = 16591, + [SMALL_STATE(456)] = 16613, + [SMALL_STATE(457)] = 16631, + [SMALL_STATE(458)] = 16645, + [SMALL_STATE(459)] = 16657, + [SMALL_STATE(460)] = 16669, + [SMALL_STATE(461)] = 16691, + [SMALL_STATE(462)] = 16703, + [SMALL_STATE(463)] = 16721, + [SMALL_STATE(464)] = 16733, + [SMALL_STATE(465)] = 16751, + [SMALL_STATE(466)] = 16769, + [SMALL_STATE(467)] = 16787, + [SMALL_STATE(468)] = 16807, + [SMALL_STATE(469)] = 16827, + [SMALL_STATE(470)] = 16845, + [SMALL_STATE(471)] = 16861, + [SMALL_STATE(472)] = 16873, + [SMALL_STATE(473)] = 16885, + [SMALL_STATE(474)] = 16899, + [SMALL_STATE(475)] = 16917, + [SMALL_STATE(476)] = 16935, + [SMALL_STATE(477)] = 16947, + [SMALL_STATE(478)] = 16963, + [SMALL_STATE(479)] = 16977, + [SMALL_STATE(480)] = 16993, + [SMALL_STATE(481)] = 17008, + [SMALL_STATE(482)] = 17025, + [SMALL_STATE(483)] = 17042, + [SMALL_STATE(484)] = 17059, + [SMALL_STATE(485)] = 17076, + [SMALL_STATE(486)] = 17091, + [SMALL_STATE(487)] = 17108, + [SMALL_STATE(488)] = 17125, + [SMALL_STATE(489)] = 17142, + [SMALL_STATE(490)] = 17157, + [SMALL_STATE(491)] = 17174, + [SMALL_STATE(492)] = 17193, + [SMALL_STATE(493)] = 17210, + [SMALL_STATE(494)] = 17223, + [SMALL_STATE(495)] = 17234, + [SMALL_STATE(496)] = 17249, + [SMALL_STATE(497)] = 17260, + [SMALL_STATE(498)] = 17277, + [SMALL_STATE(499)] = 17294, + [SMALL_STATE(500)] = 17305, + [SMALL_STATE(501)] = 17322, + [SMALL_STATE(502)] = 17341, + [SMALL_STATE(503)] = 17357, + [SMALL_STATE(504)] = 17371, + [SMALL_STATE(505)] = 17387, + [SMALL_STATE(506)] = 17403, + [SMALL_STATE(507)] = 17419, + [SMALL_STATE(508)] = 17433, + [SMALL_STATE(509)] = 17447, + [SMALL_STATE(510)] = 17461, + [SMALL_STATE(511)] = 17477, + [SMALL_STATE(512)] = 17493, + [SMALL_STATE(513)] = 17507, + [SMALL_STATE(514)] = 17521, + [SMALL_STATE(515)] = 17533, + [SMALL_STATE(516)] = 17549, + [SMALL_STATE(517)] = 17561, + [SMALL_STATE(518)] = 17577, + [SMALL_STATE(519)] = 17593, + [SMALL_STATE(520)] = 17609, + [SMALL_STATE(521)] = 17625, + [SMALL_STATE(522)] = 17641, + [SMALL_STATE(523)] = 17655, + [SMALL_STATE(524)] = 17671, + [SMALL_STATE(525)] = 17687, + [SMALL_STATE(526)] = 17701, + [SMALL_STATE(527)] = 17717, + [SMALL_STATE(528)] = 17733, + [SMALL_STATE(529)] = 17749, + [SMALL_STATE(530)] = 17763, + [SMALL_STATE(531)] = 17777, + [SMALL_STATE(532)] = 17791, + [SMALL_STATE(533)] = 17805, + [SMALL_STATE(534)] = 17821, + [SMALL_STATE(535)] = 17837, + [SMALL_STATE(536)] = 17851, + [SMALL_STATE(537)] = 17865, + [SMALL_STATE(538)] = 17879, + [SMALL_STATE(539)] = 17895, + [SMALL_STATE(540)] = 17907, + [SMALL_STATE(541)] = 17923, + [SMALL_STATE(542)] = 17939, + [SMALL_STATE(543)] = 17953, + [SMALL_STATE(544)] = 17969, + [SMALL_STATE(545)] = 17985, + [SMALL_STATE(546)] = 18001, + [SMALL_STATE(547)] = 18017, + [SMALL_STATE(548)] = 18031, + [SMALL_STATE(549)] = 18045, + [SMALL_STATE(550)] = 18059, + [SMALL_STATE(551)] = 18073, + [SMALL_STATE(552)] = 18087, + [SMALL_STATE(553)] = 18101, + [SMALL_STATE(554)] = 18115, + [SMALL_STATE(555)] = 18125, + [SMALL_STATE(556)] = 18141, + [SMALL_STATE(557)] = 18157, + [SMALL_STATE(558)] = 18173, + [SMALL_STATE(559)] = 18187, + [SMALL_STATE(560)] = 18199, + [SMALL_STATE(561)] = 18213, + [SMALL_STATE(562)] = 18225, + [SMALL_STATE(563)] = 18241, + [SMALL_STATE(564)] = 18257, + [SMALL_STATE(565)] = 18273, + [SMALL_STATE(566)] = 18289, + [SMALL_STATE(567)] = 18303, + [SMALL_STATE(568)] = 18317, + [SMALL_STATE(569)] = 18333, + [SMALL_STATE(570)] = 18345, + [SMALL_STATE(571)] = 18361, + [SMALL_STATE(572)] = 18377, + [SMALL_STATE(573)] = 18393, + [SMALL_STATE(574)] = 18409, + [SMALL_STATE(575)] = 18425, + [SMALL_STATE(576)] = 18439, + [SMALL_STATE(577)] = 18453, + [SMALL_STATE(578)] = 18465, + [SMALL_STATE(579)] = 18481, + [SMALL_STATE(580)] = 18497, + [SMALL_STATE(581)] = 18513, + [SMALL_STATE(582)] = 18527, + [SMALL_STATE(583)] = 18541, + [SMALL_STATE(584)] = 18553, + [SMALL_STATE(585)] = 18569, + [SMALL_STATE(586)] = 18583, + [SMALL_STATE(587)] = 18599, + [SMALL_STATE(588)] = 18613, + [SMALL_STATE(589)] = 18626, + [SMALL_STATE(590)] = 18639, + [SMALL_STATE(591)] = 18648, + [SMALL_STATE(592)] = 18657, + [SMALL_STATE(593)] = 18666, + [SMALL_STATE(594)] = 18679, + [SMALL_STATE(595)] = 18688, + [SMALL_STATE(596)] = 18701, + [SMALL_STATE(597)] = 18714, + [SMALL_STATE(598)] = 18723, + [SMALL_STATE(599)] = 18736, + [SMALL_STATE(600)] = 18747, + [SMALL_STATE(601)] = 18760, + [SMALL_STATE(602)] = 18773, + [SMALL_STATE(603)] = 18786, + [SMALL_STATE(604)] = 18795, + [SMALL_STATE(605)] = 18804, + [SMALL_STATE(606)] = 18813, + [SMALL_STATE(607)] = 18822, + [SMALL_STATE(608)] = 18835, + [SMALL_STATE(609)] = 18848, + [SMALL_STATE(610)] = 18861, + [SMALL_STATE(611)] = 18870, + [SMALL_STATE(612)] = 18879, + [SMALL_STATE(613)] = 18892, + [SMALL_STATE(614)] = 18901, + [SMALL_STATE(615)] = 18910, + [SMALL_STATE(616)] = 18923, + [SMALL_STATE(617)] = 18932, + [SMALL_STATE(618)] = 18941, + [SMALL_STATE(619)] = 18950, + [SMALL_STATE(620)] = 18959, + [SMALL_STATE(621)] = 18968, + [SMALL_STATE(622)] = 18981, + [SMALL_STATE(623)] = 18994, + [SMALL_STATE(624)] = 19003, + [SMALL_STATE(625)] = 19016, + [SMALL_STATE(626)] = 19029, + [SMALL_STATE(627)] = 19042, + [SMALL_STATE(628)] = 19051, + [SMALL_STATE(629)] = 19064, + [SMALL_STATE(630)] = 19077, + [SMALL_STATE(631)] = 19090, + [SMALL_STATE(632)] = 19103, + [SMALL_STATE(633)] = 19112, + [SMALL_STATE(634)] = 19125, + [SMALL_STATE(635)] = 19138, + [SMALL_STATE(636)] = 19151, + [SMALL_STATE(637)] = 19160, + [SMALL_STATE(638)] = 19173, + [SMALL_STATE(639)] = 19186, + [SMALL_STATE(640)] = 19197, + [SMALL_STATE(641)] = 19210, + [SMALL_STATE(642)] = 19223, + [SMALL_STATE(643)] = 19236, + [SMALL_STATE(644)] = 19247, + [SMALL_STATE(645)] = 19260, + [SMALL_STATE(646)] = 19273, + [SMALL_STATE(647)] = 19286, + [SMALL_STATE(648)] = 19299, + [SMALL_STATE(649)] = 19312, + [SMALL_STATE(650)] = 19325, + [SMALL_STATE(651)] = 19334, + [SMALL_STATE(652)] = 19347, + [SMALL_STATE(653)] = 19360, + [SMALL_STATE(654)] = 19373, + [SMALL_STATE(655)] = 19384, + [SMALL_STATE(656)] = 19397, + [SMALL_STATE(657)] = 19410, + [SMALL_STATE(658)] = 19423, + [SMALL_STATE(659)] = 19436, + [SMALL_STATE(660)] = 19449, + [SMALL_STATE(661)] = 19462, + [SMALL_STATE(662)] = 19475, + [SMALL_STATE(663)] = 19488, + [SMALL_STATE(664)] = 19501, + [SMALL_STATE(665)] = 19514, + [SMALL_STATE(666)] = 19527, + [SMALL_STATE(667)] = 19540, + [SMALL_STATE(668)] = 19549, + [SMALL_STATE(669)] = 19562, + [SMALL_STATE(670)] = 19575, + [SMALL_STATE(671)] = 19586, + [SMALL_STATE(672)] = 19599, + [SMALL_STATE(673)] = 19612, + [SMALL_STATE(674)] = 19625, + [SMALL_STATE(675)] = 19638, + [SMALL_STATE(676)] = 19651, + [SMALL_STATE(677)] = 19664, + [SMALL_STATE(678)] = 19677, + [SMALL_STATE(679)] = 19690, + [SMALL_STATE(680)] = 19699, + [SMALL_STATE(681)] = 19712, + [SMALL_STATE(682)] = 19725, + [SMALL_STATE(683)] = 19738, + [SMALL_STATE(684)] = 19751, + [SMALL_STATE(685)] = 19760, + [SMALL_STATE(686)] = 19773, + [SMALL_STATE(687)] = 19786, + [SMALL_STATE(688)] = 19799, + [SMALL_STATE(689)] = 19812, + [SMALL_STATE(690)] = 19825, + [SMALL_STATE(691)] = 19838, + [SMALL_STATE(692)] = 19847, + [SMALL_STATE(693)] = 19860, + [SMALL_STATE(694)] = 19873, + [SMALL_STATE(695)] = 19886, + [SMALL_STATE(696)] = 19895, + [SMALL_STATE(697)] = 19904, + [SMALL_STATE(698)] = 19917, + [SMALL_STATE(699)] = 19930, + [SMALL_STATE(700)] = 19943, + [SMALL_STATE(701)] = 19956, + [SMALL_STATE(702)] = 19965, + [SMALL_STATE(703)] = 19978, + [SMALL_STATE(704)] = 19991, + [SMALL_STATE(705)] = 20004, + [SMALL_STATE(706)] = 20017, + [SMALL_STATE(707)] = 20028, + [SMALL_STATE(708)] = 20037, + [SMALL_STATE(709)] = 20046, + [SMALL_STATE(710)] = 20059, + [SMALL_STATE(711)] = 20072, + [SMALL_STATE(712)] = 20085, + [SMALL_STATE(713)] = 20094, + [SMALL_STATE(714)] = 20107, + [SMALL_STATE(715)] = 20116, + [SMALL_STATE(716)] = 20129, + [SMALL_STATE(717)] = 20138, + [SMALL_STATE(718)] = 20151, + [SMALL_STATE(719)] = 20160, + [SMALL_STATE(720)] = 20169, + [SMALL_STATE(721)] = 20182, + [SMALL_STATE(722)] = 20195, + [SMALL_STATE(723)] = 20208, + [SMALL_STATE(724)] = 20218, + [SMALL_STATE(725)] = 20226, + [SMALL_STATE(726)] = 20234, + [SMALL_STATE(727)] = 20244, + [SMALL_STATE(728)] = 20252, + [SMALL_STATE(729)] = 20260, + [SMALL_STATE(730)] = 20268, + [SMALL_STATE(731)] = 20276, + [SMALL_STATE(732)] = 20286, + [SMALL_STATE(733)] = 20294, + [SMALL_STATE(734)] = 20302, + [SMALL_STATE(735)] = 20312, + [SMALL_STATE(736)] = 20320, + [SMALL_STATE(737)] = 20330, + [SMALL_STATE(738)] = 20338, + [SMALL_STATE(739)] = 20346, + [SMALL_STATE(740)] = 20356, + [SMALL_STATE(741)] = 20364, + [SMALL_STATE(742)] = 20374, + [SMALL_STATE(743)] = 20382, + [SMALL_STATE(744)] = 20390, + [SMALL_STATE(745)] = 20398, + [SMALL_STATE(746)] = 20406, + [SMALL_STATE(747)] = 20414, + [SMALL_STATE(748)] = 20422, + [SMALL_STATE(749)] = 20432, + [SMALL_STATE(750)] = 20442, + [SMALL_STATE(751)] = 20452, + [SMALL_STATE(752)] = 20460, + [SMALL_STATE(753)] = 20468, + [SMALL_STATE(754)] = 20478, + [SMALL_STATE(755)] = 20486, + [SMALL_STATE(756)] = 20494, + [SMALL_STATE(757)] = 20502, + [SMALL_STATE(758)] = 20510, + [SMALL_STATE(759)] = 20518, + [SMALL_STATE(760)] = 20526, + [SMALL_STATE(761)] = 20534, + [SMALL_STATE(762)] = 20542, + [SMALL_STATE(763)] = 20550, + [SMALL_STATE(764)] = 20560, + [SMALL_STATE(765)] = 20568, + [SMALL_STATE(766)] = 20578, + [SMALL_STATE(767)] = 20588, + [SMALL_STATE(768)] = 20596, + [SMALL_STATE(769)] = 20604, + [SMALL_STATE(770)] = 20612, + [SMALL_STATE(771)] = 20620, + [SMALL_STATE(772)] = 20628, + [SMALL_STATE(773)] = 20636, + [SMALL_STATE(774)] = 20646, + [SMALL_STATE(775)] = 20654, + [SMALL_STATE(776)] = 20662, + [SMALL_STATE(777)] = 20672, + [SMALL_STATE(778)] = 20682, + [SMALL_STATE(779)] = 20690, + [SMALL_STATE(780)] = 20698, + [SMALL_STATE(781)] = 20708, + [SMALL_STATE(782)] = 20718, + [SMALL_STATE(783)] = 20726, + [SMALL_STATE(784)] = 20734, + [SMALL_STATE(785)] = 20742, + [SMALL_STATE(786)] = 20752, + [SMALL_STATE(787)] = 20760, + [SMALL_STATE(788)] = 20768, + [SMALL_STATE(789)] = 20776, + [SMALL_STATE(790)] = 20784, + [SMALL_STATE(791)] = 20794, + [SMALL_STATE(792)] = 20802, + [SMALL_STATE(793)] = 20812, + [SMALL_STATE(794)] = 20820, + [SMALL_STATE(795)] = 20828, + [SMALL_STATE(796)] = 20838, + [SMALL_STATE(797)] = 20848, + [SMALL_STATE(798)] = 20858, + [SMALL_STATE(799)] = 20868, + [SMALL_STATE(800)] = 20878, + [SMALL_STATE(801)] = 20886, + [SMALL_STATE(802)] = 20896, + [SMALL_STATE(803)] = 20906, + [SMALL_STATE(804)] = 20916, + [SMALL_STATE(805)] = 20924, + [SMALL_STATE(806)] = 20934, + [SMALL_STATE(807)] = 20944, + [SMALL_STATE(808)] = 20952, + [SMALL_STATE(809)] = 20962, + [SMALL_STATE(810)] = 20972, + [SMALL_STATE(811)] = 20982, + [SMALL_STATE(812)] = 20990, + [SMALL_STATE(813)] = 21000, + [SMALL_STATE(814)] = 21010, + [SMALL_STATE(815)] = 21020, + [SMALL_STATE(816)] = 21028, + [SMALL_STATE(817)] = 21038, + [SMALL_STATE(818)] = 21046, + [SMALL_STATE(819)] = 21056, + [SMALL_STATE(820)] = 21064, + [SMALL_STATE(821)] = 21074, + [SMALL_STATE(822)] = 21084, + [SMALL_STATE(823)] = 21092, + [SMALL_STATE(824)] = 21102, + [SMALL_STATE(825)] = 21112, + [SMALL_STATE(826)] = 21120, + [SMALL_STATE(827)] = 21130, + [SMALL_STATE(828)] = 21140, + [SMALL_STATE(829)] = 21148, + [SMALL_STATE(830)] = 21158, + [SMALL_STATE(831)] = 21166, + [SMALL_STATE(832)] = 21174, + [SMALL_STATE(833)] = 21182, + [SMALL_STATE(834)] = 21190, + [SMALL_STATE(835)] = 21198, + [SMALL_STATE(836)] = 21206, + [SMALL_STATE(837)] = 21213, + [SMALL_STATE(838)] = 21220, + [SMALL_STATE(839)] = 21227, + [SMALL_STATE(840)] = 21234, + [SMALL_STATE(841)] = 21241, + [SMALL_STATE(842)] = 21248, + [SMALL_STATE(843)] = 21255, + [SMALL_STATE(844)] = 21262, + [SMALL_STATE(845)] = 21269, + [SMALL_STATE(846)] = 21276, + [SMALL_STATE(847)] = 21283, + [SMALL_STATE(848)] = 21290, + [SMALL_STATE(849)] = 21297, + [SMALL_STATE(850)] = 21304, + [SMALL_STATE(851)] = 21311, + [SMALL_STATE(852)] = 21318, + [SMALL_STATE(853)] = 21325, + [SMALL_STATE(854)] = 21332, + [SMALL_STATE(855)] = 21339, + [SMALL_STATE(856)] = 21346, + [SMALL_STATE(857)] = 21353, + [SMALL_STATE(858)] = 21360, + [SMALL_STATE(859)] = 21367, + [SMALL_STATE(860)] = 21374, + [SMALL_STATE(861)] = 21381, + [SMALL_STATE(862)] = 21388, + [SMALL_STATE(863)] = 21395, + [SMALL_STATE(864)] = 21402, + [SMALL_STATE(865)] = 21409, + [SMALL_STATE(866)] = 21416, + [SMALL_STATE(867)] = 21423, + [SMALL_STATE(868)] = 21430, + [SMALL_STATE(869)] = 21437, + [SMALL_STATE(870)] = 21444, + [SMALL_STATE(871)] = 21451, + [SMALL_STATE(872)] = 21458, + [SMALL_STATE(873)] = 21465, + [SMALL_STATE(874)] = 21472, + [SMALL_STATE(875)] = 21479, + [SMALL_STATE(876)] = 21486, + [SMALL_STATE(877)] = 21493, + [SMALL_STATE(878)] = 21500, + [SMALL_STATE(879)] = 21507, + [SMALL_STATE(880)] = 21514, + [SMALL_STATE(881)] = 21521, + [SMALL_STATE(882)] = 21528, + [SMALL_STATE(883)] = 21535, + [SMALL_STATE(884)] = 21542, + [SMALL_STATE(885)] = 21549, + [SMALL_STATE(886)] = 21556, + [SMALL_STATE(887)] = 21563, + [SMALL_STATE(888)] = 21570, + [SMALL_STATE(889)] = 21577, + [SMALL_STATE(890)] = 21584, + [SMALL_STATE(891)] = 21591, + [SMALL_STATE(892)] = 21598, + [SMALL_STATE(893)] = 21605, + [SMALL_STATE(894)] = 21612, + [SMALL_STATE(895)] = 21619, + [SMALL_STATE(896)] = 21626, + [SMALL_STATE(897)] = 21633, + [SMALL_STATE(898)] = 21640, + [SMALL_STATE(899)] = 21647, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -32019,11 +32043,11 @@ static const TSParseActionEntry ts_parse_actions[] = { [766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pipe_expression, 3, 0, 15), [768] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__compose_expression, 1, 0, 0), [770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), - [772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), + [772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), [774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), [776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429), [778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), - [780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), + [780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), [782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428), [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat2, 2, 0, 42), [786] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat2, 2, 0, 42), SHIFT_REPEAT(288), @@ -32037,33 +32061,33 @@ static const TSParseActionEntry ts_parse_actions[] = { [803] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pipe_expression, 3, 0, 15), [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_atom, 1, 0, 0), [807] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), SHIFT_REPEAT(417), - [810] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), SHIFT_REPEAT(389), + [810] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), SHIFT_REPEAT(390), [813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), [815] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), SHIFT_REPEAT(428), [818] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), SHIFT_REPEAT(418), - [821] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), SHIFT_REPEAT(388), + [821] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), SHIFT_REPEAT(389), [824] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_application_repeat1, 2, 0, 51), SHIFT_REPEAT(429), [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(459), - [829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), + [829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(394), [831] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 1, 0, 19), [833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(463), [835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant, 2, 0, 32), - [837] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(459), - [840] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(393), - [843] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), - [845] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(463), - [848] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 0, 25), - [850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), - [852] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat2, 2, 0, 42), - [854] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat2, 2, 0, 42), SHIFT_REPEAT(292), - [857] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(418), - [860] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(388), - [863] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(429), - [866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), - [868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), - [870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [872] = {.entry = {.count = 1, .reusable = false}}, SHIFT(741), - [874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(741), + [837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), + [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(741), + [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [843] = {.entry = {.count = 1, .reusable = false}}, SHIFT(740), + [845] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(459), + [848] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(394), + [851] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), + [853] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(463), + [856] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 0, 25), + [858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [860] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_expression_repeat2, 2, 0, 42), + [862] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat2, 2, 0, 42), SHIFT_REPEAT(292), + [865] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(418), + [868] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(389), + [871] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_repeat1, 2, 0, 49), SHIFT_REPEAT(429), + [874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), [876] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__path_component, 1, 0, 3), [878] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__path_component, 1, 0, 3), [880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), @@ -32072,7 +32096,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [886] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_type, 5, 0, 0), [888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(796), [890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(797), - [892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), + [892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), [894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), [896] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_variable, 1, 0, 8), [898] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ce_let, 4, 0, 4), @@ -32080,7 +32104,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_measure, 1, 0, 0), [904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(457), [906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), - [908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(403), + [908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402), [910] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ce_bind, 4, 0, 4), [912] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ce_bind, 4, 0, 4), [914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), @@ -32088,7 +32112,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), [920] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_measure_repeat1, 2, 0, 0), [922] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_measure_repeat1, 2, 0, 0), SHIFT_REPEAT(457), - [925] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_measure_repeat1, 2, 0, 0), SHIFT_REPEAT(403), + [925] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_measure_repeat1, 2, 0, 0), SHIFT_REPEAT(402), [928] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pattern, 1, 0, 0), [930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__type_identifier, 1, 0, 2), [932] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ce_do, 2, 0, 0), @@ -32236,7 +32260,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [1228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(560), [1230] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__variant_list, 1, 0, 0), [1232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), - [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399), + [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(400), [1236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), [1238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), [1240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interpolation, 4, 0, 43), @@ -32422,16 +32446,16 @@ static const TSParseActionEntry ts_parse_actions[] = { [1619] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_initializer, 3, 0, 44), [1621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_binding, 5, 0, 28), [1623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(443), - [1625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), + [1625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), [1627] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_elif_clause, 4, 0, 69), [1629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), [1631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(862), [1633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_active_pattern_cases, 7, 0, 45), [1635] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_active_pattern_cases, 5, 0, 45), [1637] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_active_pattern_cases_repeat1, 2, 0, 47), SHIFT_REPEAT(899), - [1640] = {.entry = {.count = 1, .reusable = false}}, SHIFT(757), - [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(757), - [1644] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_kwarg, 3, 0, 44), + [1640] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_kwarg, 3, 0, 44), + [1642] = {.entry = {.count = 1, .reusable = false}}, SHIFT(757), + [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(757), [1646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_binding, 6, 0, 48), [1648] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_binding, 4, 0, 17), [1650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_kwargs, 4, 0, 0), @@ -32451,7 +32475,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [1678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_update, 3, 0, 50), [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(866), [1682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(471), - [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(394), + [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(395), [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_active_pattern_definition, 5, 0, 29), [1688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_extern_import_declaration, 5, 0, 36), [1690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_binding, 5, 0, 30), @@ -32498,7 +32522,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [1772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(767), [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(381), - [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(401), + [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(825), [1784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), @@ -32511,8 +32535,8 @@ static const TSParseActionEntry ts_parse_actions[] = { [1798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), [1800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(436), [1802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(857), - [1804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(397), - [1806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), + [1804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398), + [1806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), [1808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(496), [1810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(737), [1812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), diff --git a/editors/tree-sitter-pyfun/test/corpus/items.txt b/editors/tree-sitter-pyfun/test/corpus/items.txt index 73bf47f..d67d3ff 100644 --- a/editors/tree-sitter-pyfun/test/corpus/items.txt +++ b/editors/tree-sitter-pyfun/test/corpus/items.txt @@ -190,6 +190,36 @@ extern pure loads : string -> Json = json.loads(strict=true, offset=-2, sep=", " (identifier) (string)))))) +================================================================================ +extern with a caller-supplied kwarg slot +================================================================================ + +extern openText : string -> string -> Seq string = builtins.open(mode="rt", encoding=...) + +-------------------------------------------------------------------------------- + +(source_file + (extern_declaration + (identifier) + (function_type + (type_variable) + (function_type + (type_variable) + (type_application + (type_identifier) + (type_variable)))) + (extern_target + (python_path + (identifier) + (identifier)) + (extern_kwargs + (extern_kwarg + (identifier) + (string)) + (extern_kwarg + (identifier) + (extern_slot)))))) + ================================================================================ extern import with alias ================================================================================ diff --git a/src/ast/mod.rs b/src/ast/mod.rs index f653b1a..b908ad4 100644 --- a/src/ast/mod.rs +++ b/src/ast/mod.rs @@ -218,6 +218,7 @@ fn print_extern_arg(arg: &ExternArg) -> String { ExternArg::Int(n) => n.to_string(), ExternArg::Float(f) => format!("{f:?}"), ExternArg::Bool(b) => b.to_string(), + ExternArg::Slot => "...".to_string(), } } diff --git a/src/lexer/mod.rs b/src/lexer/mod.rs index dfeb20a..c501a54 100644 --- a/src/lexer/mod.rs +++ b/src/lexer/mod.rs @@ -794,6 +794,13 @@ impl<'a> Lexer<'a> { self.push(Tok::PipeLeft, start); return Ok(()); } + // `...` — the `extern` kwarg slot marker, lexed before the single `.` so the + // three dots are one token (and `. . .` stays three). + if c == b'.' && self.peek2() == Some(b'.') && self.src.get(self.pos + 2) == Some(&b'.') { + self.pos += 3; + self.push(Tok::Ellipsis, start); + return Ok(()); + } // Two-char comparison / equality operators (checked before `=` `!` `<` `>`). if let Some(tok) = match (c, self.peek2()) { (b'=', Some(b'=')) => Some(Tok::EqEq), @@ -1148,6 +1155,37 @@ mod tests { assert_eq!(kinds("2.5"), vec![Tok::Float(2.5), Tok::Eof]); } + #[test] + fn lexes_ellipsis_as_one_token() { + // The `extern` kwarg slot marker is a single lexeme, so a dotted target's + // separate dots stay separate and spaced-out dots are not an ellipsis. + assert_eq!(kinds("..."), vec![Tok::Ellipsis, Tok::Eof]); + assert_eq!( + kinds("f(k=...)"), + vec![ + Tok::Ident("f".to_string()), + Tok::LParen, + Tok::Ident("k".to_string()), + Tok::Eq, + Tok::Ellipsis, + Tok::RParen, + Tok::Eof + ] + ); + assert_eq!(kinds(". . ."), vec![Tok::Dot, Tok::Dot, Tok::Dot, Tok::Eof]); + assert_eq!( + kinds("a.b.c"), + vec![ + Tok::Ident("a".to_string()), + Tok::Dot, + Tok::Ident("b".to_string()), + Tok::Dot, + Tok::Ident("c".to_string()), + Tok::Eof + ] + ); + } + #[test] fn lexes_reassignment_arrow() { assert_eq!( diff --git a/src/lexer/token.rs b/src/lexer/token.rs index 48e428f..3d7a27f 100644 --- a/src/lexer/token.rs +++ b/src/lexer/token.rs @@ -91,6 +91,11 @@ pub enum Tok { Comma, // , Colon, // : Dot, // . (record field access) + /// `...` — the caller-supplied slot marker in an `extern` target's keyword + /// arguments (`= requests.get(timeout = ...)`, `DESIGN.md` §6), spelled as in a + /// Python stub file. Lexed as one token so `. . .` is not the same thing, and + /// unused elsewhere in the grammar. + Ellipsis, Underscore, // _ /// A typed hole in expression position: `?` (anonymous) or `?name` (named, the diff --git a/src/lowering/mod.rs b/src/lowering/mod.rs index 20b5669..8af0c1d 100644 --- a/src/lowering/mod.rs +++ b/src/lowering/mod.rs @@ -231,11 +231,12 @@ struct Lowerer { /// Externs with a `unit` domain (`unit -> a`, e.g. `time.time`): a *nullary* /// Python callable, applied to `()` as a zero-argument call (`time.time()`). nullary_externs: HashSet, - /// `extern` name → its pinned Python keyword arguments (already lowered to their - /// `PyExpr` literals), appended to every emitted call (`open(path, - /// encoding="utf-8")`). Under-application routes them through - /// `functools.partial` so they are never dropped (`DESIGN.md` §6). - extern_kwargs: std::collections::HashMap>, + /// `extern` name → its Python keyword arguments (literals already lowered to + /// `PyExpr`, `...` slots left to be filled from the call), appended to every + /// emitted call (`open(path, encoding="utf-8")`). Under-application routes + /// literals through `functools.partial`, and anything with an unfilled slot + /// through a lambda, so nothing is ever dropped (`DESIGN.md` §6). + extern_kwargs: std::collections::HashMap>, /// Python modules an *used* extern needs imported (the first segment of a /// dotted target, e.g. `math` for `math.sqrt`). Bare builtins import nothing. needed_imports: BTreeSet, @@ -354,7 +355,7 @@ impl Lowerer { let mut extern_module_imports: Vec<(Vec, Option)> = Vec::new(); let mut receiver_externs = std::collections::HashMap::new(); let mut nullary_externs = HashSet::new(); - let mut extern_kwargs: std::collections::HashMap> = + let mut extern_kwargs: std::collections::HashMap> = std::collections::HashMap::new(); let mut user_defs = HashSet::new(); let mut top_fn_defs: HashMap, Expr)> = HashMap::new(); @@ -693,15 +694,15 @@ impl Lowerer { self.needed_imports.insert(module); } // A plain extern with pinned kwargs binds to a - // `functools.partial` that carries them; otherwise to the + // `functools.partial` that carries them (or, with a `...` + // slot, to a lambda that places it); otherwise to the // bare dotted target. if kwargs.is_empty() { dotted_path(&decl.target) } else { - self.build_call_kw( + self.build_call_kw_bare( dotted_path(&decl.target), Some(arrow_arity(&decl.ty)), - vec![], kwargs, ) } @@ -1669,7 +1670,15 @@ impl Lowerer { receiver_lambda(&member, arity.unwrap_or(1), kind, kwargs), )); } - let recv = arg_vals.remove(0); + let mut recv = arg_vals.remove(0); + let method_arity = arity.map(|k| k.saturating_sub(1)); + // An under-applied `...` slot puts the call inside a lambda, so the + // receiver must be bound out here to keep evaluating at application time. + let defers = + slot_count(&kwargs) > 0 && method_arity.is_some_and(|k| arg_vals.len() < k); + if defers { + recv = self.hoist_tmp(recv, &mut stmts); + } let accessed = attr_path(recv, &member); let result = match kind { // Property: `recv.text`; any further args are over-application calls. @@ -1677,16 +1686,19 @@ impl Lowerer { func: Box::new(f), args: vec![a], }), - // A method extern with pinned kwargs routes every arity through - // `build_call_kw` so the kwargs are appended (full/over) or carried - // by `functools.partial` (receiver-only / method-partial) — never lost. + // A method extern with kwargs routes every arity through + // `build_call_kw` so they are appended (full/over) or carried by + // `functools.partial` / a lambda (receiver-only, method-partial) — + // never lost. Receiver::Method if !kwargs.is_empty() => { - let method_arity = arity.map(|k| k.saturating_sub(1)); - self.build_call_kw(accessed, method_arity, arg_vals, kwargs) + let mut hoist = Vec::new(); + let call = + self.build_call_kw(accessed, method_arity, arg_vals, kwargs, &mut hoist); + stmts.extend(hoist); + call } Receiver::Method => { // The method itself takes one fewer argument than the arity. - let method_arity = arity.map(|k| k.saturating_sub(1)); if arg_vals.is_empty() { match method_arity { // A nullary method: call it now (`resp.read()`). @@ -1727,11 +1739,16 @@ impl Lowerer { // Drop the leading unit argument; call the target with no arguments // (plus any pinned kwargs, `time.time()` → `f(tz=…)`). let base = match self.extern_kwargs.get(name).cloned() { - Some(kwargs) => PyExpr::CallKw { - func: Box::new(dotted_path(&target)), - args: vec![], - kwargs, - }, + // A nullary extern has no argument to spare, so the parser rejects a + // `...` slot on one and these kwargs are all pinned literals. + Some(spec) => { + let (_, kwargs) = bind_kwargs(&spec, Vec::new()); + PyExpr::CallKw { + func: Box::new(dotted_path(&target)), + args: vec![], + kwargs, + } + } None => PyExpr::Call { func: Box::new(dotted_path(&target)), args: vec![], @@ -1748,11 +1765,12 @@ impl Lowerer { return Ok((stmts, result)); } - // A plain (non-receiver, non-nullary) extern that pins fixed Python kwargs: + // A plain (non-receiver, non-nullary) extern carrying Python kwargs: // `openText path` → `builtins.open(path, mode="rt", encoding="utf-8")`. - // Full/over-application appends the kwargs to the direct call; under- - // application carries them through `functools.partial` (`build_call_kw`), so - // a partial or bare reference never silently drops them (`DESIGN.md` §6). + // Full/over-application places them on the direct call, a `...` slot taking + // its value from the trailing arguments; under-application carries pinned + // literals through `functools.partial` and an unfilled slot through a lambda + // (`build_call_kw`), so nothing is ever silently dropped (`DESIGN.md` §6). if let ExprKind::Var(name) = &head.kind && !locals.contains(name) && !self.user_defs.contains(name) @@ -1770,7 +1788,10 @@ impl Lowerer { stmts.extend(arg_stmts); arg_vals.push(arg_val); } - let call = self.build_call_kw(dotted_path(&target), arity, arg_vals, kwargs); + let mut hoist = Vec::new(); + let call = + self.build_call_kw(dotted_path(&target), arity, arg_vals, kwargs, &mut hoist); + stmts.extend(hoist); return Ok((stmts, call)); } @@ -1954,17 +1975,18 @@ impl Lowerer { let kwargs = self.extern_kwargs.get(name).cloned().unwrap_or_default(); return nullary_lambda(&target, kwargs); } - // A bare reference to a plain extern that pins kwargs carries them via + // A bare reference to a plain extern carrying kwargs keeps them via // `functools.partial` (`openText` → `functools.partial(builtins.open, - // mode="rt", encoding="utf-8")`), so the kwargs survive later - // application. Applied references are handled in `lower_application`. + // mode="rt", encoding="utf-8")`), or via a lambda when a `...` slot has + // yet to be filled, so they survive later application. Applied + // references are handled in `lower_application`. if let Some(kwargs) = self.extern_kwargs.get(name).cloned() { let target = self.extern_targets[name].clone(); if let Some(module) = self.extern_import_spec(&target) { self.needed_imports.insert(module); } let arity = self.arities.get(name).copied(); - return self.build_call_kw(dotted_path(&target), arity, vec![], kwargs); + return self.build_call_kw_bare(dotted_path(&target), arity, kwargs); } // An `extern` reference lowers to its dotted Python target (e.g. // `math.sqrt`), recording any module that must be imported. @@ -3123,61 +3145,123 @@ impl Lowerer { } } - /// Like [`Self::build_call`] but for an `extern` whose target pins fixed Python - /// keyword arguments. The pinned `kwargs` ride along at every arity: - /// full/over-application appends them to the direct call (`f(a, kw=v)`); under- - /// application hands them to `functools.partial` (`functools.partial(f, a, - /// kw=v)`), so a later application supplies the remaining positional arguments - /// and the kwargs are never dropped. + /// Like [`Self::build_call`] but for an `extern` whose target carries Python + /// keyword arguments. The `spec` rides along at every arity, so nothing is ever + /// dropped: full/over-application emits the direct call (`f(a, kw=v)`), and + /// under-application either hands the pinned literals to `functools.partial` + /// (`functools.partial(f, a, kw=v)`) or, when a `...` slot is still unfilled, + /// closes over a lambda that takes the remaining arguments. + /// + /// Any statements needed to keep the already-supplied arguments evaluating at + /// application time (rather than inside a lambda body) are pushed onto `hoist`. fn build_call_kw( &mut self, head: PyExpr, arity: Option, args: Vec, - kwargs: Vec<(String, PyExpr)>, + spec: Vec<(String, KwSource)>, + hoist: &mut Vec, ) -> PyExpr { let n = args.len(); - match arity { - Some(k) if n < k => { + let slots = slot_count(&spec); + // An unknown arity is treated as n-ary, but it still has to leave room for + // the slots, so a bare reference to a slot extern becomes a lambda. + let k = arity.unwrap_or(n.max(slots)); + if n < k { + if slots == 0 { // Partial application: `functools.partial` carries the positional // args *and* the pinned keyword args. self.needs_functools = true; let mut partial_args = Vec::with_capacity(n + 1); partial_args.push(head); partial_args.extend(args); - PyExpr::CallKw { + let (_, kwargs) = bind_kwargs(&spec, Vec::new()); + return PyExpr::CallKw { func: Box::new(PyExpr::Attribute { value: Box::new(PyExpr::Name("functools".to_string())), attr: "partial".to_string(), }), args: partial_args, kwargs, - } + }; } - Some(k) if n > k => { - // Over-application: full (kw-carrying) call, then apply the rest. - let mut rest = args; - let first = rest.drain(..k).collect(); - let mut call = PyExpr::CallKw { + // `functools.partial` cannot carry a keyword whose value has not arrived, + // so a slot extern's partial application is a lambda over the missing + // arguments. Bind what was supplied first, so it evaluates now — exactly + // when `functools.partial` would have evaluated it. + let bound: Vec = args.into_iter().map(|a| self.hoist_tmp(a, hoist)).collect(); + let params: Vec = (0..k - n).map(|i| format!("_pf_k{i}")).collect(); + let mut all = bound; + all.extend(params.iter().cloned().map(PyExpr::Name)); + let (positional, kwargs) = bind_kwargs(&spec, all); + return PyExpr::Lambda { + params, + body: Box::new(PyExpr::CallKw { func: Box::new(head), - args: first, + args: positional, kwargs, - }; - for extra in rest { - call = PyExpr::Call { - func: Box::new(call), - args: vec![extra], - }; - } - call - } - // Exact arity, or unknown arity (treated as n-ary). - _ => PyExpr::CallKw { + }), + }; + } + if n > k { + // Over-application: full (kw-carrying) call, then apply the rest. + let mut rest = args; + let first: Vec = rest.drain(..k).collect(); + let (positional, kwargs) = bind_kwargs(&spec, first); + let mut call = PyExpr::CallKw { func: Box::new(head), - args, + args: positional, kwargs, - }, + }; + for extra in rest { + call = PyExpr::Call { + func: Box::new(call), + args: vec![extra], + }; + } + return call; + } + let (positional, kwargs) = bind_kwargs(&spec, args); + PyExpr::CallKw { + func: Box::new(head), + args: positional, + kwargs, + } + } + + /// [`Self::build_call_kw`] for a reference that supplies no arguments, and so + /// has nothing to hoist. + fn build_call_kw_bare( + &mut self, + head: PyExpr, + arity: Option, + spec: Vec<(String, KwSource)>, + ) -> PyExpr { + let mut hoist = Vec::new(); + let call = self.build_call_kw(head, arity, Vec::new(), spec, &mut hoist); + debug_assert!( + hoist.is_empty(), + "a bare reference supplies no arguments to hoist" + ); + call + } + + /// Bind `value` to a fresh temporary (pushed onto `hoist`) so that placing it + /// inside a lambda body does not defer its evaluation. A literal is already + /// stable and is returned unchanged. + fn hoist_tmp(&mut self, value: PyExpr, hoist: &mut Vec) -> PyExpr { + if matches!( + value, + PyExpr::Str(_) | PyExpr::Int(_) | PyExpr::Float(_) | PyExpr::Bool(_) + ) { + return value; } + let tmp = self.fresh_tmp(); + hoist.push(PyStmt::Assign { + target: tmp.clone(), + value, + }); + PyExpr::Name(tmp) } fn fresh_tmp(&mut self) -> String { @@ -3278,17 +3362,59 @@ const PY_BUILTIN_TYPES: &[&str] = &[ /// Lower a pinned `extern` keyword-argument literal to its Python IR expression. /// A negative int/float is emitted as a `Neg` of the magnitude, matching how the /// emitter renders unary minus (`compresslevel=-1`). -fn lower_extern_arg(arg: &ExternArg) -> PyExpr { +fn lower_extern_arg(arg: &ExternArg) -> KwSource { match arg { - ExternArg::Str(s) => PyExpr::Str(s.clone()), - ExternArg::Int(n) if *n < 0 => PyExpr::Neg(Box::new(PyExpr::Int(-n))), - ExternArg::Int(n) => PyExpr::Int(*n), - ExternArg::Float(f) if *f < 0.0 => PyExpr::Neg(Box::new(PyExpr::Float(-f))), - ExternArg::Float(f) => PyExpr::Float(*f), - ExternArg::Bool(b) => PyExpr::Bool(*b), + ExternArg::Str(s) => KwSource::Lit(PyExpr::Str(s.clone())), + ExternArg::Int(n) if *n < 0 => KwSource::Lit(PyExpr::Neg(Box::new(PyExpr::Int(-n)))), + ExternArg::Int(n) => KwSource::Lit(PyExpr::Int(*n)), + ExternArg::Float(f) if *f < 0.0 => KwSource::Lit(PyExpr::Neg(Box::new(PyExpr::Float(-f)))), + ExternArg::Float(f) => KwSource::Lit(PyExpr::Float(*f)), + ExternArg::Bool(b) => KwSource::Lit(PyExpr::Bool(*b)), + ExternArg::Slot => KwSource::Slot, } } +/// Where an `extern` target's keyword argument gets its value: a literal pinned at +/// the declaration, or a `...` slot filled from the call's arguments +/// (`DESIGN.md` §6). +#[derive(Debug, Clone, PartialEq)] +enum KwSource { + Lit(PyExpr), + Slot, +} + +/// How many of an extern's arguments its `...` slots claim. +fn slot_count(spec: &[(String, KwSource)]) -> usize { + spec.iter().filter(|(_, v)| *v == KwSource::Slot).count() +} + +/// Bind a keyword spec to concrete values: the leading `args` fill the positional +/// parameters and the rest fill the `...` slots in written order. Returns the +/// positional arguments and the resolved `kw=value` pairs. +/// +/// `args` must hold exactly the positional count plus the slot count; callers +/// arrange that (by padding with lambda parameters when under-applied). +fn bind_kwargs( + spec: &[(String, KwSource)], + args: Vec, +) -> (Vec, Vec<(String, PyExpr)>) { + let positional = args.len() - slot_count(spec); + let mut rest = args; + let leading: Vec = rest.drain(..positional).collect(); + let mut fills = rest.into_iter(); + let kwargs = spec + .iter() + .map(|(k, v)| { + let value = match v { + KwSource::Lit(e) => e.clone(), + KwSource::Slot => fills.next().expect("a fill per slot"), + }; + (k.clone(), value) + }) + .collect(); + (leading, kwargs) +} + /// Build a Python expression from a dotted path: `["math", "sqrt"]` → `math.sqrt`, /// a single segment → a bare name. fn dotted_path(segments: &[String]) -> PyExpr { @@ -3322,7 +3448,7 @@ fn receiver_lambda( member: &[String], arity: usize, kind: Receiver, - kwargs: Vec<(String, PyExpr)>, + spec: Vec<(String, KwSource)>, ) -> PyExpr { let recv = "_pf_recv".to_string(); let accessed = attr_path(PyExpr::Name(recv.clone()), member); @@ -3332,17 +3458,20 @@ fn receiver_lambda( body: Box::new(accessed), }; } + // The lambda takes every argument after the receiver; a `...` slot claims one of + // them and lands as a keyword instead of a positional. let args: Vec = (1..arity.max(1)).map(|i| format!("_pf_a{i}")).collect(); let call_args: Vec = args.iter().cloned().map(PyExpr::Name).collect(); - let body = if kwargs.is_empty() { + let body = if spec.is_empty() { PyExpr::Call { func: Box::new(accessed), args: call_args, } } else { + let (positional, kwargs) = bind_kwargs(&spec, call_args); PyExpr::CallKw { func: Box::new(accessed), - args: call_args, + args: positional, kwargs, } }; @@ -3356,14 +3485,16 @@ fn receiver_lambda( /// A lambda for a bare reference to a nullary extern: `lambda *_: time.time()`. The /// `*_` swallows the unit argument Pyfun passes at a `unit -> a` call site, so the -/// value works however it is later applied. Any pinned `kwargs` are appended. -fn nullary_lambda(target: &[String], kwargs: Vec<(String, PyExpr)>) -> PyExpr { - let body = if kwargs.is_empty() { +/// value works however it is later applied. Any pinned `kwargs` are appended (a +/// nullary extern has no argument to spare, so the parser rejects `...` on one). +fn nullary_lambda(target: &[String], spec: Vec<(String, KwSource)>) -> PyExpr { + let body = if spec.is_empty() { PyExpr::Call { func: Box::new(dotted_path(target)), args: vec![], } } else { + let (_, kwargs) = bind_kwargs(&spec, Vec::new()); PyExpr::CallKw { func: Box::new(dotted_path(target)), args: vec![], diff --git a/src/parser/ast.rs b/src/parser/ast.rs index 6b51c41..5d5048a 100644 --- a/src/parser/ast.rs +++ b/src/parser/ast.rs @@ -147,22 +147,29 @@ pub struct ExternDecl { /// importing) the receiver's class, and reaches inherited/delegated members the /// unbound `Class.member` form cannot. pub receiver: Option, - /// Fixed Python keyword arguments pinned on the target (`DESIGN.md` §6), from a - /// `(kw = lit, …)` suffix on the `= …` clause. Appended to every emitted call - /// (`open(path, mode="rt", encoding="utf-8")`); empty when absent. Purely a - /// lowering concern — invisible to the Pyfun type (the arrow type is unchanged). + /// Python keyword arguments on the target (`DESIGN.md` §6), from a + /// `(kw = lit | ..., …)` suffix on the `= …` clause. Appended to every emitted + /// call (`open(path, mode="rt", encoding="utf-8")`); empty when absent. A + /// pinned literal is purely a lowering concern, invisible to the Pyfun type; a + /// `...` slot consumes one argument of the declared arrow, so it changes where + /// that argument lands in the emitted call but not the type either. pub kwargs: Vec<(String, ExternArg)>, pub span: NodeSpan, } -/// A literal value pinned as a keyword argument on an `extern` target. Only the -/// literal forms Python needs at the boundary — no Pyfun expressions. +/// A value bound to a keyword argument on an `extern` target: either a literal +/// pinned at the declaration, or a `...` slot the caller fills. Only the literal +/// forms Python needs at the boundary — no Pyfun expressions. #[derive(Debug, Clone, PartialEq)] pub enum ExternArg { Str(String), Int(i64), Float(f64), Bool(bool), + /// `...` — a caller-supplied slot (`DESIGN.md` §6). Consumes one argument of + /// the declared arrow: the target takes the leading arguments positionally and + /// the slots take the trailing ones, in the order the keywords are written. + Slot, } /// How an instance-access `extern` (`= .member`) uses its first argument. diff --git a/src/parser/mod.rs b/src/parser/mod.rs index 57bb5c0..d74e499 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -379,7 +379,9 @@ impl Parser { // `= .read()` calls the method (`resp.read()`), `= .text` reads the // attribute/property (`resp.text`) — trailing `()` is the "call" marker. // A trailing `(kw = lit, …)` pins fixed Python keyword arguments on the - // target, appended to every emitted call (`open(path, encoding="utf-8")`). + // target, appended to every emitted call (`open(path, encoding="utf-8")`); + // a `kw = ...` slot instead takes one of the caller's arguments. + let kw_start = self.cur_start(); let (target, receiver, kwargs) = if self.eat(&Tok::Eq) { let dotted = self.eat(&Tok::Dot); let mut segs = vec![self.parse_ident("Python target")?]; @@ -407,6 +409,35 @@ impl Parser { } else { (vec![name.clone()], None, Vec::new()) }; + // A `...` slot consumes one argument of the declared arrow, so the type must + // have an argument to spare. A receiver takes the first one, and a nullary + // extern's only argument is the `unit` that lowering drops, so neither leaves + // anything for a slot to claim. + let slots = kwargs.iter().filter(|(_, v)| *v == ExternArg::Slot).count(); + if slots > 0 { + let kw_span = Span::new(kw_start, self.prev_end()); + if type_is_unit_domain(&ty) { + return Err(ParseError { + message: "`...` needs an argument to take, but this extern's only \ + argument is the `unit` that a nullary call drops" + .to_string(), + span: kw_span, + }); + } + let available = type_arrow_arity(&ty) - usize::from(receiver.is_some()); + if slots > available { + let slot_s = if slots == 1 { "" } else { "s" }; + let arg_s = if available == 1 { "" } else { "s" }; + return Err(ParseError { + message: format!( + "{slots} `...` slot{slot_s}, but the type leaves only \ + {available} argument{arg_s} to fill {}", + if slots == 1 { "it" } else { "them" } + ), + span: kw_span, + }); + } + } let span = NodeSpan::new(Span::new(start, self.prev_end())); Ok(ExternDecl { doc: None, @@ -449,9 +480,13 @@ impl Parser { Ok(kwargs) } - /// Parse a single pinned keyword-argument literal: a string, an int (with an - /// optional leading unary minus), a float (likewise), or a bool. + /// Parse a single keyword-argument value: `...` (a caller-supplied slot), or a + /// pinned literal — a string, an int (with an optional leading unary minus), a + /// float (likewise), or a bool. fn parse_extern_arg(&mut self) -> Result { + if self.eat(&Tok::Ellipsis) { + return Ok(ExternArg::Slot); + } // A leading `-` negates the following numeric literal. if self.eat(&Tok::Minus) { return match self.peek().clone() { @@ -487,7 +522,7 @@ impl Parser { self.bump(); Ok(ExternArg::Bool(false)) } - _ => Err(self.error("expected a string, number, or bool literal")), + _ => Err(self.error("expected `...` or a string, number, or bool literal")), } } @@ -2074,6 +2109,24 @@ fn attach_doc(item: &mut Item, doc: Option) { } } +/// The number of leading arrows in a surface type — how many arguments an `extern` +/// of that type takes. (Lowering has its own copy for the lowered form; this one +/// keeps the parser from depending on a later phase.) +fn type_arrow_arity(ty: &TypeExpr) -> usize { + match ty { + TypeExpr::Fun(_, ret, _) => 1 + type_arrow_arity(ret), + TypeExpr::Con(..) | TypeExpr::Tuple(_) => 0, + } +} + +/// Whether an `extern`'s first parameter is `unit` — a *nullary* Python callable +/// whose single argument lowering drops (`time.time ()` → `time.time()`). +fn type_is_unit_domain(ty: &TypeExpr) -> bool { + matches!(ty, TypeExpr::Fun(domain, _, _) + if matches!(domain.as_ref(), + TypeExpr::Con(name, _, args) if name == "unit" && args.is_empty())) +} + /// A short human-readable name for a token, used in error messages. fn describe(tok: &Tok) -> String { match tok { @@ -2144,6 +2197,7 @@ fn token_symbol(tok: &Tok) -> &'static str { Tok::Comma => ",", Tok::Colon => ":", Tok::Dot => ".", + Tok::Ellipsis => "...", Tok::Underscore => "_", _ => "token", } diff --git a/tests/compile.rs b/tests/compile.rs index 32b177d..b12daf0 100644 --- a/tests/compile.rs +++ b/tests/compile.rs @@ -455,6 +455,139 @@ fn e2e_extern_kwargs_produce_observable_output() { ); } +#[test] +fn extern_kwarg_slot_takes_a_trailing_argument() { + // `kw = ...` makes the keyword's value come from the caller: the target takes + // the leading arguments positionally and the slots take the trailing ones. + let py = pyfun::compile( + "extern openText : string -> string -> Seq string = builtins.open(mode=\"rt\", encoding=...)\n\ + let f path enc = openText path enc", + ) + .unwrap(); + assert!( + py.contains("return builtins.open(path, mode=\"rt\", encoding=enc)"), + "{py}" + ); +} + +#[test] +fn extern_kwarg_slots_fill_in_the_order_the_keywords_are_written() { + // Pinned literals consume no argument; the slots take the trailing arguments + // left to right, wherever they sit among the literals. + let py = pyfun::compile( + "extern mix : string -> int -> bool -> a = m.f(a=1, b=..., c=\"x\", d=...)\n\ + let f s i b = mix s i b", + ) + .unwrap(); + assert!(py.contains("return m.f(s, a=1, b=i, c=\"x\", d=b)"), "{py}"); +} + +#[test] +fn receiver_method_extern_kwarg_slot_takes_a_trailing_argument() { + // The receiver still claims the first argument; a slot claims one of the rest. + let py = pyfun::compile( + "extern type P\n\ + extern writeText : P -> string -> string -> int = .write_text(encoding=...)\n\ + let f p text enc = writeText p text enc", + ) + .unwrap(); + assert!( + py.contains("return p.write_text(text, encoding=enc)"), + "{py}" + ); +} + +#[test] +fn extern_kwarg_slot_partial_application_becomes_a_lambda() { + // `functools.partial` cannot carry a keyword whose value has not arrived, so an + // under-applied slot extern closes over a lambda that takes the rest. A bare + // reference takes every argument, including the positional ones. + let py = pyfun::compile( + "extern parseInt : string -> int -> int = int(base=...)\n\ + let bare = parseInt\n\ + let partial = parseInt \"ff\"", + ) + .unwrap(); + assert!( + py.contains("bare = lambda _pf_k0, _pf_k1: int(_pf_k0, base=_pf_k1)"), + "{py}" + ); + assert!( + py.contains("partial = lambda _pf_k0: int(\"ff\", base=_pf_k0)"), + "{py}" + ); + assert!( + !py.contains("functools"), + "no partial is possible here: {py}" + ); +} + +#[test] +fn extern_kwarg_slot_partial_evaluates_supplied_arguments_eagerly() { + // The supplied arguments must evaluate at application time, exactly as + // `functools.partial` would have evaluated them — not once per later call. They + // are bound to temporaries, and the lambda closes over those. The receiver of a + // method extern is bound the same way. + let py = pyfun::compile( + "extern parseInt : string -> int -> int = int(base=...)\n\ + extern src : unit -> string = get.line\n\ + let partial = parseInt (src ())", + ) + .unwrap(); + assert!(py.contains("_pf_t0 = get.line()"), "{py}"); + assert!( + py.contains("partial = lambda _pf_k0: int(_pf_t0, base=_pf_k0)"), + "{py}" + ); + + let py = pyfun::compile( + "extern type P\n\ + extern toPath : string -> P = pathlib.Path\n\ + extern writeText : P -> string -> string -> int = .write_text(encoding=...)\n\ + let partial = writeText (toPath \"a.txt\") \"body\"", + ) + .unwrap(); + assert!(py.contains("_pf_t0 = pathlib.Path(\"a.txt\")"), "{py}"); + assert!( + py.contains("partial = lambda _pf_k0: _pf_t0.write_text(\"body\", encoding=_pf_k0)"), + "{py}" + ); +} + +#[test] +fn extern_kwarg_slot_rejects_a_type_with_no_argument_to_spare() { + // A slot consumes an argument of the declared arrow, so the type must have one + // going spare: a receiver takes the first, and a nullary extern's only argument + // is the `unit` that lowering drops. + let err = pyfun::compile("extern bad : string -> a = f(x=..., y=...)").unwrap_err(); + assert!(err.to_string().contains("2 `...` slots"), "{err}"); + assert!(err.to_string().contains("only 1 argument"), "{err}"); + + let err = pyfun::compile("extern bad : string -> a = .attr(k=...)").unwrap_err(); + assert!(err.to_string().contains("1 `...` slot,"), "{err}"); + assert!(err.to_string().contains("only 0 arguments"), "{err}"); + + let err = pyfun::compile("extern bad : unit -> a = time.time(tz=...)").unwrap_err(); + assert!( + err.to_string().contains("`unit` that a nullary call drops"), + "{err}" + ); +} + +#[test] +fn e2e_extern_kwarg_slot_produces_observable_output() { + // `int`'s real `base` kwarg, supplied by the caller rather than pinned: the same + // extern parses hex and binary, and a partial application of it still works. + run_and_check( + "extern parseIn : string -> int -> int = int(base=...)\n\ + let hex = parseIn \"ff\" 16\n\ + let bin = parseIn \"1011\" 2\n\ + let ff = parseIn \"ff\"\n\ + let also = ff 16", + &[("hex", "255"), ("bin", "11"), ("also", "255")], + ); +} + #[test] fn list_literal_lowers_to_a_python_list() { let py = pyfun::compile("let xs = [1, 2, 3]").unwrap(); diff --git a/tests/roundtrip.rs b/tests/roundtrip.rs index eca7ce4..2ef369c 100644 --- a/tests/roundtrip.rs +++ b/tests/roundtrip.rs @@ -273,6 +273,12 @@ const PROGRAMS: &[&str] = &[ "extern connect: string -> a = sqlite3.connect(timeout=5, check_same_thread=false)", "extern gzipOpen: string -> a = gzip.open(compresslevel=-1, ratio=2.5, mode=\"rt\")", "extern open: string -> a = open(mode=\"rt\")", + // A `...` slot takes its value from the caller instead of the declaration, and + // mixes freely with pinned literals on all three target forms. + "extern parseInt: string -> int -> int = int(base=...)", + "extern openText: string -> string -> Seq string = builtins.open(mode=\"rt\", encoding=...)", + "extern writeText: a -> string -> string -> int = .write_text(encoding=...)", + "extern mix: string -> int -> bool -> a = m.f(a=1, b=..., c=\"x\", d=...)", // Effect annotations on declared arrows (`DESIGN.md` §4): labels print back // as written, so single, multi, and argument-position annotations roundtrip. "extern fetch: string ->{async} string = httpx.get",