diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md index a475c0e..4959be8 100644 --- a/.claude/CLAUDE.md +++ b/.claude/CLAUDE.md @@ -76,7 +76,7 @@ feat(lexer): add type system keywords Added four keywords for new type system: - concept: Base type definition - sub_concept: Enum/record sub-type definition -- concept_comparison: Compile-time enum mapping +- definition: Compile-time enum mapping - any: Universal type for dynamic contexts ``` @@ -90,6 +90,14 @@ Added four keywords for new type system: - `SBIR-v0.2.0-SPEC.md` - Storybook Intermediate Representation binary format - `.claude/tmp` - Unlimited storage for temporary files. Use this for plans, reports, and other temporary data that is not part of the repository. +## Debugging Protocol + +When debugging fails after 2 attempts, stop and enter plan mode. Explain your current hypothesis, what you've tried, and propose next steps before making more changes. Do not blame caching or environment without evidence. + +## Project-Specific: Zed Extension + +For Zed extension work: the compiled grammar is cached and `highlights.scm` must be bundled correctly. Never delete local query files assuming Zed will fall back to fetched ones. Always verify the extension builds and loads before declaring success. + ## Testing Philosophy - Every feature needs tests diff --git a/docs/README.md b/docs/README.md index 2809c10..e3b6b8b 100644 --- a/docs/README.md +++ b/docs/README.md @@ -51,7 +51,7 @@ Storybook v0.3 introduces a **compile-time type system** for stronger validation - **`species`** - Define base archetypes with default fields that characters inherit - **`concept` / `sub_concept`** - Algebraic data types with dot notation (`sub_concept Cup.Size { Small, Medium, Large }`) -- **`concept_comparison`** - Compile-time pattern matching over concept variants +- **`definition`** - Compile-time pattern matching over concept variants - **Template species inheritance** - Templates extend species for layered defaults (`template Person: Human { ... }`) - **Life arc field requirements** - `life_arc Career requires { skill: Number }` validates fields at compile time diff --git a/docs/SBIR-CHANGELOG.md b/docs/SBIR-CHANGELOG.md index fc74872..6355082 100644 --- a/docs/SBIR-CHANGELOG.md +++ b/docs/SBIR-CHANGELOG.md @@ -11,6 +11,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 --- +## [0.3.2] - 2026-02-23 + +### Changed + +**Keyword Rename:** +- The `concept_comparison` keyword has been renamed to `definition` + - Old: `concept_comparison SkillLevel { ... }` + - New: `definition SkillLevel { ... }` + - No binary format changes required - this is a source-level rename only + - The Rust AST type `ConceptComparisonDecl` is renamed to `DefinitionDecl` + +--- + ## [0.2.0] - 2026-02-13 ### Added diff --git a/docs/SBIR-v0.3.1-SPEC.md b/docs/SBIR-v0.3.1-SPEC.md index 79175f0..4bd7ab2 100644 --- a/docs/SBIR-v0.3.1-SPEC.md +++ b/docs/SBIR-v0.3.1-SPEC.md @@ -58,7 +58,7 @@ The Storybook Intermediate Representation (SBIR) is a binary format that represe 3. **Life Arc Field Requirements** - Life arcs can declare required fields with type annotations **Breaking changes:** -- TYPES section now populated with concept, sub_concept, and concept_comparison definitions +- TYPES section now populated with concept, sub_concept, and definition declarations - Value discriminants renamed: Int→Number, Float→Decimal, String→Text, Bool→Boolean - Expression discriminants renamed: IntLit→NumberLit, FloatLit→DecimalLit, StringLit→TextLit, BoolLit→BooleanLit - TEMPLATES section extended with species_base field @@ -385,7 +385,7 @@ concept Cup sub_concept Cup.Type { Small, Medium, Large } sub_concept Cup.Material { weight: 100, fragile: true } -concept_comparison CupDefaults for Cup matching Cup.Type { +definition CupDefaults for Cup matching Cup.Type { Small { capacity: 200 } Medium { capacity: 350 } Large { capacity: 500 } @@ -1051,7 +1051,7 @@ enumerations used primarily for calendar patterns and simple value sets. - Value/expression type renames aligned with Storybook language terminology **Breaking Changes:** -- TYPES section (Section 3) now populated with concept, sub_concept, and concept_comparison definitions +- TYPES section (Section 3) now populated with concept, sub_concept, and definition declarations - Value discriminant names changed: Int→Number, Float→Decimal, String→Text, Bool→Boolean (wire format unchanged) - Expression discriminant names changed: IntLit→NumberLit, FloatLit→DecimalLit, StringLit→TextLit, BoolLit→BooleanLit (wire format unchanged) - TEMPLATES section: added `species_base: Option` field before `strict` diff --git a/docs/SBIR-v0.3.2-SPEC.md b/docs/SBIR-v0.3.2-SPEC.md new file mode 100644 index 0000000..843ec4b --- /dev/null +++ b/docs/SBIR-v0.3.2-SPEC.md @@ -0,0 +1,1266 @@ +# Storybook Intermediate Representation (SBIR) v0.3.2 Specification + +**Version:** 0.3.2 +**Status:** Draft +**Date:** February 2026 + +--- + +## Table of Contents + +1. [Introduction](#1-introduction) +2. [File Format Overview](#2-file-format-overview) +3. [Section 1: Header](#3-section-1-header) +4. [Section 2: String Table](#4-section-2-string-table) +5. [Section 3: Types](#5-section-3-types) +6. [Section 4: Characters](#6-section-4-characters) +7. [Section 5: Templates](#7-section-5-templates) +8. [Section 6: Species](#8-section-6-species) +9. [Section 7: Behaviors](#9-section-7-behaviors) +10. [Section 8: Schedules](#10-section-8-schedules) +11. [Section 9: Institutions](#11-section-9-institutions) +12. [Section 10: Relationships](#12-section-10-relationships) +13. [Section 11: Locations](#13-section-11-locations) +14. [Section 12: Life Arcs](#14-section-12-life-arcs) +15. [Section 13: Enums](#15-section-13-enums) +16. [Changelog](#16-changelog) + +--- + +## 1. Introduction + +### 1.1 Purpose + +The Storybook Intermediate Representation (SBIR) is a binary format that represents compiled Storybook programs. It serves as the interchange format between the Storybook compiler and runtime engines. + +### 1.2 Design Goals + +- **Compact:** Efficient binary encoding for large story worlds +- **Fast to load:** Direct memory mapping when possible +- **Versioned:** Clear version tracking for format evolution +- **Complete:** Represents all semantic information from source +- **Runtime-ready:** Minimal post-processing required + +### 1.3 Changes in v0.3.2 + +**Keyword changes:** +1. **Definition Keyword** - The `concept_comparison` keyword has been renamed to `definition` + - Old: `concept_comparison SkillLevel { ... }` + - New: `definition SkillLevel { ... }` + - This is a **find-and-replace** change - no binary format changes required + - The struct and AST type is renamed from `ConceptComparisonDecl` to `DefinitionDecl` + +### 1.4 Changes in v0.3.1 + +**Keyword changes:** +1. **Schedule Composition** - The `extends` keyword for schedule inheritance has been renamed to `modifies` + - Old: `schedule BakerSchedule extends WorkWeek { ... }` + - New: `schedule BakerSchedule modifies WorkWeek { ... }` + - This is a **find-and-replace** change - no binary format changes required + - The field name in the Schedule struct remains the same (just stores the base schedule name) + +### 1.4 Changes in v0.3.0 + +**Major additions:** +1. **Type System** - Concepts, sub-concepts (enum/record), and concept comparisons with pattern matching +2. **Species-Based Template Inheritance** - Templates can declare a species base for field inheritance +3. **Life Arc Field Requirements** - Life arcs can declare required fields with type annotations + +**Breaking changes:** +- TYPES section now populated with concept, sub_concept, and definition declarations +- Value discriminants renamed: Int→Number, Float→Decimal, String→Text, Bool→Boolean +- Expression discriminants renamed: IntLit→NumberLit, FloatLit→DecimalLit, StringLit→TextLit, BoolLit→BooleanLit +- TEMPLATES section extended with species_base field +- LIFE ARCS section extended with required_fields + +### 1.5 Changes in v0.2.0 + +**Major additions:** +1. **Resource Linking System** - Characters and institutions can link to behaviors and schedules with conditions and priorities +2. **Year-Long Schedule System** - Schedules support temporal patterns (day-specific, seasonal, recurrence) +3. **Behavior Tree Enhancements** - Named nodes, decorator parameters, keyword transformations + +**Breaking changes:** +- CHARACTERS section extended with behavior_links and schedule_links +- INSTITUTIONS section extended with behavior_links and schedule_links +- SCHEDULES section redesigned with patterns and inheritance +- BEHAVIORS section extended with named nodes and parameterized decorators + +--- + +## 2. File Format Overview + +### 2.1 File Structure + +``` +[Header] +[String Table] +[Type Definitions] +[Characters Section] +[Templates Section] +[Species Section] +[Behaviors Section] +[Schedules Section] +[Institutions Section] +[Relationships Section] +[Locations Section] +[Life Arcs Section] +[Enums Section] +``` + +### 2.2 Primitive Types + +| Type | Size | Description | +|------|------|-------------| +| `u8` | 1 byte | Unsigned 8-bit integer | +| `u16` | 2 bytes | Unsigned 16-bit integer (little-endian) | +| `u32` | 4 bytes | Unsigned 32-bit integer (little-endian) | +| `u64` | 8 bytes | Unsigned 64-bit integer (little-endian) | +| `i32` | 4 bytes | Signed 32-bit integer (little-endian) | +| `i64` | 8 bytes | Signed 64-bit integer (little-endian) | +| `f32` | 4 bytes | IEEE 754 single-precision float | +| `f64` | 8 bytes | IEEE 754 double-precision float | +| `bool` | 1 byte | 0 = false, 1 = true | +| `String` | Variable | Length-prefixed UTF-8: `u32 length` + `[u8; length]` | +| `StringRef` | 4 bytes | Index into string table (u32) | + +### 2.3 Common Structures + +#### Option + +Optional values are encoded with a discriminant byte followed by the value if present: + +``` +u8 discriminant: + 0 = None → No additional bytes, next field starts immediately + 1 = Some → T data follows immediately after discriminant +``` + +**Encoding:** +- **None case:** Just 1 byte (0x00), nothing else +- **Some case:** 1 byte (0x01) + full T encoding + +**Examples:** + +`Option` when None: +``` +0x00 ← 1 byte total +``` + +`Option` when Some(42): +``` +0x01 ← discriminant (Some) +0x2A 0x00 0x00 0x00 ← StringRef = 42 (u32) + ← 5 bytes total +``` + +`Option>` when None: +``` +0x00 ← 1 byte total +``` + +`Option>` when Some([field1, field2]): +``` +0x01 ← discriminant (Some) +0x02 0x00 0x00 0x00 ← count = 2 (u32) +[Field 1 encoding] ← First field +[Field 2 encoding] ← Second field + ← 5+ bytes (depends on field sizes) +``` + +#### Vec +``` +u32 count +[T; count] +``` + +### 2.4 Binary Format Conventions + +**IMPORTANT: SBIR is a packed binary format with no separators.** + +#### No Delimiter Bytes + +All data is laid out **sequentially in memory** with **no separator characters** between: +- Items in a Vec +- Fields in a struct +- Sections in the file +- Values of any kind + +The file is a continuous stream of bytes where each element's size determines where the next element begins. + +#### Length-Prefix Pattern + +All variable-length data uses a **length-prefix pattern**: + +1. **Length/count field** (u32) tells you "how much data is coming" +2. **Data bytes** - read exactly that amount +3. **Next field** starts immediately after (no gap, no separator) + +#### Reading Variable-Length Vec + +When `T` itself is variable-length, each item carries its own size information: + +**Example: Vec** +``` +u32 count = 3 ← "There are 3 strings" + String 1: + u32 length = 5 ← "First string is 5 bytes" + [u8; 5] = "hello" ← Read 5 bytes, next item starts immediately + String 2: + u32 length = 5 ← "Second string is 5 bytes" + [u8; 5] = "world" ← Read 5 bytes + String 3: + u32 length = 3 ← "Third string is 3 bytes" + [u8; 3] = "foo" ← Read 3 bytes +``` + +**Example: Vec** (complex variable-length structs) +``` +u32 count = 2 ← "There are 2 characters" + Character 1: + u32 name_len = 6 + [u8; 6] = "Martha" + u8 species_discriminant = 1 ← Option::Some + u32 species_ref = 10 + u32 fields_count = 2 + Field 1: (name_ref, value_discriminant, value_data) + Field 2: (name_ref, value_discriminant, value_data) + u32 template_refs_count = 1 + StringRef = 15 + u32 behavior_links_count = 0 + u32 schedule_links_count = 0 + Character 2: + (starts immediately after Character 1 ends) + u32 name_len = 5 + [u8; 5] = "David" + ... (continues) +``` + +#### Parsing Algorithm + +The parser reads **sequentially** using each length field to know how many bytes to consume: + +``` +position = 0 +while position < file_size: + read_length_or_discriminant() + read_exactly_that_many_bytes() + position += bytes_read + // Next field starts here (no seeking, no separator scanning) +``` + +#### Key Rules + +1. **Fixed-size types** (u8, u32, f64, etc.) take their exact size - no padding +2. **Variable-size types** always start with a length prefix (u32) +3. **Option** starts with a discriminant byte (0=None, 1=Some) +4. **Enums/discriminated unions** start with a discriminant byte +5. **No alignment padding** - all data is tightly packed + +There are no: + +- No newline characters (`\n`) +- No separators (`,`, `;`, spaces) +- No null terminators (except inside UTF-8 string data) +- No padding bytes between fields (unless explicitly specified) +- No section markers or headers (sections just follow each other) + +The documentation uses newlines and indentation for **readability only** - the actual binary file is a continuous stream of bytes with no whitespace. + +--- + +## 3. Section 1: Header + +``` +Magic: [u8; 4] // "SBIR" (0x53 0x42 0x49 0x52) +Version: u16 // Major version (0x0003 for v0.3.0) +MinorVersion: u16 // Minor version (0x0000) +Flags: u32 // Reserved (0x00000000) +SectionCount: u32 // Number of sections (currently 13) +``` + +**Version History:** +- v0.1.0: Implicit version (pre-release) +- v0.2.0: First formal versioned release +- v0.3.0: Type system, species inheritance, life arc requirements + +--- + +## 4. Section 2: String Table + +The string table stores all strings used in the SBIR file. + +``` +Count: u32 +Strings: [String; Count] +``` + +**Usage:** All `StringRef` types reference an index in this table. + +**Encoding:** UTF-8 with length prefix. + +**Example:** +``` +Count: 3 +Strings: + [0]: "Alice" + [1]: "Wonderland" + [2]: "rabbit_hole" +``` + +--- + +## 5. Section 3: Types + +**Note:** New in v0.3.0. This section encodes the concept type system. + +### 5.1 Structure + +``` +ConceptCount: u32 +Concepts: [Concept; ConceptCount] +SubConceptCount: u32 +SubConcepts: [SubConcept; SubConceptCount] +ConceptComparisonCount: u32 +ConceptComparisons: [ConceptComparison; ConceptComparisonCount] +``` + +### 5.2 Concept Encoding + +``` +Concept: + name: StringRef +``` + +A concept is a named type declaration with no additional data. Sub-concepts reference +their parent concept by name. + +### 5.3 SubConcept Encoding + +``` +SubConcept: + name: StringRef + parent_concept: StringRef + kind: u8 + data: +``` + +**Kind Discriminants:** +``` +0x01 = Enum +0x02 = Record +``` + +**Enum (0x01):** +``` +variants: Vec +``` + +**Record (0x02):** +``` +fields: Vec +``` + +Where `Field` is encoded as: +``` +Field: + name: StringRef + value: Value +``` + +### 5.4 ConceptComparison Encoding + +``` +ConceptComparison: + name: StringRef + concept_ref: StringRef // The concept being compared + sub_concept_ref: StringRef // The sub-concept (enum) being matched + arms: Vec +``` + +**ComparisonArm:** +``` +ComparisonArm: + variant: StringRef // Enum variant to match + fields: Vec // Field assignments for this arm + condition: Option // Optional guard condition +``` + +### 5.5 Binary Example + +**Source:** +```storybook +concept Cup +sub_concept Cup.Type { Small, Medium, Large } +sub_concept Cup.Material { weight: 100, fragile: true } + +definition CupDefaults for Cup matching Cup.Type { + Small { capacity: 200 } + Medium { capacity: 350 } + Large { capacity: 500 } +} +``` + +**Binary (conceptual):** +``` +ConceptCount: 1 +Concepts: + [0]: name = StringRef("Cup") + +SubConceptCount: 2 +SubConcepts: + [0]: SubConcept { + name: StringRef("Type") + parent_concept: StringRef("Cup") + kind: 0x01 (Enum) + variants: [StringRef("Small"), StringRef("Medium"), StringRef("Large")] + } + [1]: SubConcept { + name: StringRef("Material") + parent_concept: StringRef("Cup") + kind: 0x02 (Record) + fields: [ + Field { name: StringRef("weight"), value: Number(100) }, + Field { name: StringRef("fragile"), value: Boolean(true) } + ] + } + +ConceptComparisonCount: 1 +ConceptComparisons: + [0]: ConceptComparison { + name: StringRef("CupDefaults") + concept_ref: StringRef("Cup") + sub_concept_ref: StringRef("Type") + arms: [ + { variant: StringRef("Small"), fields: [("capacity", Number(200))], condition: None }, + { variant: StringRef("Medium"), fields: [("capacity", Number(350))], condition: None }, + { variant: StringRef("Large"), fields: [("capacity", Number(500))], condition: None } + ] + } +``` + +--- + +## 6. Section 4: Characters + +### 6.1 Structure + +``` +Count: u32 +Characters: [Character; Count] +``` + +### 6.2 Character Encoding + +``` +Character: + name: StringRef + species: Option + fields: Map + template_refs: Vec // Templates this character uses + behavior_links: Vec // NEW in v0.2.0 + schedule_links: Vec // NEW in v0.2.0 +``` + +### 6.3 BehaviorLink (NEW in v0.2.0) + +``` +BehaviorLink: + behavior_id: u32 // Index into BEHAVIORS section + priority: u8 // 0=Low, 1=Normal, 2=High, 3=Critical + condition: Option // Optional activation condition + is_default: bool // Default behavior (no condition) +``` + +**Priority Encoding:** +``` +enum Priority { + Low = 0, + Normal = 1, + High = 2, + Critical = 3, +} +``` + +**Selection Algorithm:** +1. Filter links where `condition` evaluates to true (or is None) +2. Sort by priority (descending) +3. Return highest priority link +4. If tie, use declaration order + +### 6.4 ScheduleLink (NEW in v0.2.0) + +``` +ScheduleLink: + schedule_id: u32 // Index into SCHEDULES section + condition: Option // Optional activation condition + is_default: bool // Default schedule (fallback) +``` + +**Selection Algorithm:** +1. Iterate schedule_links in order +2. Skip default links initially +3. Return first link where `condition` is true (or None) +4. If no match, use default link (if present) + +### 6.5 Value Encoding + +``` +Value: + discriminant: u8 + data: +``` + +**Discriminants:** +``` +0x01 = Number(i64) // Renamed from Int in v0.3.0 +0x02 = Decimal(f64) // Renamed from Float in v0.3.0 +0x03 = Text(StringRef) // Renamed from String in v0.3.0 +0x04 = Boolean(bool) // Renamed from Bool in v0.3.0 +0x05 = Range(Value, Value) +0x06 = Time(u8 hour, u8 minute, u8 second) +0x07 = Duration(u32 hours, u32 minutes, u32 seconds) +0x08 = Identifier(Vec) // Qualified path +0x09 = List(Vec) +0x0A = Object(Vec) +0x0B = ProseBlock(StringRef tag, String content) +0x0C = Override(...) +``` + +**Note:** The wire format (discriminant bytes 0x01-0x0C) is unchanged from v0.2.0. +Only the semantic names have been updated to match the Storybook language's type +terminology. + +### 6.6 Expression Encoding + +``` +Expression: + discriminant: u8 + data: +``` + +**Discriminants:** +``` +0x01 = NumberLit(i64) // Renamed from IntLit in v0.3.0 +0x02 = DecimalLit(f64) // Renamed from FloatLit in v0.3.0 +0x03 = TextLit(StringRef) // Renamed from StringLit in v0.3.0 +0x04 = BooleanLit(bool) // Renamed from BoolLit in v0.3.0 +0x05 = Identifier(Vec) +0x06 = FieldAccess(Box, StringRef) +0x07 = Comparison(Box, CompOp, Box) +0x08 = Logical(Box, LogicalOp, Box) +0x09 = Unary(UnaryOp, Box) +0x0A = Quantifier(QuantifierKind, StringRef var, Box collection, Box predicate) +``` + +**CompOp:** `u8` (0x01=Eq, 0x02=Ne, 0x03=Lt, 0x04=Le, 0x05=Gt, 0x06=Ge) + +**LogicalOp:** `u8` (0x01=And, 0x02=Or) + +**UnaryOp:** `u8` (0x01=Not, 0x02=Neg) + +**QuantifierKind:** `u8` (0x01=ForAll, 0x02=Exists) + +--- + +## 7. Section 5: Templates + +``` +Count: u32 +Templates: [Template; Count] + +Template: + name: StringRef + species_base: Option // NEW in v0.3.0 - Species base for field inheritance + strict: bool + includes: Vec + fields: Map +``` + +**Species Base (NEW in v0.3.0):** + +When `species_base` is `Some(ref)`, the template inherits fields from the referenced +species as its base layer. The override chain is: + +1. Species fields (base layer) +2. Included template fields (override species) +3. Template's own fields (override includes) +4. Character fields (override template) + +Last-one-wins semantics apply at each layer. Type invariance is enforced: a field's +type cannot change through the inheritance chain (e.g., a Number field in the species +cannot become a Text field in the template). + +--- + +## 8. Section 6: Species + +``` +Count: u32 +Species: [Species; Count] + +Species: + name: StringRef + includes: Vec + fields: Map +``` + +--- + +## 9. Section 7: Behaviors + +### 9.1 Structure + +``` +Count: u32 +Behaviors: [Behavior; Count] +``` + +### 9.2 Behavior Encoding + +``` +Behavior: + name: StringRef + root: BehaviorNode +``` + +### 9.3 BehaviorNode Encoding + +``` +BehaviorNode: + discriminant: u8 + data: +``` + +#### Node Type Discriminants + +``` +0x01 = Selector +0x02 = Sequence +0x03 = Condition +0x04 = Action +0x10 = DecoratorRepeat +0x11 = DecoratorRepeatN +0x12 = DecoratorRepeatRange +0x13 = DecoratorInvert +0x14 = DecoratorRetry +0x15 = DecoratorTimeout +0x16 = DecoratorCooldown +0x17 = DecoratorGuard +0x18 = DecoratorSucceedAlways +0x19 = DecoratorFailAlways +0x20 = SubTree +``` + +#### Selector Node (0x01) + +``` +label: Option // NEW in v0.2.0 +children: Vec +``` + +**Keyword Mapping:** `selector` or `choose` + +#### Sequence Node (0x02) + +``` +label: Option // NEW in v0.2.0 +children: Vec +``` + +**Keyword Mapping:** `sequence` or `then` + +#### Condition Node (0x03) + +``` +expression: Expression +``` + +**Keyword Mapping:** `if` or `when` + +#### Action Node (0x04) + +``` +name: StringRef +parameters: Vec +``` + +**Keyword Mapping:** No prefix (just action name) + +#### Decorator Nodes (0x10-0x19) + +**DecoratorRepeat (0x10):** +``` +child: Box +``` +Keyword: `repeat { ... }` + +**DecoratorRepeatN (0x11):** +``` +count: u32 +child: Box +``` +Keyword: `repeat(N) { ... }` + +**DecoratorRepeatRange (0x12):** +``` +min: u32 +max: u32 +child: Box +``` +Keyword: `repeat(min..max) { ... }` + +**DecoratorInvert (0x13):** +``` +child: Box +``` +Keyword: `invert { ... }` + +**DecoratorRetry (0x14):** +``` +max_attempts: u32 +child: Box +``` +Keyword: `retry(N) { ... }` + +**DecoratorTimeout (0x15):** +``` +milliseconds: u64 // Duration in milliseconds +child: Box +``` +Keyword: `timeout(duration) { ... }` +Example: `timeout(5s)`, `timeout(30m)`, `timeout(2h)` + +**DecoratorCooldown (0x16):** +``` +milliseconds: u64 // Cooldown period in milliseconds +child: Box +``` +Keyword: `cooldown(duration) { ... }` + +**DecoratorIf (0x17):** +``` +condition: Expression +child: Box +``` +Keyword: `if(condition) { ... }` + +**DecoratorSucceedAlways (0x18):** +``` +child: Box +``` +Keyword: `succeed_always { ... }` + +**DecoratorFailAlways (0x19):** +``` +child: Box +``` +Keyword: `fail_always { ... }` + +#### SubTree Node (0x20) + +``` +path: Vec // Qualified path to subtree +``` + +Keyword: `include path::to::subtree` + +--- + +## 10. Section 8: Schedules + +### 10.1 Structure + +``` +Count: u32 +Schedules: [Schedule; Count] +``` + +### 10.2 Schedule Encoding (REDESIGNED in v0.2.0) + +``` +Schedule: + name: StringRef + parent_schedule_id: Option // Index into SCHEDULES section (for inheritance) + blocks: Vec + patterns: Vec // Day-specific, seasonal, recurrence patterns +``` + +### 10.3 ScheduleBlock + +``` +ScheduleBlock: + name: StringRef // Required in v0.2.0 + start: u16 // Minutes since midnight (0-1439) + end: u16 // Minutes since midnight (0-1439) + behavior_ref: Option> // Reference to behavior (qualified path) + fields: Map +``` + +**Changes from v0.1.0:** +- `name` is now required (was optional) +- `behavior_ref` replaces `activity: String` +- Time is encoded as minutes since midnight + +### 10.4 SchedulePattern (NEW in v0.2.0) + +``` +SchedulePattern: + kind: u8 // Pattern discriminant + specification: Vec // Pattern-specific data + blocks: Vec // Blocks to apply when pattern matches +``` + +**Pattern Kind Discriminants:** +``` +0x01 = DayPattern +0x02 = SeasonPattern +0x03 = RecurrencePattern +``` + +#### DayPattern (0x01) + +``` +specification: + day_enum_value: StringRef // References user-defined DayOfWeek enum +``` + +Example: `on Fireday` → references "Fireday" from user's DayOfWeek enum + +#### SeasonPattern (0x02) + +``` +specification: + season_enum_values: Vec // Multiple seasons allowed +``` + +Example: `season (EarlySummer, LateSummer)` → references Season enum values + +#### RecurrencePattern (0x03) + +``` +specification: + name: StringRef // Recurrence name + spec: RecurrenceSpec +``` + +**RecurrenceSpec:** +``` +RecurrenceSpec: + discriminant: u8 + data: + +Discriminants: + 0x01 = Every(u32 days) // every N days + 0x02 = WeeklyOn(Vec) // weekly on [days] + 0x03 = MonthlyOnDay(u8 day) // monthly on day N + 0x04 = Annually(u8 month, u8 day) // annually on month/day +``` + +### 10.5 Runtime Schedule Evaluation + +**Algorithm:** +1. Resolve character's schedule via ScheduleLink (conditional selection) +2. Merge inherited schedules (parent → child, depth-first) +3. Evaluate patterns for current day/season +4. Overlay patterns on base blocks (later patterns override earlier ones) +5. Produce final 24-hour schedule +6. Return ordered list of (time, behavior_ref) pairs + +--- + +## 11. Section 9: Institutions + +### 11.1 Structure (EXTENDED in v0.2.0) + +``` +Count: u32 +Institutions: [Institution; Count] + +Institution: + name: StringRef + fields: Map + behavior_links: Vec // NEW in v0.2.0 + schedule_links: Vec // NEW in v0.2.0 +``` + +**Note:** BehaviorLink and ScheduleLink are identical to Character section (§6.3, §6.4) + +--- + +## 12. Section 10: Relationships + +``` +Count: u32 +Relationships: [Relationship; Count] + +Relationship: + name: StringRef + participants: Vec + fields: Map + +Participant: + role: Option + name: Vec // Qualified path + self_block: Option> + other_block: Option> +``` + +--- + +## 13. Section 11: Locations + +``` +Count: u32 +Locations: [Location; Count] + +Location: + name: StringRef + fields: Map +``` + +--- + +## 14. Section 12: Life Arcs + +``` +Count: u32 +LifeArcs: [LifeArc; Count] + +LifeArc: + name: StringRef + required_fields: Vec // NEW in v0.3.0 + states: Vec + +ArcState: + name: StringRef + on_enter: Option> + transitions: Vec + +Transition: + to: StringRef + condition: Expression +``` + +### 14.1 FieldRequirement (NEW in v0.3.0) + +``` +FieldRequirement: + name: StringRef // Field name + type_name: StringRef // Expected type (e.g., "Number", "Text") +``` + +**Purpose:** Life arcs can declare required fields that any character using the life arc +must have. This enables compile-time validation that characters provide the necessary +fields for state transitions and on_enter actions. + +**Example:** +```storybook +life_arc Career requires { skill_level: Number, title: Text } { + state Junior { ... } + state Senior { ... } +} +``` + +**Binary:** +``` +LifeArc: + name: StringRef("Career") + required_fields: [ + FieldRequirement { name: StringRef("skill_level"), type_name: StringRef("Number") }, + FieldRequirement { name: StringRef("title"), type_name: StringRef("Text") } + ] + states: [...] +``` + +--- + +## 15. Section 13: Enums + +### 15.1 Structure + +``` +Count: u32 +Enums: [EnumDecl; Count] +``` + +### 15.2 EnumDecl Encoding + +``` +EnumDecl: + name: StringRef // u32 index into string table + variants: Vec // Encoded as below +``` + +**Variants encoding (Vec):** +``` +u32 variant_count // Number of enum variants +[StringRef; variant_count] // Array of variant names (each is u32) +``` + +### 15.3 Binary Example + +**Source:** +```storybook +enum SkillLevel { + Novice, + Beginner, + Intermediate, + Advanced, + Expert, + Master +} +``` + +**Binary encoding:** +``` +EnumDecl: + name: StringRef = 42 // "SkillLevel" (4 bytes) + + u32 variant_count = 6 // 6 variants (4 bytes) + variants: + StringRef = 43 // "Novice" (4 bytes) + StringRef = 44 // "Beginner" (4 bytes) + StringRef = 45 // "Intermediate" (4 bytes) + StringRef = 46 // "Advanced" (4 bytes) + StringRef = 47 // "Expert" (4 bytes) + StringRef = 48 // "Master" (4 bytes) + +Total: 32 bytes (4 + 4 + 6*4) +``` + +### 15.4 Usage + +**Usage:** Enums are used for: +- Calendar definitions (DayOfWeek, Season, Month) +- Custom enumerated values +- Pattern matching in schedules + +**Note:** As of v0.3.0, enum-like types can also be defined via `sub_concept` with +enum kind (Section 5.3). The key distinction is that `sub_concept` enums are tied to a +parent concept and participate in the concept type system (concept comparisons, +exhaustiveness checking), while standalone enums in this section are untyped +enumerations used primarily for calendar patterns and simple value sets. + +**Standard Calendar Enums (optional):** +- `DayOfWeek`: Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday +- `Season`: Spring, Summer, Fall, Winter +- `Month`: January, February, ..., December + +--- + +## 16. Changelog + +### v0.3.0 (February 2026) + +**Major Features:** +- Type system: concepts, sub-concepts (enum and record kinds), concept comparisons +- Species-based template inheritance with type invariance enforcement +- Life arc field requirements with type annotations +- Value/expression type renames aligned with Storybook language terminology + +**Breaking Changes:** +- TYPES section (Section 3) now populated with concept, sub_concept, and definition declarations +- Value discriminant names changed: Int→Number, Float→Decimal, String→Text, Bool→Boolean (wire format unchanged) +- Expression discriminant names changed: IntLit→NumberLit, FloatLit→DecimalLit, StringLit→TextLit, BoolLit→BooleanLit (wire format unchanged) +- TEMPLATES section: added `species_base: Option` field before `strict` +- LIFE ARCS section: added `required_fields: Vec` field after `name` + +**Note:** SBIR encoder/decoder implementation is deferred until SaberVM design is finalized. + +### v0.2.0 (February 2026) + +**Major Features:** +- Resource linking system for behaviors and schedules +- Year-long schedule patterns (day, season, recurrence) +- Schedule inheritance and composition +- Behavior tree keyword support (named nodes) +- Parameterized decorators (repeat, retry, timeout, cooldown, if) + +**Breaking Changes:** +- CHARACTERS section: added behavior_links, schedule_links +- INSTITUTIONS section: added behavior_links, schedule_links +- SCHEDULES section: complete redesign with patterns and inheritance +- BEHAVIORS section: added named node support + +**Deprecations:** +- None (first versioned release) + +**Bug Fixes:** +- N/A (first formal release) + +### v0.1.0 (Implicit, Pre-Release) + +**Initial format** (inferred from existing codebase): +- Basic entity storage (characters, templates, species) +- Simple schedules (time blocks with activities) +- Behavior trees (symbolic syntax) +- Relationships, locations, life arcs +- Enum support + +--- + +## Appendix A: Binary Encoding Examples + +### Example 1: Character with Resource Links + +**Source:** +```storybook +character Alice: Human { + age: 7 + + uses behavior: CuriousBehavior, when: self.location == Wonderland, priority: High + uses behavior: DefaultBehavior, default: true + + uses schedule: AdventureSchedule, when: self.in_wonderland + uses schedule: NormalSchedule, default: true +} +``` + +**Binary (conceptual):** +``` +Character: + name: StringRef(0) // "Alice" + species: Some(StringRef(1)) // "Human" + fields: [ + ("age", Number(7)) + ] + template_refs: [] + behavior_links: [ + BehaviorLink { + behavior_id: 3 + priority: 2 // High + condition: Some(Comparison(FieldAccess(...), Eq, Identifier(...))) + is_default: false + }, + BehaviorLink { + behavior_id: 5 + priority: 1 // Normal + condition: None + is_default: true + } + ] + schedule_links: [ + ScheduleLink { + schedule_id: 1 + condition: Some(FieldAccess(...)) + is_default: false + }, + ScheduleLink { + schedule_id: 2 + condition: None + is_default: true + } + ] +``` + +### Example 2: Schedule with Patterns + +**Source:** +```storybook +schedule WorkWeek modifies BaseSchedule { + block morning { 08:00 - 12:00: WorkTasks } + block lunch { 12:00 - 13:00: EatLunch } + block afternoon { 13:00 - 17:00: WorkTasks } + + on Friday { + override afternoon { 13:00 - 15:00: FinishWeek } + } + + season (Summer) { + override morning { 07:00 - 11:00: WorkEarly } + } +} +``` + +**Binary (conceptual):** +``` +Schedule: + name: StringRef(10) // "WorkWeek" + parent_schedule_id: Some(0) // BaseSchedule index + blocks: [ + ScheduleBlock { + name: StringRef(11) // "morning" + start: 480 // 08:00 in minutes + end: 720 // 12:00 in minutes + behavior_ref: Some(["WorkTasks"]) + fields: [] + }, + ScheduleBlock { + name: StringRef(12) // "lunch" + start: 720 + end: 780 + behavior_ref: Some(["EatLunch"]) + fields: [] + }, + ScheduleBlock { + name: StringRef(13) // "afternoon" + start: 780 + end: 1020 + behavior_ref: Some(["WorkTasks"]) + fields: [] + } + ] + patterns: [ + SchedulePattern { + kind: 0x01 // DayPattern + specification: StringRef(14) // "Friday" + blocks: [ + ScheduleBlock { + name: StringRef(13) // "afternoon" (override) + start: 780 + end: 900 + behavior_ref: Some(["FinishWeek"]) + fields: [] + } + ] + }, + SchedulePattern { + kind: 0x02 // SeasonPattern + specification: [StringRef(15)] // ["Summer"] + blocks: [ + ScheduleBlock { + name: StringRef(11) // "morning" (override) + start: 420 + end: 660 + behavior_ref: Some(["WorkEarly"]) + fields: [] + } + ] + } + ] +``` + +--- + +## Appendix B: File Size Estimates + +**Assumptions:** +- Average character: 500 bytes +- Average behavior tree: 1 KB +- Average schedule: 800 bytes +- 1000 characters, 500 behaviors, 300 schedules + +**Estimated size:** +- Characters: 500 KB +- Behaviors: 500 KB +- Schedules: 240 KB +- Other sections: 100 KB +- **Total: ~1.34 MB** + +**Compression:** Typical compression (gzip/zstd) achieves 60-70% reduction → ~400-500 KB + +--- + +## Appendix C: Version History + +| Version | Date | Major Changes | +|---------|------|---------------| +| 0.1.0 | (Implicit) | Initial format | +| 0.2.0 | Feb 2026 | Resource linking, year-long schedules, behavior keywords | +| 0.3.0 | Feb 2026 | Type system, species inheritance, life arc requirements | +| 0.3.1 | Feb 2026 | Schedule keyword change: `extends` → `modifies` (source-level only) | + +--- + +**END OF SPECIFICATION** diff --git a/docs/TYPE-SYSTEM.md b/docs/TYPE-SYSTEM.md index 595182b..3228947 100644 --- a/docs/TYPE-SYSTEM.md +++ b/docs/TYPE-SYSTEM.md @@ -21,7 +21,7 @@ The Storybook type system is a **declarative, pure functional DSL** for defining - **`character`/`institution`/`location`**: Typed value instances - **`concept`**: Base type declarations for pattern matching - **`sub_concept`**: Enumerated and typed subtypes (tagged union members) -- **`concept_comparison`**: Compile-time pattern matching over subtype combinations +- **`definition`**: Compile-time pattern matching over subtype combinations - **`action`**: Signature declarations for runtime-implemented operations This system enables static validation of entity relationships, behavior conditions, and data structures while maintaining readability for narrative design. @@ -415,7 +415,7 @@ concept Vendor **When to use:** - When you need a type that will have multiple variants or aspects - To create type-safe enumerations through `sub_concept` -- As a base for compile-time pattern matching via `concept_comparison` +- As a base for compile-time pattern matching via `definition` --- @@ -530,13 +530,13 @@ Sub_concepts are **tagged union members**, not inheritance: --- -### `concept_comparison` - Compile-time Pattern Matching +### `definition` - Compile-time Pattern Matching -A `concept_comparison` performs compile-time pattern matching over combinations of sub_concept values, mapping them to derived variant names. +A `definition` performs compile-time pattern matching over combinations of sub_concept values, mapping them to derived variant names. **Syntax:** ```storybook -concept_comparison ComparisonName { +definition ComparisonName { VariantName1: { SubConceptName1: condition1, SubConceptName2: condition2, @@ -570,7 +570,7 @@ sub_concept Cup.Color { Red, Blue, Green } -concept_comparison CustomerNumbererestInCups { +definition CustomerNumbererestInCups { Numbererested: { Cup.Size: any, // Any size Cup.Type: Cup.Type is Glass or Cup.Type is Plastic, // Only Glass or Plastic @@ -655,7 +655,7 @@ serve(CupColor.Red) **Compile-time:** - Sub_concept field types must be identifiers (not value types) -- Pattern matching in `concept_comparison` is validated +- Pattern matching in `definition` is validated - Type references must resolve to declared concepts **Runtime:** @@ -677,7 +677,7 @@ sub_concept VendorInventory { Cup: any // any value of type Cup (includes all CupSize, CupType, CupColor) } -concept_comparison Example { +definition Example { AllCups: { CupSize: any, // matches Small, Medium, Large CupType: any, // matches Ceramic, Glass, Plastic @@ -710,7 +710,7 @@ concept_comparison Example { - Fields reference other concepts or need flexibility (`any`) - You want record-like types within the concept system -### When to use `concept_comparison` +### When to use `definition` - You need to map combinations of sub_concepts to outcomes - Complex conditional logic benefits from compile-time validation - Behavior trees need type-safe decision points @@ -747,7 +747,7 @@ sub_concept Food.Freshness { Spoiled } -concept_comparison FoodQuality { +definition FoodQuality { Excellent: { Food.Type: any, Food.Freshness: Food.Freshness is Fresh @@ -1699,7 +1699,7 @@ The runtime must maintain **state consistency** by validating life arc condition ## Future Considerations -- **Exhaustiveness checking**: Ensure all variant combinations are covered in concept_comparisons +- **Exhaustiveness checking**: Ensure all variant combinations are covered in definitions - **Default variants**: Support for catch-all patterns in comparisons - **Type inference**: Automatic parent concept detection beyond prefix matching - **Generic concepts**: Parameterized types for reusable patterns diff --git a/examples/baker-family/schema/types.sb b/examples/baker-family/schema/types.sb index 959c05b..20efb79 100644 --- a/examples/baker-family/schema/types.sb +++ b/examples/baker-family/schema/types.sb @@ -33,9 +33,9 @@ sub_concept SkillLevel.Tier { Master } -// Concept comparison - compile-time mapping of skill tiers to quality expectations +// Definition - compile-time mapping of skill tiers to quality expectations // An Apprentice can produce any quality; a Master must produce fresh goods -concept_comparison SkillLevel { +definition SkillLevel { Apprentice: { baking_skill: Tier is Apprentice, freshness: any diff --git a/src/lsp/code_actions.rs b/src/lsp/code_actions.rs index 08cf603..172e081 100644 --- a/src/lsp/code_actions.rs +++ b/src/lsp/code_actions.rs @@ -1701,7 +1701,7 @@ fn get_declaration_name(decl: &crate::syntax::ast::Declaration) -> String { | Declaration::Use(_) => "use".to_string(), | Declaration::Concept(c) => c.name.clone(), | Declaration::SubConcept(sc) => sc.name.clone(), - | Declaration::ConceptComparison(cc) => cc.name.clone(), + | Declaration::Definition(cc) => cc.name.clone(), } } @@ -1721,7 +1721,7 @@ fn get_declaration_type_name(decl: &crate::syntax::ast::Declaration) -> &'static | Declaration::Use(_) => "Use", | Declaration::Concept(_) => "Concept", | Declaration::SubConcept(_) => "Sub Concept", - | Declaration::ConceptComparison(_) => "Concept Comparison", + | Declaration::Definition(_) => "Definition", } } @@ -1954,7 +1954,7 @@ fn get_declaration_span(decl: &crate::syntax::ast::Declaration) -> Span { | Declaration::Use(u) => u.span.clone(), | Declaration::Concept(c) => c.span.clone(), | Declaration::SubConcept(sc) => sc.span.clone(), - | Declaration::ConceptComparison(cc) => cc.span.clone(), + | Declaration::Definition(cc) => cc.span.clone(), } } diff --git a/src/lsp/completion.rs b/src/lsp/completion.rs index 1769cc5..75eaae4 100644 --- a/src/lsp/completion.rs +++ b/src/lsp/completion.rs @@ -685,7 +685,7 @@ fn top_level_keyword_completions() -> Vec { keyword_item("use", "Import declarations", "use ${1:path::to::item};"), keyword_item("concept", "Define an algebraic data type", "concept ${1:Name};"), keyword_item("sub_concept", "Define a sub-type", "sub_concept ${1:Parent}.${2:Name} {\n $0\n}"), - keyword_item("concept_comparison", "Pattern match on concepts", "concept_comparison ${1:Name} {\n $0\n}"), + keyword_item("definition", "Pattern match on concepts", "definition ${1:Name} {\n $0\n}"), ] } diff --git a/src/lsp/completion_tests.rs b/src/lsp/completion_tests.rs index 739a600..fb46a45 100644 --- a/src/lsp/completion_tests.rs +++ b/src/lsp/completion_tests.rs @@ -269,8 +269,8 @@ character Bob {}"#; "Should have sub_concept keyword" ); assert!( - items.iter().any(|item| item.label == "concept_comparison"), - "Should have concept_comparison keyword" + items.iter().any(|item| item.label == "definition"), + "Should have definition keyword" ); // Check snippets have correct format diff --git a/src/lsp/hover.rs b/src/lsp/hover.rs index 666b1e1..4e657af 100644 --- a/src/lsp/hover.rs +++ b/src/lsp/hover.rs @@ -177,9 +177,7 @@ fn get_declaration_name(decl: &Declaration) -> Option { | Declaration::Schedule(s) => Some(s.name.clone()), | Declaration::Behavior(b) => Some(b.name.clone()), | Declaration::Use(_) => None, - | Declaration::Concept(_) | - Declaration::SubConcept(_) | - Declaration::ConceptComparison(_) => None, // TODO: Implement hover for type system + | Declaration::Concept(_) | Declaration::SubConcept(_) | Declaration::Definition(_) => None, /* TODO: Implement hover for type system */ } } @@ -198,7 +196,7 @@ fn format_declaration_hover(decl: &Declaration, _kind: &DeclKind) -> Hover { | Declaration::Use(_) => "**use** declaration".to_string(), | Declaration::Concept(_) => "**concept** declaration".to_string(), | Declaration::SubConcept(_) => "**sub_concept** declaration".to_string(), - | Declaration::ConceptComparison(_) => "**concept_comparison** declaration".to_string(), + | Declaration::Definition(_) => "**definition** declaration".to_string(), }; Hover { diff --git a/src/lsp/semantic_tokens.rs b/src/lsp/semantic_tokens.rs index 5d59883..154b982 100644 --- a/src/lsp/semantic_tokens.rs +++ b/src/lsp/semantic_tokens.rs @@ -453,7 +453,7 @@ pub fn get_semantic_tokens(doc: &Document) -> Option { }, } }, - | Declaration::ConceptComparison(comparison) => { + | Declaration::Definition(comparison) => { // Highlight comparison name as TYPE builder.add_token( comparison.span.start_line, diff --git a/src/lsp/semantic_tokens_tests.rs b/src/lsp/semantic_tokens_tests.rs index 9651404..81d4035 100644 --- a/src/lsp/semantic_tokens_tests.rs +++ b/src/lsp/semantic_tokens_tests.rs @@ -109,9 +109,9 @@ mod tests { } #[test] - fn test_concept_comparison_semantic_tokens() { + fn test_definition_semantic_tokens() { // LALRPOP parser: FieldCondition uses simple Ident, not dotted path - let source = r#"concept_comparison BakeryType { + let source = r#"definition BakeryType { Bakery: { Size: any }, diff --git a/src/lsp/symbols.rs b/src/lsp/symbols.rs index e5183a9..08b1a98 100644 --- a/src/lsp/symbols.rs +++ b/src/lsp/symbols.rs @@ -90,9 +90,9 @@ fn extract_declaration_symbol( extract_field_symbols(&s.fields, positions), ), | Declaration::Use(_) => return None, // Use statements don't create symbols - | Declaration::Concept(_) | - Declaration::SubConcept(_) | - Declaration::ConceptComparison(_) => return None, // TODO: Implement symbols for type system + | Declaration::Concept(_) | Declaration::SubConcept(_) | Declaration::Definition(_) => { + return None + }, // TODO: Implement symbols for type system }; let (start_line, start_col) = positions.offset_to_position(span.start); diff --git a/src/resolve/convert.rs b/src/resolve/convert.rs index 9a33a4d..0101562 100644 --- a/src/resolve/convert.rs +++ b/src/resolve/convert.rs @@ -97,7 +97,7 @@ pub fn convert_file_with_all_files( }, | ast::Declaration::Concept(_) | ast::Declaration::SubConcept(_) | - ast::Declaration::ConceptComparison(_) => { + ast::Declaration::Definition(_) => { // TODO: Implement conversion for type system declarations }, } diff --git a/src/resolve/names.rs b/src/resolve/names.rs index d089045..146f294 100644 --- a/src/resolve/names.rs +++ b/src/resolve/names.rs @@ -139,8 +139,8 @@ impl NameTable { | Declaration::Species(s) => (s.name.clone(), DeclKind::Species, s.span.clone()), | Declaration::Concept(_) | Declaration::SubConcept(_) | - Declaration::ConceptComparison(_) => continue, /* TODO: Implement name resolution - * for type system */ + Declaration::Definition(_) => continue, /* TODO: Implement name resolution + * for type system */ }; // For now, qualified path is just the name diff --git a/src/resolve/references.rs b/src/resolve/references.rs index e973677..c6c6a0b 100644 --- a/src/resolve/references.rs +++ b/src/resolve/references.rs @@ -186,9 +186,7 @@ fn find_references_in_declaration( | Declaration::Use(_) => { // Use statements are handled separately }, - | Declaration::Concept(_) | - Declaration::SubConcept(_) | - Declaration::ConceptComparison(_) => { + | Declaration::Concept(_) | Declaration::SubConcept(_) | Declaration::Definition(_) => { // TODO: Implement reference finding for type system }, } diff --git a/src/resolve/validate.rs b/src/resolve/validate.rs index ad627df..ec4acc9 100644 --- a/src/resolve/validate.rs +++ b/src/resolve/validate.rs @@ -542,30 +542,27 @@ pub fn validate_species_type_invariance(file: &File, collector: &mut ErrorCollec } } -/// Validate concept_comparison patterns against the concept registry +/// Validate definition patterns against the concept registry /// /// Checks: -/// 1. The concept_comparison name references an existing concept +/// 1. The definition name references an existing concept /// 2. All variant names in patterns exist in the concept's enum sub-concepts /// 3. Patterns are exhaustive (all variants are covered) -pub fn validate_concept_comparison_patterns( +pub fn validate_definition_patterns( file: &File, registry: &crate::resolve::types::ConceptRegistry, collector: &mut ErrorCollector, ) { for decl in &file.declarations { - if let Declaration::ConceptComparison(comp) = decl { + if let Declaration::Definition(comp) = decl { // Check that the concept exists let concept = match registry.lookup_concept(&comp.name) { | Some(c) => c, | None => { collector.add(ResolveError::ValidationError { - message: format!( - "Concept '{}' not found for concept_comparison", - comp.name - ), + message: format!("Concept '{}' not found for definition", comp.name), help: Some(format!( - "Add 'concept {}' before defining a concept_comparison for it.", + "Add 'concept {}' before defining a definition for it.", comp.name )), }); @@ -646,7 +643,7 @@ pub fn validate_concept_comparison_patterns( sorted.sort(); collector.add(ResolveError::ValidationError { message: format!( - "concept_comparison '{}' is not exhaustive: missing variants {}", + "definition '{}' is not exhaustive: missing variants {}", comp.name, sorted .iter() @@ -680,7 +677,7 @@ pub fn validate_file(file: &File, action_registry: &HashSet) -> Result<( validate_sub_concept_parents(file, &mut collector); validate_species_type_invariance(file, &mut collector); let concept_registry = crate::resolve::types::ConceptRegistry::from_file(file); - validate_concept_comparison_patterns(file, &concept_registry, &mut collector); + validate_definition_patterns(file, &concept_registry, &mut collector); for decl in &file.declarations { match decl { @@ -1189,7 +1186,7 @@ mod tests { use crate::resolve::types::ConceptRegistry; - fn make_concept_comparison_file() -> File { + fn make_definition_file() -> File { File { declarations: vec![ Declaration::Concept(ConceptDecl { @@ -1213,10 +1210,10 @@ mod tests { } #[test] - fn test_concept_comparison_valid_exhaustive() { - let mut file = make_concept_comparison_file(); + fn test_definition_valid_exhaustive() { + let mut file = make_definition_file(); file.declarations - .push(Declaration::ConceptComparison(ConceptComparisonDecl { + .push(Declaration::Definition(DefinitionDecl { name: "Cup".to_string(), variants: vec![ VariantPattern { @@ -1240,15 +1237,15 @@ mod tests { let registry = ConceptRegistry::from_file(&file); let mut collector = ErrorCollector::new(); - validate_concept_comparison_patterns(&file, ®istry, &mut collector); + validate_definition_patterns(&file, ®istry, &mut collector); assert!(!collector.has_errors()); } #[test] - fn test_concept_comparison_not_exhaustive() { - let mut file = make_concept_comparison_file(); + fn test_definition_not_exhaustive() { + let mut file = make_definition_file(); file.declarations - .push(Declaration::ConceptComparison(ConceptComparisonDecl { + .push(Declaration::Definition(DefinitionDecl { name: "Cup".to_string(), variants: vec![ VariantPattern { @@ -1263,15 +1260,15 @@ mod tests { let registry = ConceptRegistry::from_file(&file); let mut collector = ErrorCollector::new(); - validate_concept_comparison_patterns(&file, ®istry, &mut collector); + validate_definition_patterns(&file, ®istry, &mut collector); assert!(collector.has_errors()); } #[test] - fn test_concept_comparison_unknown_variant() { - let mut file = make_concept_comparison_file(); + fn test_definition_unknown_variant() { + let mut file = make_definition_file(); file.declarations - .push(Declaration::ConceptComparison(ConceptComparisonDecl { + .push(Declaration::Definition(DefinitionDecl { name: "Cup".to_string(), variants: vec![ VariantPattern { @@ -1300,14 +1297,14 @@ mod tests { let registry = ConceptRegistry::from_file(&file); let mut collector = ErrorCollector::new(); - validate_concept_comparison_patterns(&file, ®istry, &mut collector); + validate_definition_patterns(&file, ®istry, &mut collector); assert!(collector.has_errors()); } #[test] - fn test_concept_comparison_missing_concept() { + fn test_definition_missing_concept() { let file = File { - declarations: vec![Declaration::ConceptComparison(ConceptComparisonDecl { + declarations: vec![Declaration::Definition(DefinitionDecl { name: "NonExistent".to_string(), variants: vec![], span: Span::new(0, 100), @@ -1316,15 +1313,15 @@ mod tests { let registry = ConceptRegistry::from_file(&file); let mut collector = ErrorCollector::new(); - validate_concept_comparison_patterns(&file, ®istry, &mut collector); + validate_definition_patterns(&file, ®istry, &mut collector); assert!(collector.has_errors()); } #[test] - fn test_concept_comparison_with_field_conditions() { - let mut file = make_concept_comparison_file(); + fn test_definition_with_field_conditions() { + let mut file = make_definition_file(); file.declarations - .push(Declaration::ConceptComparison(ConceptComparisonDecl { + .push(Declaration::Definition(DefinitionDecl { name: "Cup".to_string(), variants: vec![ VariantPattern { @@ -1356,7 +1353,7 @@ mod tests { let registry = ConceptRegistry::from_file(&file); let mut collector = ErrorCollector::new(); - validate_concept_comparison_patterns(&file, ®istry, &mut collector); + validate_definition_patterns(&file, ®istry, &mut collector); assert!(!collector.has_errors()); } } diff --git a/src/syntax/ast.rs b/src/syntax/ast.rs index 17714ca..b9ac5a0 100644 --- a/src/syntax/ast.rs +++ b/src/syntax/ast.rs @@ -71,7 +71,7 @@ pub enum Declaration { Species(Species), Concept(ConceptDecl), SubConcept(SubConceptDecl), - ConceptComparison(ConceptComparisonDecl), + Definition(DefinitionDecl), } /// Use statement for importing definitions @@ -442,9 +442,9 @@ pub enum SubConceptKind { Record { fields: Vec }, } -/// Concept comparison - compile-time pattern matching for concept variants +/// Definition - compile-time pattern matching for concept variants #[derive(Debug, Clone, PartialEq)] -pub struct ConceptComparisonDecl { +pub struct DefinitionDecl { pub name: String, pub variants: Vec, pub span: Span, diff --git a/src/syntax/lexer.rs b/src/syntax/lexer.rs index cd466f0..9234edf 100644 --- a/src/syntax/lexer.rs +++ b/src/syntax/lexer.rs @@ -34,8 +34,8 @@ pub enum Token { Concept, #[token("sub_concept")] SubConcept, - #[token("concept_comparison")] - ConceptComparison, + #[token("definition")] + Definition, #[token("any")] Any, #[token("requires")] @@ -521,7 +521,7 @@ Second prose block content. #[test] fn test_type_system_keywords() { - let input = "concept sub_concept concept_comparison any"; + let input = "concept sub_concept definition any"; let lexer = Lexer::new(input); let tokens: Vec = lexer.map(|(_, tok, _)| tok).collect(); @@ -530,7 +530,7 @@ Second prose block content. vec![ Token::Concept, Token::SubConcept, - Token::ConceptComparison, + Token::Definition, Token::Any, ] ); diff --git a/src/syntax/parser.lalrpop b/src/syntax/parser.lalrpop index 7a5aef8..a97b7a5 100644 --- a/src/syntax/parser.lalrpop +++ b/src/syntax/parser.lalrpop @@ -22,7 +22,7 @@ Declaration: Declaration = { => Declaration::Species(sp), => Declaration::Concept(concept), => Declaration::SubConcept(sub), - => Declaration::ConceptComparison(comp), + => Declaration::Definition(comp), }; // ===== Use declarations ===== @@ -803,8 +803,8 @@ SubConceptDecl: SubConceptDecl = { }, }; -ConceptComparisonDecl: ConceptComparisonDecl = { - "concept_comparison" "{" > "}" => ConceptComparisonDecl { +DefinitionDecl: DefinitionDecl = { + "definition" "{" > "}" => DefinitionDecl { name, variants, span: Span::new(start, end), @@ -976,7 +976,7 @@ extern { "species" => Token::Species, "concept" => Token::Concept, "sub_concept" => Token::SubConcept, - "concept_comparison" => Token::ConceptComparison, + "definition" => Token::Definition, "any" => Token::Any, "requires" => Token::Requires, "state" => Token::State, diff --git a/src/syntax/parser.rs b/src/syntax/parser.rs index 41e415f..c882e02 100644 --- a/src/syntax/parser.rs +++ b/src/syntax/parser.rs @@ -75,7 +75,7 @@ mod __parse__File { Variant45(Vec), Variant46(Vec), Variant47(Vec), - Variant48(ConceptComparisonDecl), + Variant48(DefinitionDecl), Variant49(ConceptDecl), Variant50(Declaration), Variant51(alloc::vec::Vec), @@ -2734,7 +2734,7 @@ mod __parse__File { r###""species""###, r###""concept""###, r###""sub_concept""###, - r###""concept_comparison""###, + r###""definition""###, r###""any""###, r###""requires""###, r###""state""###, @@ -2949,7 +2949,7 @@ mod __parse__File { Token::Species if true => Some(9), Token::Concept if true => Some(10), Token::SubConcept if true => Some(11), - Token::ConceptComparison if true => Some(12), + Token::Definition if true => Some(12), Token::Any if true => Some(13), Token::Requires if true => Some(14), Token::State if true => Some(15), @@ -6674,7 +6674,7 @@ mod __parse__File { fn __pop_Variant48< >( __symbols: &mut alloc::vec::Vec<(usize,__Symbol<>,usize)> - ) -> (usize, ConceptComparisonDecl, usize) + ) -> (usize, DefinitionDecl, usize) { match __symbols.pop() { Some((__l, __Symbol::Variant48(__v), __r)) => (__l, __v, __r), @@ -9948,7 +9948,7 @@ mod __parse__File { _: core::marker::PhantomData<()>, ) -> (usize, usize) { - // ConceptComparisonDecl = "concept_comparison", Ident, "{", Comma, "}" => ActionFn(418); + // DefinitionDecl = "definition", Ident, "{", Comma, "}" => ActionFn(418); assert!(__symbols.len() >= 5); let __sym4 = __pop_Variant0(__symbols); let __sym3 = __pop_Variant47(__symbols); @@ -10225,7 +10225,7 @@ mod __parse__File { _: core::marker::PhantomData<()>, ) -> (usize, usize) { - // Declaration = ConceptComparisonDecl => ActionFn(14); + // Declaration = DefinitionDecl => ActionFn(14); let __sym0 = __pop_Variant48(__symbols); let __start = __sym0.0; let __end = __sym0.2; @@ -13896,8 +13896,8 @@ fn __action13((_, sub, _): (usize, SubConceptDecl, usize)) -> Declaration { clippy::needless_lifetimes, clippy::just_underscores_and_digits )] -fn __action14((_, comp, _): (usize, ConceptComparisonDecl, usize)) -> Declaration { - Declaration::ConceptComparison(comp) +fn __action14((_, comp, _): (usize, DefinitionDecl, usize)) -> Declaration { + Declaration::Definition(comp) } #[allow( @@ -15888,8 +15888,8 @@ fn __action138( (_, variants, _): (usize, Vec, usize), (_, _, _): (usize, Token, usize), (_, end, _): (usize, usize, usize), -) -> ConceptComparisonDecl { - ConceptComparisonDecl { +) -> DefinitionDecl { + DefinitionDecl { name, variants, span: Span::new(start, end), @@ -19031,7 +19031,7 @@ fn __action374( __3: (usize, Vec, usize), __4: (usize, Token, usize), __5: (usize, usize, usize), -) -> ConceptComparisonDecl { +) -> DefinitionDecl { let __start0 = __0.0; let __end0 = __0.0; let __temp0 = __action228(&__start0, &__end0); @@ -19945,7 +19945,7 @@ fn __action418( __2: (usize, Token, usize), __3: (usize, Vec, usize), __4: (usize, Token, usize), -) -> ConceptComparisonDecl { +) -> DefinitionDecl { let __start0 = __4.2; let __end0 = __4.2; let __temp0 = __action227(&__start0, &__end0); diff --git a/src/syntax/prop_tests.rs b/src/syntax/prop_tests.rs index 01d5005..ee97c7f 100644 --- a/src/syntax/prop_tests.rs +++ b/src/syntax/prop_tests.rs @@ -61,7 +61,7 @@ fn valid_ident() -> impl Strategy { // Type system keywords (v0.3.0) "concept" | "sub_concept" | - "concept_comparison" | + "definition" | "any" ) }) diff --git a/tests/tree_sitter_integration.rs b/tests/tree_sitter_integration.rs index 669464d..f53723e 100644 --- a/tests/tree_sitter_integration.rs +++ b/tests/tree_sitter_integration.rs @@ -288,7 +288,7 @@ fn test_type_system_keywords_parse() { fn test_any_type_highlights_correctly() { // Create a minimal test file with any_type usage let test_content = r#" -concept_comparison SkillLevel { +definition SkillLevel { Novice: { skill: any }, Expert: { skill: Tier is Expert } } diff --git a/tree-sitter-storybook/grammar.js b/tree-sitter-storybook/grammar.js index 25720c8..19f6e1d 100644 --- a/tree-sitter-storybook/grammar.js +++ b/tree-sitter-storybook/grammar.js @@ -50,7 +50,7 @@ module.exports = grammar({ $.enum_declaration, $.concept_declaration, $.sub_concept, - $.concept_comparison + $.definition ), // Use declarations @@ -548,9 +548,9 @@ module.exports = grammar({ any_type: $ => 'any', - // Concept comparison - compile-time pattern matching - concept_comparison: $ => seq( - 'concept_comparison', + // Definition - compile-time pattern matching + definition: $ => seq( + 'definition', field('name', $.identifier), '{', commaSep1($.variant_pattern), diff --git a/tree-sitter-storybook/queries/highlights.scm b/tree-sitter-storybook/queries/highlights.scm index cc23da7..b6d2d7a 100644 --- a/tree-sitter-storybook/queries/highlights.scm +++ b/tree-sitter-storybook/queries/highlights.scm @@ -20,7 +20,7 @@ "state" "concept" "sub_concept" - "concept_comparison" + "definition" ] @keyword.declaration ; Keywords - Control flow and modifiers @@ -83,7 +83,7 @@ (concept_declaration name: (identifier) @type.concept) (sub_concept parent: (identifier) @type.concept) (sub_concept name: (identifier) @type.sub_concept) -(concept_comparison name: (identifier) @type.concept_comparison) +(definition name: (identifier) @type.definition) (variant_pattern name: (identifier) @type.variant) (template_declaration species: (identifier) @type.builtin) diff --git a/tree-sitter-storybook/queries/indents.scm b/tree-sitter-storybook/queries/indents.scm index 17002fe..0ce4a6d 100644 --- a/tree-sitter-storybook/queries/indents.scm +++ b/tree-sitter-storybook/queries/indents.scm @@ -40,7 +40,7 @@ (sequence_node) (decorator_node) (sub_concept) - (concept_comparison) + (definition) (variant_pattern) ] @indent.begin diff --git a/tree-sitter-storybook/queries/outline.scm b/tree-sitter-storybook/queries/outline.scm index 79bccbe..3f2857f 100644 --- a/tree-sitter-storybook/queries/outline.scm +++ b/tree-sitter-storybook/queries/outline.scm @@ -66,7 +66,7 @@ name: (identifier) @name ) @symbol.sub_concept -; Concept comparisons -(concept_comparison +; Definitions +(definition name: (identifier) @name -) @symbol.concept_comparison +) @symbol.definition diff --git a/tree-sitter-storybook/src/grammar.json b/tree-sitter-storybook/src/grammar.json index 3e34e6b..1a8b42e 100644 --- a/tree-sitter-storybook/src/grammar.json +++ b/tree-sitter-storybook/src/grammar.json @@ -103,7 +103,7 @@ }, { "type": "SYMBOL", - "name": "concept_comparison" + "name": "definition" } ] }, @@ -2657,12 +2657,12 @@ "type": "STRING", "value": "any" }, - "concept_comparison": { + "definition": { "type": "SEQ", "members": [ { "type": "STRING", - "value": "concept_comparison" + "value": "definition" }, { "type": "FIELD", diff --git a/tree-sitter-storybook/src/node-types.json b/tree-sitter-storybook/src/node-types.json index 35a24cd..e2677ea 100644 --- a/tree-sitter-storybook/src/node-types.json +++ b/tree-sitter-storybook/src/node-types.json @@ -308,32 +308,6 @@ ] } }, - { - "type": "concept_comparison", - "named": true, - "fields": { - "name": { - "multiple": false, - "required": true, - "types": [ - { - "type": "identifier", - "named": true - } - ] - } - }, - "children": { - "multiple": true, - "required": true, - "types": [ - { - "type": "variant_pattern", - "named": true - } - ] - } - }, { "type": "concept_declaration", "named": true, @@ -383,11 +357,11 @@ "named": true }, { - "type": "concept_comparison", + "type": "concept_declaration", "named": true }, { - "type": "concept_declaration", + "type": "definition", "named": true }, { @@ -493,6 +467,32 @@ ] } }, + { + "type": "definition", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "variant_pattern", + "named": true + } + ] + } + }, { "type": "dotted_path", "named": true, @@ -2104,11 +2104,11 @@ "named": false }, { - "type": "concept_comparison", + "type": "cooldown", "named": false }, { - "type": "cooldown", + "type": "definition", "named": false }, { diff --git a/tree-sitter-storybook/src/parser.c b/tree-sitter-storybook/src/parser.c index 3b2d2ba..e74e89c 100644 --- a/tree-sitter-storybook/src/parser.c +++ b/tree-sitter-storybook/src/parser.c @@ -90,7 +90,7 @@ enum ts_symbol_identifiers { anon_sym_concept = 68, anon_sym_sub_concept = 69, sym_any_type = 70, - anon_sym_concept_comparison = 71, + anon_sym_definition = 71, anon_sym_or = 72, anon_sym_is = 73, anon_sym_and = 74, @@ -167,7 +167,7 @@ enum ts_symbol_identifiers { sym_sub_concept_enum_body = 145, sym_sub_concept_record_body = 146, sym_sub_concept_field = 147, - sym_concept_comparison = 148, + sym_definition = 148, sym_variant_pattern = 149, sym_field_condition = 150, sym_is_condition = 151, @@ -199,7 +199,7 @@ enum ts_symbol_identifiers { aux_sym_species_body_repeat1 = 177, aux_sym_species_body_repeat2 = 178, aux_sym_sub_concept_record_body_repeat1 = 179, - aux_sym_concept_comparison_repeat1 = 180, + aux_sym_definition_repeat1 = 180, aux_sym_variant_pattern_repeat1 = 181, aux_sym_is_condition_repeat1 = 182, }; @@ -276,7 +276,7 @@ static const char * const ts_symbol_names[] = { [anon_sym_concept] = "concept", [anon_sym_sub_concept] = "sub_concept", [sym_any_type] = "any_type", - [anon_sym_concept_comparison] = "concept_comparison", + [anon_sym_definition] = "definition", [anon_sym_or] = "or", [anon_sym_is] = "is", [anon_sym_and] = "and", @@ -353,7 +353,7 @@ static const char * const ts_symbol_names[] = { [sym_sub_concept_enum_body] = "sub_concept_enum_body", [sym_sub_concept_record_body] = "sub_concept_record_body", [sym_sub_concept_field] = "sub_concept_field", - [sym_concept_comparison] = "concept_comparison", + [sym_definition] = "definition", [sym_variant_pattern] = "variant_pattern", [sym_field_condition] = "field_condition", [sym_is_condition] = "is_condition", @@ -385,7 +385,7 @@ static const char * const ts_symbol_names[] = { [aux_sym_species_body_repeat1] = "species_body_repeat1", [aux_sym_species_body_repeat2] = "species_body_repeat2", [aux_sym_sub_concept_record_body_repeat1] = "sub_concept_record_body_repeat1", - [aux_sym_concept_comparison_repeat1] = "concept_comparison_repeat1", + [aux_sym_definition_repeat1] = "definition_repeat1", [aux_sym_variant_pattern_repeat1] = "variant_pattern_repeat1", [aux_sym_is_condition_repeat1] = "is_condition_repeat1", }; @@ -462,7 +462,7 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_concept] = anon_sym_concept, [anon_sym_sub_concept] = anon_sym_sub_concept, [sym_any_type] = sym_any_type, - [anon_sym_concept_comparison] = anon_sym_concept_comparison, + [anon_sym_definition] = anon_sym_definition, [anon_sym_or] = anon_sym_or, [anon_sym_is] = anon_sym_is, [anon_sym_and] = anon_sym_and, @@ -539,7 +539,7 @@ static const TSSymbol ts_symbol_map[] = { [sym_sub_concept_enum_body] = sym_sub_concept_enum_body, [sym_sub_concept_record_body] = sym_sub_concept_record_body, [sym_sub_concept_field] = sym_sub_concept_field, - [sym_concept_comparison] = sym_concept_comparison, + [sym_definition] = sym_definition, [sym_variant_pattern] = sym_variant_pattern, [sym_field_condition] = sym_field_condition, [sym_is_condition] = sym_is_condition, @@ -571,7 +571,7 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_species_body_repeat1] = aux_sym_species_body_repeat1, [aux_sym_species_body_repeat2] = aux_sym_species_body_repeat2, [aux_sym_sub_concept_record_body_repeat1] = aux_sym_sub_concept_record_body_repeat1, - [aux_sym_concept_comparison_repeat1] = aux_sym_concept_comparison_repeat1, + [aux_sym_definition_repeat1] = aux_sym_definition_repeat1, [aux_sym_variant_pattern_repeat1] = aux_sym_variant_pattern_repeat1, [aux_sym_is_condition_repeat1] = aux_sym_is_condition_repeat1, }; @@ -861,7 +861,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [anon_sym_concept_comparison] = { + [anon_sym_definition] = { .visible = true, .named = false, }, @@ -1169,7 +1169,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_concept_comparison] = { + [sym_definition] = { .visible = true, .named = true, }, @@ -1297,7 +1297,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = false, }, - [aux_sym_concept_comparison_repeat1] = { + [aux_sym_definition_repeat1] = { .visible = false, .named = false, }, @@ -2448,831 +2448,828 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { 'a', 1, 'b', 2, 'c', 3, - 'e', 4, - 'f', 5, - 'i', 6, - 'l', 7, - 'm', 8, - 'n', 9, - 'o', 10, - 'r', 11, - 's', 12, - 't', 13, - 'u', 14, - 'w', 15, + 'd', 4, + 'e', 5, + 'f', 6, + 'i', 7, + 'l', 8, + 'm', 9, + 'n', 10, + 'o', 11, + 'r', 12, + 's', 13, + 't', 14, + 'u', 15, + 'w', 16, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ') SKIP(0); END_STATE(); case 1: - if (lookahead == 'n') ADVANCE(16); - if (lookahead == 'p') ADVANCE(17); - if (lookahead == 's') ADVANCE(18); + if (lookahead == 'n') ADVANCE(17); + if (lookahead == 'p') ADVANCE(18); + if (lookahead == 's') ADVANCE(19); END_STATE(); case 2: - if (lookahead == 'e') ADVANCE(19); - if (lookahead == 'l') ADVANCE(20); + if (lookahead == 'e') ADVANCE(20); + if (lookahead == 'l') ADVANCE(21); END_STATE(); case 3: - if (lookahead == 'h') ADVANCE(21); - if (lookahead == 'o') ADVANCE(22); + if (lookahead == 'h') ADVANCE(22); + if (lookahead == 'o') ADVANCE(23); END_STATE(); case 4: - if (lookahead == 'n') ADVANCE(23); + if (lookahead == 'e') ADVANCE(24); END_STATE(); case 5: - if (lookahead == 'a') ADVANCE(24); - if (lookahead == 'r') ADVANCE(25); + if (lookahead == 'n') ADVANCE(25); END_STATE(); case 6: - if (lookahead == 'f') ADVANCE(26); - if (lookahead == 'n') ADVANCE(27); - if (lookahead == 's') ADVANCE(28); + if (lookahead == 'a') ADVANCE(26); + if (lookahead == 'r') ADVANCE(27); END_STATE(); case 7: - if (lookahead == 'i') ADVANCE(29); - if (lookahead == 'o') ADVANCE(30); + if (lookahead == 'f') ADVANCE(28); + if (lookahead == 'n') ADVANCE(29); + if (lookahead == 's') ADVANCE(30); END_STATE(); case 8: - if (lookahead == 'o') ADVANCE(31); - END_STATE(); - case 9: + if (lookahead == 'i') ADVANCE(31); if (lookahead == 'o') ADVANCE(32); END_STATE(); + case 9: + if (lookahead == 'o') ADVANCE(33); + END_STATE(); case 10: - if (lookahead == 'n') ADVANCE(33); - if (lookahead == 'r') ADVANCE(34); - if (lookahead == 't') ADVANCE(35); - if (lookahead == 'v') ADVANCE(36); + if (lookahead == 'o') ADVANCE(34); END_STATE(); case 11: - if (lookahead == 'e') ADVANCE(37); + if (lookahead == 'n') ADVANCE(35); + if (lookahead == 'r') ADVANCE(36); + if (lookahead == 't') ADVANCE(37); + if (lookahead == 'v') ADVANCE(38); END_STATE(); case 12: - if (lookahead == 'c') ADVANCE(38); if (lookahead == 'e') ADVANCE(39); - if (lookahead == 'p') ADVANCE(40); - if (lookahead == 't') ADVANCE(41); - if (lookahead == 'u') ADVANCE(42); END_STATE(); case 13: - if (lookahead == 'e') ADVANCE(43); - if (lookahead == 'h') ADVANCE(44); - if (lookahead == 'i') ADVANCE(45); - if (lookahead == 'r') ADVANCE(46); + if (lookahead == 'c') ADVANCE(40); + if (lookahead == 'e') ADVANCE(41); + if (lookahead == 'p') ADVANCE(42); + if (lookahead == 't') ADVANCE(43); + if (lookahead == 'u') ADVANCE(44); END_STATE(); case 14: - if (lookahead == 's') ADVANCE(47); + if (lookahead == 'e') ADVANCE(45); + if (lookahead == 'h') ADVANCE(46); + if (lookahead == 'i') ADVANCE(47); + if (lookahead == 'r') ADVANCE(48); END_STATE(); case 15: - if (lookahead == 'h') ADVANCE(48); + if (lookahead == 's') ADVANCE(49); END_STATE(); case 16: - if (lookahead == 'd') ADVANCE(49); - if (lookahead == 'y') ADVANCE(50); + if (lookahead == 'h') ADVANCE(50); END_STATE(); case 17: - if (lookahead == 'p') ADVANCE(51); + if (lookahead == 'd') ADVANCE(51); + if (lookahead == 'y') ADVANCE(52); END_STATE(); case 18: - ACCEPT_TOKEN(anon_sym_as); + if (lookahead == 'p') ADVANCE(53); END_STATE(); case 19: - if (lookahead == 'h') ADVANCE(52); + ACCEPT_TOKEN(anon_sym_as); END_STATE(); case 20: - if (lookahead == 'o') ADVANCE(53); + if (lookahead == 'h') ADVANCE(54); END_STATE(); case 21: - if (lookahead == 'a') ADVANCE(54); if (lookahead == 'o') ADVANCE(55); END_STATE(); case 22: - if (lookahead == 'n') ADVANCE(56); + if (lookahead == 'a') ADVANCE(56); if (lookahead == 'o') ADVANCE(57); END_STATE(); case 23: - if (lookahead == 't') ADVANCE(58); - if (lookahead == 'u') ADVANCE(59); + if (lookahead == 'n') ADVANCE(58); + if (lookahead == 'o') ADVANCE(59); END_STATE(); case 24: - if (lookahead == 'i') ADVANCE(60); - if (lookahead == 'l') ADVANCE(61); + if (lookahead == 'f') ADVANCE(60); END_STATE(); case 25: - if (lookahead == 'o') ADVANCE(62); + if (lookahead == 't') ADVANCE(61); + if (lookahead == 'u') ADVANCE(62); END_STATE(); case 26: - ACCEPT_TOKEN(anon_sym_if); + if (lookahead == 'i') ADVANCE(63); + if (lookahead == 'l') ADVANCE(64); END_STATE(); case 27: - if (lookahead == 'c') ADVANCE(63); - if (lookahead == 's') ADVANCE(64); - if (lookahead == 'v') ADVANCE(65); + if (lookahead == 'o') ADVANCE(65); END_STATE(); case 28: - ACCEPT_TOKEN(anon_sym_is); + ACCEPT_TOKEN(anon_sym_if); END_STATE(); case 29: - if (lookahead == 'f') ADVANCE(66); + if (lookahead == 'c') ADVANCE(66); + if (lookahead == 's') ADVANCE(67); + if (lookahead == 'v') ADVANCE(68); END_STATE(); case 30: - if (lookahead == 'c') ADVANCE(67); + ACCEPT_TOKEN(anon_sym_is); END_STATE(); case 31: - if (lookahead == 'd') ADVANCE(68); + if (lookahead == 'f') ADVANCE(69); END_STATE(); case 32: - if (lookahead == 't') ADVANCE(69); + if (lookahead == 'c') ADVANCE(70); END_STATE(); case 33: - ACCEPT_TOKEN(anon_sym_on); + if (lookahead == 'd') ADVANCE(71); END_STATE(); case 34: - ACCEPT_TOKEN(anon_sym_or); + if (lookahead == 't') ADVANCE(72); END_STATE(); case 35: - if (lookahead == 'h') ADVANCE(70); + ACCEPT_TOKEN(anon_sym_on); END_STATE(); case 36: - if (lookahead == 'e') ADVANCE(71); + ACCEPT_TOKEN(anon_sym_or); END_STATE(); case 37: - if (lookahead == 'c') ADVANCE(72); - if (lookahead == 'l') ADVANCE(73); - if (lookahead == 'm') ADVANCE(74); - if (lookahead == 'p') ADVANCE(75); - if (lookahead == 'q') ADVANCE(76); - if (lookahead == 't') ADVANCE(77); + if (lookahead == 'h') ADVANCE(73); END_STATE(); case 38: - if (lookahead == 'h') ADVANCE(78); + if (lookahead == 'e') ADVANCE(74); END_STATE(); case 39: - if (lookahead == 'l') ADVANCE(79); + if (lookahead == 'c') ADVANCE(75); + if (lookahead == 'l') ADVANCE(76); + if (lookahead == 'm') ADVANCE(77); + if (lookahead == 'p') ADVANCE(78); + if (lookahead == 'q') ADVANCE(79); + if (lookahead == 't') ADVANCE(80); END_STATE(); case 40: - if (lookahead == 'e') ADVANCE(80); + if (lookahead == 'h') ADVANCE(81); END_STATE(); case 41: - if (lookahead == 'a') ADVANCE(81); - if (lookahead == 'r') ADVANCE(82); + if (lookahead == 'l') ADVANCE(82); END_STATE(); case 42: - if (lookahead == 'b') ADVANCE(83); - if (lookahead == 'c') ADVANCE(84); + if (lookahead == 'e') ADVANCE(83); END_STATE(); case 43: - if (lookahead == 'm') ADVANCE(85); + if (lookahead == 'a') ADVANCE(84); + if (lookahead == 'r') ADVANCE(85); END_STATE(); case 44: - if (lookahead == 'e') ADVANCE(86); + if (lookahead == 'b') ADVANCE(86); + if (lookahead == 'c') ADVANCE(87); END_STATE(); case 45: - if (lookahead == 'm') ADVANCE(87); + if (lookahead == 'm') ADVANCE(88); END_STATE(); case 46: - if (lookahead == 'u') ADVANCE(88); - END_STATE(); - case 47: if (lookahead == 'e') ADVANCE(89); END_STATE(); + case 47: + if (lookahead == 'm') ADVANCE(90); + END_STATE(); case 48: - if (lookahead == 'e') ADVANCE(90); + if (lookahead == 'u') ADVANCE(91); END_STATE(); case 49: - ACCEPT_TOKEN(anon_sym_and); + if (lookahead == 'e') ADVANCE(92); END_STATE(); case 50: - ACCEPT_TOKEN(sym_any_type); + if (lookahead == 'e') ADVANCE(93); END_STATE(); case 51: - if (lookahead == 'e') ADVANCE(91); + ACCEPT_TOKEN(anon_sym_and); END_STATE(); case 52: - if (lookahead == 'a') ADVANCE(92); + ACCEPT_TOKEN(sym_any_type); END_STATE(); case 53: - if (lookahead == 'c') ADVANCE(93); + if (lookahead == 'e') ADVANCE(94); END_STATE(); case 54: - if (lookahead == 'r') ADVANCE(94); + if (lookahead == 'a') ADVANCE(95); END_STATE(); case 55: - if (lookahead == 'o') ADVANCE(95); - END_STATE(); - case 56: if (lookahead == 'c') ADVANCE(96); END_STATE(); + case 56: + if (lookahead == 'r') ADVANCE(97); + END_STATE(); case 57: - if (lookahead == 'l') ADVANCE(97); + if (lookahead == 'o') ADVANCE(98); END_STATE(); case 58: - if (lookahead == 'e') ADVANCE(98); + if (lookahead == 'c') ADVANCE(99); END_STATE(); case 59: - if (lookahead == 'm') ADVANCE(99); - END_STATE(); - case 60: if (lookahead == 'l') ADVANCE(100); END_STATE(); + case 60: + if (lookahead == 'i') ADVANCE(101); + END_STATE(); case 61: - if (lookahead == 's') ADVANCE(101); + if (lookahead == 'e') ADVANCE(102); END_STATE(); case 62: - if (lookahead == 'm') ADVANCE(102); + if (lookahead == 'm') ADVANCE(103); END_STATE(); case 63: - if (lookahead == 'l') ADVANCE(103); + if (lookahead == 'l') ADVANCE(104); END_STATE(); case 64: - if (lookahead == 't') ADVANCE(104); + if (lookahead == 's') ADVANCE(105); END_STATE(); case 65: - if (lookahead == 'e') ADVANCE(105); + if (lookahead == 'm') ADVANCE(106); END_STATE(); case 66: - if (lookahead == 'e') ADVANCE(106); + if (lookahead == 'l') ADVANCE(107); END_STATE(); case 67: - if (lookahead == 'a') ADVANCE(107); + if (lookahead == 't') ADVANCE(108); END_STATE(); case 68: - if (lookahead == 'i') ADVANCE(108); - END_STATE(); - case 69: - ACCEPT_TOKEN(anon_sym_not); - END_STATE(); - case 70: if (lookahead == 'e') ADVANCE(109); END_STATE(); + case 69: + if (lookahead == 'e') ADVANCE(110); + END_STATE(); + case 70: + if (lookahead == 'a') ADVANCE(111); + END_STATE(); case 71: - if (lookahead == 'r') ADVANCE(110); + if (lookahead == 'i') ADVANCE(112); END_STATE(); case 72: - if (lookahead == 'u') ADVANCE(111); + ACCEPT_TOKEN(anon_sym_not); END_STATE(); case 73: - if (lookahead == 'a') ADVANCE(112); + if (lookahead == 'e') ADVANCE(113); END_STATE(); case 74: - if (lookahead == 'o') ADVANCE(113); + if (lookahead == 'r') ADVANCE(114); END_STATE(); case 75: - if (lookahead == 'e') ADVANCE(114); - END_STATE(); - case 76: if (lookahead == 'u') ADVANCE(115); END_STATE(); + case 76: + if (lookahead == 'a') ADVANCE(116); + END_STATE(); case 77: - if (lookahead == 'r') ADVANCE(116); + if (lookahead == 'o') ADVANCE(117); END_STATE(); case 78: - if (lookahead == 'e') ADVANCE(117); + if (lookahead == 'e') ADVANCE(118); END_STATE(); case 79: - if (lookahead == 'f') ADVANCE(118); + if (lookahead == 'u') ADVANCE(119); END_STATE(); case 80: - if (lookahead == 'c') ADVANCE(119); + if (lookahead == 'r') ADVANCE(120); END_STATE(); case 81: - if (lookahead == 't') ADVANCE(120); + if (lookahead == 'e') ADVANCE(121); END_STATE(); case 82: - if (lookahead == 'i') ADVANCE(121); + if (lookahead == 'f') ADVANCE(122); END_STATE(); case 83: - if (lookahead == '_') ADVANCE(122); - END_STATE(); - case 84: if (lookahead == 'c') ADVANCE(123); END_STATE(); + case 84: + if (lookahead == 't') ADVANCE(124); + END_STATE(); case 85: - if (lookahead == 'p') ADVANCE(124); + if (lookahead == 'i') ADVANCE(125); END_STATE(); case 86: - if (lookahead == 'n') ADVANCE(125); + if (lookahead == '_') ADVANCE(126); END_STATE(); case 87: - if (lookahead == 'e') ADVANCE(126); + if (lookahead == 'c') ADVANCE(127); END_STATE(); case 88: - if (lookahead == 'e') ADVANCE(127); + if (lookahead == 'p') ADVANCE(128); END_STATE(); case 89: - ACCEPT_TOKEN(anon_sym_use); - if (lookahead == 's') ADVANCE(128); - END_STATE(); - case 90: if (lookahead == 'n') ADVANCE(129); END_STATE(); + case 90: + if (lookahead == 'e') ADVANCE(130); + END_STATE(); case 91: - if (lookahead == 'n') ADVANCE(130); + if (lookahead == 'e') ADVANCE(131); END_STATE(); case 92: - if (lookahead == 'v') ADVANCE(131); + ACCEPT_TOKEN(anon_sym_use); + if (lookahead == 's') ADVANCE(132); END_STATE(); case 93: - if (lookahead == 'k') ADVANCE(132); + if (lookahead == 'n') ADVANCE(133); END_STATE(); case 94: - if (lookahead == 'a') ADVANCE(133); + if (lookahead == 'n') ADVANCE(134); END_STATE(); case 95: - if (lookahead == 's') ADVANCE(134); + if (lookahead == 'v') ADVANCE(135); END_STATE(); case 96: - if (lookahead == 'e') ADVANCE(135); + if (lookahead == 'k') ADVANCE(136); END_STATE(); case 97: - if (lookahead == 'd') ADVANCE(136); + if (lookahead == 'a') ADVANCE(137); END_STATE(); case 98: - if (lookahead == 'r') ADVANCE(137); + if (lookahead == 's') ADVANCE(138); END_STATE(); case 99: - ACCEPT_TOKEN(anon_sym_enum); - END_STATE(); - case 100: - if (lookahead == '_') ADVANCE(138); - END_STATE(); - case 101: if (lookahead == 'e') ADVANCE(139); END_STATE(); + case 100: + if (lookahead == 'd') ADVANCE(140); + END_STATE(); + case 101: + if (lookahead == 'n') ADVANCE(141); + END_STATE(); case 102: - ACCEPT_TOKEN(anon_sym_from); - END_STATE(); - case 103: - if (lookahead == 'u') ADVANCE(140); - END_STATE(); - case 104: - if (lookahead == 'i') ADVANCE(141); - END_STATE(); - case 105: if (lookahead == 'r') ADVANCE(142); END_STATE(); - case 106: + case 103: + ACCEPT_TOKEN(anon_sym_enum); + END_STATE(); + case 104: if (lookahead == '_') ADVANCE(143); END_STATE(); + case 105: + if (lookahead == 'e') ADVANCE(144); + END_STATE(); + case 106: + ACCEPT_TOKEN(anon_sym_from); + END_STATE(); case 107: - if (lookahead == 't') ADVANCE(144); + if (lookahead == 'u') ADVANCE(145); END_STATE(); case 108: - if (lookahead == 'f') ADVANCE(145); + if (lookahead == 'i') ADVANCE(146); END_STATE(); case 109: - if (lookahead == 'r') ADVANCE(146); - END_STATE(); - case 110: if (lookahead == 'r') ADVANCE(147); END_STATE(); - case 111: - if (lookahead == 'r') ADVANCE(148); + case 110: + if (lookahead == '_') ADVANCE(148); END_STATE(); - case 112: + case 111: if (lookahead == 't') ADVANCE(149); END_STATE(); + case 112: + if (lookahead == 'f') ADVANCE(150); + END_STATE(); case 113: - if (lookahead == 'v') ADVANCE(150); + if (lookahead == 'r') ADVANCE(151); END_STATE(); case 114: - if (lookahead == 'a') ADVANCE(151); + if (lookahead == 'r') ADVANCE(152); END_STATE(); case 115: - if (lookahead == 'i') ADVANCE(152); + if (lookahead == 'r') ADVANCE(153); END_STATE(); case 116: - if (lookahead == 'y') ADVANCE(153); + if (lookahead == 't') ADVANCE(154); END_STATE(); case 117: - if (lookahead == 'd') ADVANCE(154); + if (lookahead == 'v') ADVANCE(155); END_STATE(); case 118: - ACCEPT_TOKEN(anon_sym_self); + if (lookahead == 'a') ADVANCE(156); END_STATE(); case 119: - if (lookahead == 'i') ADVANCE(155); + if (lookahead == 'i') ADVANCE(157); END_STATE(); case 120: - if (lookahead == 'e') ADVANCE(156); + if (lookahead == 'y') ADVANCE(158); END_STATE(); case 121: - if (lookahead == 'c') ADVANCE(157); + if (lookahead == 'd') ADVANCE(159); END_STATE(); case 122: - if (lookahead == 'c') ADVANCE(158); + ACCEPT_TOKEN(anon_sym_self); END_STATE(); case 123: - if (lookahead == 'e') ADVANCE(159); + if (lookahead == 'i') ADVANCE(160); END_STATE(); case 124: - if (lookahead == 'l') ADVANCE(160); + if (lookahead == 'e') ADVANCE(161); END_STATE(); case 125: - ACCEPT_TOKEN(anon_sym_then); + if (lookahead == 'c') ADVANCE(162); END_STATE(); case 126: - if (lookahead == 'o') ADVANCE(161); + if (lookahead == 'c') ADVANCE(163); END_STATE(); case 127: - ACCEPT_TOKEN(anon_sym_true); + if (lookahead == 'e') ADVANCE(164); END_STATE(); case 128: - ACCEPT_TOKEN(anon_sym_uses); + if (lookahead == 'l') ADVANCE(165); END_STATE(); case 129: - ACCEPT_TOKEN(anon_sym_when); + ACCEPT_TOKEN(anon_sym_then); END_STATE(); case 130: - if (lookahead == 'd') ADVANCE(162); + if (lookahead == 'o') ADVANCE(166); END_STATE(); case 131: - if (lookahead == 'i') ADVANCE(163); + ACCEPT_TOKEN(anon_sym_true); END_STATE(); case 132: - ACCEPT_TOKEN(anon_sym_block); + ACCEPT_TOKEN(anon_sym_uses); END_STATE(); case 133: - if (lookahead == 'c') ADVANCE(164); + ACCEPT_TOKEN(anon_sym_when); END_STATE(); case 134: - if (lookahead == 'e') ADVANCE(165); + if (lookahead == 'd') ADVANCE(167); END_STATE(); case 135: - if (lookahead == 'p') ADVANCE(166); + if (lookahead == 'i') ADVANCE(168); END_STATE(); case 136: - if (lookahead == 'o') ADVANCE(167); + ACCEPT_TOKEN(anon_sym_block); END_STATE(); case 137: - ACCEPT_TOKEN(anon_sym_enter); + if (lookahead == 'c') ADVANCE(169); END_STATE(); case 138: - if (lookahead == 'a') ADVANCE(168); + if (lookahead == 'e') ADVANCE(170); END_STATE(); case 139: - ACCEPT_TOKEN(anon_sym_false); + if (lookahead == 'p') ADVANCE(171); END_STATE(); case 140: - if (lookahead == 'd') ADVANCE(169); + if (lookahead == 'o') ADVANCE(172); END_STATE(); case 141: - if (lookahead == 't') ADVANCE(170); - END_STATE(); - case 142: - if (lookahead == 't') ADVANCE(171); - END_STATE(); - case 143: - if (lookahead == 'a') ADVANCE(172); - END_STATE(); - case 144: if (lookahead == 'i') ADVANCE(173); END_STATE(); + case 142: + ACCEPT_TOKEN(anon_sym_enter); + END_STATE(); + case 143: + if (lookahead == 'a') ADVANCE(174); + END_STATE(); + case 144: + ACCEPT_TOKEN(anon_sym_false); + END_STATE(); case 145: - if (lookahead == 'i') ADVANCE(174); + if (lookahead == 'd') ADVANCE(175); END_STATE(); case 146: - ACCEPT_TOKEN(anon_sym_other); + if (lookahead == 't') ADVANCE(176); END_STATE(); case 147: - if (lookahead == 'i') ADVANCE(175); + if (lookahead == 't') ADVANCE(177); END_STATE(); case 148: - if (lookahead == 'r') ADVANCE(176); + if (lookahead == 'a') ADVANCE(178); END_STATE(); case 149: - if (lookahead == 'i') ADVANCE(177); + if (lookahead == 'i') ADVANCE(179); END_STATE(); case 150: - if (lookahead == 'e') ADVANCE(178); + if (lookahead == 'i') ADVANCE(180); END_STATE(); case 151: - if (lookahead == 't') ADVANCE(179); + ACCEPT_TOKEN(anon_sym_other); END_STATE(); case 152: - if (lookahead == 'r') ADVANCE(180); + if (lookahead == 'i') ADVANCE(181); END_STATE(); case 153: - ACCEPT_TOKEN(anon_sym_retry); + if (lookahead == 'r') ADVANCE(182); END_STATE(); case 154: - if (lookahead == 'u') ADVANCE(181); + if (lookahead == 'i') ADVANCE(183); END_STATE(); case 155: - if (lookahead == 'e') ADVANCE(182); + if (lookahead == 'e') ADVANCE(184); END_STATE(); case 156: - ACCEPT_TOKEN(anon_sym_state); + if (lookahead == 't') ADVANCE(185); END_STATE(); case 157: - if (lookahead == 't') ADVANCE(183); + if (lookahead == 'r') ADVANCE(186); END_STATE(); case 158: - if (lookahead == 'o') ADVANCE(184); + ACCEPT_TOKEN(anon_sym_retry); END_STATE(); case 159: - if (lookahead == 'e') ADVANCE(185); - END_STATE(); - case 160: - if (lookahead == 'a') ADVANCE(186); - END_STATE(); - case 161: if (lookahead == 'u') ADVANCE(187); END_STATE(); + case 160: + if (lookahead == 'e') ADVANCE(188); + END_STATE(); + case 161: + ACCEPT_TOKEN(anon_sym_state); + END_STATE(); case 162: - ACCEPT_TOKEN(anon_sym_append); - END_STATE(); - case 163: - if (lookahead == 'o') ADVANCE(188); - END_STATE(); - case 164: if (lookahead == 't') ADVANCE(189); END_STATE(); + case 163: + if (lookahead == 'o') ADVANCE(190); + END_STATE(); + case 164: + if (lookahead == 'e') ADVANCE(191); + END_STATE(); case 165: - ACCEPT_TOKEN(anon_sym_choose); + if (lookahead == 'a') ADVANCE(192); END_STATE(); case 166: - if (lookahead == 't') ADVANCE(190); + if (lookahead == 'u') ADVANCE(193); END_STATE(); case 167: - if (lookahead == 'w') ADVANCE(191); + ACCEPT_TOKEN(anon_sym_append); END_STATE(); case 168: - if (lookahead == 'l') ADVANCE(192); + if (lookahead == 'o') ADVANCE(194); END_STATE(); case 169: - if (lookahead == 'e') ADVANCE(193); + if (lookahead == 't') ADVANCE(195); END_STATE(); case 170: - if (lookahead == 'u') ADVANCE(194); + ACCEPT_TOKEN(anon_sym_choose); END_STATE(); case 171: - ACCEPT_TOKEN(anon_sym_invert); + if (lookahead == 't') ADVANCE(196); END_STATE(); case 172: - if (lookahead == 'r') ADVANCE(195); + if (lookahead == 'w') ADVANCE(197); END_STATE(); case 173: - if (lookahead == 'o') ADVANCE(196); + if (lookahead == 't') ADVANCE(198); END_STATE(); case 174: - if (lookahead == 'e') ADVANCE(197); + if (lookahead == 'l') ADVANCE(199); END_STATE(); case 175: - if (lookahead == 'd') ADVANCE(198); + if (lookahead == 'e') ADVANCE(200); END_STATE(); case 176: - if (lookahead == 'e') ADVANCE(199); + if (lookahead == 'u') ADVANCE(201); END_STATE(); case 177: - if (lookahead == 'o') ADVANCE(200); + ACCEPT_TOKEN(anon_sym_invert); END_STATE(); case 178: - ACCEPT_TOKEN(anon_sym_remove); + if (lookahead == 'r') ADVANCE(202); END_STATE(); case 179: - ACCEPT_TOKEN(anon_sym_repeat); + if (lookahead == 'o') ADVANCE(203); END_STATE(); case 180: - if (lookahead == 'e') ADVANCE(201); + if (lookahead == 'e') ADVANCE(204); END_STATE(); case 181: - if (lookahead == 'l') ADVANCE(202); - END_STATE(); - case 182: - if (lookahead == 's') ADVANCE(203); - END_STATE(); - case 183: - ACCEPT_TOKEN(anon_sym_strict); - END_STATE(); - case 184: - if (lookahead == 'n') ADVANCE(204); - END_STATE(); - case 185: if (lookahead == 'd') ADVANCE(205); END_STATE(); + case 182: + if (lookahead == 'e') ADVANCE(206); + END_STATE(); + case 183: + if (lookahead == 'o') ADVANCE(207); + END_STATE(); + case 184: + ACCEPT_TOKEN(anon_sym_remove); + END_STATE(); + case 185: + ACCEPT_TOKEN(anon_sym_repeat); + END_STATE(); case 186: - if (lookahead == 't') ADVANCE(206); + if (lookahead == 'e') ADVANCE(208); END_STATE(); case 187: - if (lookahead == 't') ADVANCE(207); + if (lookahead == 'l') ADVANCE(209); END_STATE(); case 188: - if (lookahead == 'r') ADVANCE(208); + if (lookahead == 's') ADVANCE(210); END_STATE(); case 189: - if (lookahead == 'e') ADVANCE(209); + ACCEPT_TOKEN(anon_sym_strict); END_STATE(); case 190: - ACCEPT_TOKEN(anon_sym_concept); - if (lookahead == '_') ADVANCE(210); - END_STATE(); - case 191: if (lookahead == 'n') ADVANCE(211); END_STATE(); + case 191: + if (lookahead == 'd') ADVANCE(212); + END_STATE(); case 192: - if (lookahead == 'w') ADVANCE(212); - END_STATE(); - case 193: - ACCEPT_TOKEN(anon_sym_include); - END_STATE(); - case 194: if (lookahead == 't') ADVANCE(213); END_STATE(); + case 193: + if (lookahead == 't') ADVANCE(214); + END_STATE(); + case 194: + if (lookahead == 'r') ADVANCE(215); + END_STATE(); case 195: - if (lookahead == 'c') ADVANCE(214); + if (lookahead == 'e') ADVANCE(216); END_STATE(); case 196: - if (lookahead == 'n') ADVANCE(215); + ACCEPT_TOKEN(anon_sym_concept); END_STATE(); case 197: - if (lookahead == 's') ADVANCE(216); + if (lookahead == 'n') ADVANCE(217); END_STATE(); case 198: - if (lookahead == 'e') ADVANCE(217); + if (lookahead == 'i') ADVANCE(218); END_STATE(); case 199: - if (lookahead == 'n') ADVANCE(218); + if (lookahead == 'w') ADVANCE(219); END_STATE(); case 200: - if (lookahead == 'n') ADVANCE(219); + ACCEPT_TOKEN(anon_sym_include); END_STATE(); case 201: - if (lookahead == 's') ADVANCE(220); + if (lookahead == 't') ADVANCE(220); END_STATE(); case 202: - if (lookahead == 'e') ADVANCE(221); + if (lookahead == 'c') ADVANCE(221); END_STATE(); case 203: - ACCEPT_TOKEN(anon_sym_species); + if (lookahead == 'n') ADVANCE(222); END_STATE(); case 204: - if (lookahead == 'c') ADVANCE(222); + if (lookahead == 's') ADVANCE(223); END_STATE(); case 205: - if (lookahead == '_') ADVANCE(223); - END_STATE(); - case 206: if (lookahead == 'e') ADVANCE(224); END_STATE(); + case 206: + if (lookahead == 'n') ADVANCE(225); + END_STATE(); case 207: - ACCEPT_TOKEN(anon_sym_timeout); + if (lookahead == 'n') ADVANCE(226); END_STATE(); case 208: - ACCEPT_TOKEN(anon_sym_behavior); - if (lookahead == 's') ADVANCE(225); + if (lookahead == 's') ADVANCE(227); END_STATE(); case 209: - if (lookahead == 'r') ADVANCE(226); + if (lookahead == 'e') ADVANCE(228); END_STATE(); case 210: - if (lookahead == 'c') ADVANCE(227); + ACCEPT_TOKEN(anon_sym_species); END_STATE(); case 211: - ACCEPT_TOKEN(anon_sym_cooldown); + if (lookahead == 'c') ADVANCE(229); END_STATE(); case 212: - if (lookahead == 'a') ADVANCE(228); + if (lookahead == '_') ADVANCE(230); END_STATE(); case 213: - if (lookahead == 'i') ADVANCE(229); + if (lookahead == 'e') ADVANCE(231); END_STATE(); case 214: - ACCEPT_TOKEN(anon_sym_life_arc); + ACCEPT_TOKEN(anon_sym_timeout); END_STATE(); case 215: - ACCEPT_TOKEN(anon_sym_location); - END_STATE(); - case 216: - ACCEPT_TOKEN(anon_sym_modifies); - END_STATE(); - case 217: - ACCEPT_TOKEN(anon_sym_override); - END_STATE(); - case 218: - if (lookahead == 'c') ADVANCE(230); - END_STATE(); - case 219: - if (lookahead == 's') ADVANCE(231); - END_STATE(); - case 220: - ACCEPT_TOKEN(anon_sym_requires); - END_STATE(); - case 221: - ACCEPT_TOKEN(anon_sym_schedule); + ACCEPT_TOKEN(anon_sym_behavior); if (lookahead == 's') ADVANCE(232); END_STATE(); + case 216: + if (lookahead == 'r') ADVANCE(233); + END_STATE(); + case 217: + ACCEPT_TOKEN(anon_sym_cooldown); + END_STATE(); + case 218: + if (lookahead == 'o') ADVANCE(234); + END_STATE(); + case 219: + if (lookahead == 'a') ADVANCE(235); + END_STATE(); + case 220: + if (lookahead == 'i') ADVANCE(236); + END_STATE(); + case 221: + ACCEPT_TOKEN(anon_sym_life_arc); + END_STATE(); case 222: - if (lookahead == 'e') ADVANCE(233); + ACCEPT_TOKEN(anon_sym_location); END_STATE(); case 223: - if (lookahead == 'a') ADVANCE(234); + ACCEPT_TOKEN(anon_sym_modifies); END_STATE(); case 224: - ACCEPT_TOKEN(anon_sym_template); + ACCEPT_TOKEN(anon_sym_override); END_STATE(); case 225: - ACCEPT_TOKEN(anon_sym_behaviors); + if (lookahead == 'c') ADVANCE(237); END_STATE(); case 226: - ACCEPT_TOKEN(anon_sym_character); + if (lookahead == 's') ADVANCE(238); END_STATE(); case 227: - if (lookahead == 'o') ADVANCE(235); + ACCEPT_TOKEN(anon_sym_requires); END_STATE(); case 228: - if (lookahead == 'y') ADVANCE(236); + ACCEPT_TOKEN(anon_sym_schedule); + if (lookahead == 's') ADVANCE(239); END_STATE(); case 229: - if (lookahead == 'o') ADVANCE(237); + if (lookahead == 'e') ADVANCE(240); END_STATE(); case 230: - if (lookahead == 'e') ADVANCE(238); + if (lookahead == 'a') ADVANCE(241); END_STATE(); case 231: - if (lookahead == 'h') ADVANCE(239); + ACCEPT_TOKEN(anon_sym_template); END_STATE(); case 232: - ACCEPT_TOKEN(anon_sym_schedules); + ACCEPT_TOKEN(anon_sym_behaviors); END_STATE(); case 233: - if (lookahead == 'p') ADVANCE(240); + ACCEPT_TOKEN(anon_sym_character); END_STATE(); case 234: - if (lookahead == 'l') ADVANCE(241); + if (lookahead == 'n') ADVANCE(242); END_STATE(); case 235: - if (lookahead == 'm') ADVANCE(242); + if (lookahead == 'y') ADVANCE(243); END_STATE(); case 236: - if (lookahead == 's') ADVANCE(243); + if (lookahead == 'o') ADVANCE(244); END_STATE(); case 237: - if (lookahead == 'n') ADVANCE(244); + if (lookahead == 'e') ADVANCE(245); END_STATE(); case 238: - ACCEPT_TOKEN(anon_sym_recurrence); + if (lookahead == 'h') ADVANCE(246); END_STATE(); case 239: - if (lookahead == 'i') ADVANCE(245); + ACCEPT_TOKEN(anon_sym_schedules); END_STATE(); case 240: - if (lookahead == 't') ADVANCE(246); + if (lookahead == 'p') ADVANCE(247); END_STATE(); case 241: - if (lookahead == 'w') ADVANCE(247); + if (lookahead == 'l') ADVANCE(248); END_STATE(); case 242: - if (lookahead == 'p') ADVANCE(248); + ACCEPT_TOKEN(anon_sym_definition); END_STATE(); case 243: - ACCEPT_TOKEN(anon_sym_fail_always); + if (lookahead == 's') ADVANCE(249); END_STATE(); case 244: - ACCEPT_TOKEN(anon_sym_institution); + if (lookahead == 'n') ADVANCE(250); END_STATE(); case 245: - if (lookahead == 'p') ADVANCE(249); + ACCEPT_TOKEN(anon_sym_recurrence); END_STATE(); case 246: - ACCEPT_TOKEN(anon_sym_sub_concept); + if (lookahead == 'i') ADVANCE(251); END_STATE(); case 247: - if (lookahead == 'a') ADVANCE(250); + if (lookahead == 't') ADVANCE(252); END_STATE(); case 248: - if (lookahead == 'a') ADVANCE(251); + if (lookahead == 'w') ADVANCE(253); END_STATE(); case 249: - ACCEPT_TOKEN(anon_sym_relationship); + ACCEPT_TOKEN(anon_sym_fail_always); END_STATE(); case 250: - if (lookahead == 'y') ADVANCE(252); + ACCEPT_TOKEN(anon_sym_institution); END_STATE(); case 251: - if (lookahead == 'r') ADVANCE(253); + if (lookahead == 'p') ADVANCE(254); END_STATE(); case 252: - if (lookahead == 's') ADVANCE(254); + ACCEPT_TOKEN(anon_sym_sub_concept); END_STATE(); case 253: - if (lookahead == 'i') ADVANCE(255); + if (lookahead == 'a') ADVANCE(255); END_STATE(); case 254: - ACCEPT_TOKEN(anon_sym_succeed_always); + ACCEPT_TOKEN(anon_sym_relationship); END_STATE(); case 255: - if (lookahead == 's') ADVANCE(256); + if (lookahead == 'y') ADVANCE(256); END_STATE(); case 256: - if (lookahead == 'o') ADVANCE(257); + if (lookahead == 's') ADVANCE(257); END_STATE(); case 257: - if (lookahead == 'n') ADVANCE(258); - END_STATE(); - case 258: - ACCEPT_TOKEN(anon_sym_concept_comparison); + ACCEPT_TOKEN(anon_sym_succeed_always); END_STATE(); default: return false; @@ -3807,7 +3804,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_concept] = ACTIONS(1), [anon_sym_sub_concept] = ACTIONS(1), [sym_any_type] = ACTIONS(1), - [anon_sym_concept_comparison] = ACTIONS(1), + [anon_sym_definition] = ACTIONS(1), [anon_sym_or] = ACTIONS(1), [anon_sym_is] = ACTIONS(1), [anon_sym_and] = ACTIONS(1), @@ -3835,7 +3832,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_enum_declaration] = STATE(64), [sym_concept_declaration] = STATE(64), [sym_sub_concept] = STATE(64), - [sym_concept_comparison] = STATE(64), + [sym_definition] = STATE(64), [aux_sym_source_file_repeat1] = STATE(11), [ts_builtin_sym_end] = ACTIONS(5), [sym_line_comment] = ACTIONS(3), @@ -3853,7 +3850,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_enum] = ACTIONS(27), [anon_sym_concept] = ACTIONS(29), [anon_sym_sub_concept] = ACTIONS(31), - [anon_sym_concept_comparison] = ACTIONS(33), + [anon_sym_definition] = ACTIONS(33), }, }; @@ -3902,7 +3899,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_enum, anon_sym_concept, anon_sym_sub_concept, - anon_sym_concept_comparison, + anon_sym_definition, sym_identifier, [49] = 5, ACTIONS(41), 1, @@ -3996,7 +3993,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_enum, anon_sym_concept, anon_sym_sub_concept, - anon_sym_concept_comparison, + anon_sym_definition, sym_identifier, [151] = 3, ACTIONS(3), 2, @@ -4251,7 +4248,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(106), 1, anon_sym_sub_concept, ACTIONS(109), 1, - anon_sym_concept_comparison, + anon_sym_definition, ACTIONS(3), 2, sym_line_comment, sym_block_comment, @@ -4272,7 +4269,7 @@ static const uint16_t ts_small_parse_table[] = { sym_enum_declaration, sym_concept_declaration, sym_sub_concept, - sym_concept_comparison, + sym_definition, [463] = 18, ACTIONS(7), 1, anon_sym_use, @@ -4301,7 +4298,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(31), 1, anon_sym_sub_concept, ACTIONS(33), 1, - anon_sym_concept_comparison, + anon_sym_definition, ACTIONS(112), 1, ts_builtin_sym_end, ACTIONS(3), 2, @@ -4324,7 +4321,7 @@ static const uint16_t ts_small_parse_table[] = { sym_enum_declaration, sym_concept_declaration, sym_sub_concept, - sym_concept_comparison, + sym_definition, [533] = 16, ACTIONS(114), 1, sym_identifier, @@ -6233,13 +6230,11 @@ static const uint16_t ts_small_parse_table[] = { sym_comparison, sym_field_access, sym_primary_expression, - [2962] = 3, - ACTIONS(276), 1, - anon_sym_concept, + [2962] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(274), 14, + ACTIONS(274), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6252,15 +6247,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [2986] = 3, - ACTIONS(280), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [2984] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(278), 14, + ACTIONS(276), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6273,15 +6267,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3010] = 3, - ACTIONS(284), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3006] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(282), 14, + ACTIONS(278), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6294,15 +6287,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3034] = 3, - ACTIONS(288), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3028] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(286), 14, + ACTIONS(280), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6315,15 +6307,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3058] = 3, - ACTIONS(292), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3050] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(290), 14, + ACTIONS(282), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6336,15 +6327,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3082] = 3, - ACTIONS(296), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3072] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(294), 14, + ACTIONS(284), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6357,15 +6347,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3106] = 3, - ACTIONS(300), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3094] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(298), 14, + ACTIONS(286), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6378,163 +6367,399 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, + anon_sym_concept, anon_sym_sub_concept, - anon_sym_concept_comparison, - [3130] = 3, + anon_sym_definition, + [3116] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(288), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3138] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(290), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3160] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(292), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3182] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(294), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3204] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(296), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3226] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(298), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3248] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(300), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3270] = 4, ACTIONS(304), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(302), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3154] = 3, - ACTIONS(308), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(306), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3178] = 3, - ACTIONS(312), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(310), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3202] = 3, - ACTIONS(316), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(314), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3226] = 3, - ACTIONS(320), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(318), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3250] = 3, - ACTIONS(324), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(322), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3274] = 3, - ACTIONS(328), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(326), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3298] = 4, - ACTIONS(332), 1, anon_sym_RBRACE, - ACTIONS(334), 1, + ACTIONS(306), 1, anon_sym_LPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, + ACTIONS(302), 13, + anon_sym_include, + anon_sym_choose, + anon_sym_then, + anon_sym_if, + anon_sym_when, + anon_sym_repeat, + anon_sym_invert, + anon_sym_retry, + anon_sym_timeout, + anon_sym_cooldown, + anon_sym_succeed_always, + anon_sym_fail_always, + sym_identifier, + [3296] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(308), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3318] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(310), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3340] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(312), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3362] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(314), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3384] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(316), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3406] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(318), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3428] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(320), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3450] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(322), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3472] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(324), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3494] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(326), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3516] = 2, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(328), 15, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_character, + anon_sym_template, + anon_sym_schedule, + anon_sym_life_arc, + anon_sym_behavior, + anon_sym_institution, + anon_sym_relationship, + anon_sym_location, + anon_sym_species, + anon_sym_enum, + anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3538] = 4, + ACTIONS(332), 1, + anon_sym_LBRACE, + ACTIONS(334), 1, + anon_sym_RBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, ACTIONS(330), 13, anon_sym_include, anon_sym_choose, @@ -6549,13 +6774,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [3324] = 3, - ACTIONS(338), 1, - anon_sym_concept, + [3564] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(336), 14, + ACTIONS(336), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6568,15 +6791,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3348] = 3, - ACTIONS(342), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3586] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(340), 14, + ACTIONS(338), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6589,15 +6811,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3372] = 3, - ACTIONS(346), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3608] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(344), 14, + ACTIONS(340), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6610,15 +6831,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3396] = 3, - ACTIONS(350), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3630] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(348), 14, + ACTIONS(342), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6631,15 +6851,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3420] = 3, - ACTIONS(354), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3652] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(352), 14, + ACTIONS(344), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6652,15 +6871,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3444] = 3, - ACTIONS(358), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3674] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(356), 14, + ACTIONS(346), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6673,15 +6891,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3468] = 3, - ACTIONS(362), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3696] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(360), 14, + ACTIONS(348), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6694,15 +6911,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3492] = 3, - ACTIONS(366), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3718] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(364), 14, + ACTIONS(350), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6715,15 +6931,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3516] = 3, - ACTIONS(370), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3740] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(368), 14, + ACTIONS(352), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6736,15 +6951,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3540] = 3, - ACTIONS(374), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3762] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(372), 14, + ACTIONS(354), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6757,15 +6971,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3564] = 3, - ACTIONS(378), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3784] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(376), 14, + ACTIONS(356), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6778,37 +6991,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3588] = 4, - ACTIONS(382), 1, - anon_sym_LBRACE, - ACTIONS(384), 1, - anon_sym_RBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(380), 13, - anon_sym_include, - anon_sym_choose, - anon_sym_then, - anon_sym_if, - anon_sym_when, - anon_sym_repeat, - anon_sym_invert, - anon_sym_retry, - anon_sym_timeout, - anon_sym_cooldown, - anon_sym_succeed_always, - anon_sym_fail_always, - sym_identifier, - [3614] = 3, - ACTIONS(388), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3806] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(386), 14, + ACTIONS(358), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6821,15 +7011,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3638] = 3, - ACTIONS(392), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3828] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(390), 14, + ACTIONS(360), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6842,15 +7031,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3662] = 3, - ACTIONS(396), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3850] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(394), 14, + ACTIONS(362), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6863,15 +7051,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3686] = 3, - ACTIONS(400), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3872] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(398), 14, + ACTIONS(364), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6884,15 +7071,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3710] = 3, - ACTIONS(404), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3894] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(402), 14, + ACTIONS(366), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6905,15 +7091,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3734] = 3, - ACTIONS(408), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3916] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(406), 14, + ACTIONS(368), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6926,15 +7111,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3758] = 3, - ACTIONS(412), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3938] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(410), 14, + ACTIONS(370), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6947,15 +7131,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3782] = 3, - ACTIONS(416), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3960] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(414), 14, + ACTIONS(372), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6968,15 +7151,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3806] = 3, - ACTIONS(420), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [3982] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(418), 14, + ACTIONS(374), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -6989,15 +7171,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3830] = 3, - ACTIONS(424), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [4004] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(422), 14, + ACTIONS(376), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -7010,15 +7191,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3854] = 3, - ACTIONS(428), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [4026] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(426), 14, + ACTIONS(378), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -7031,15 +7211,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3878] = 3, - ACTIONS(432), 1, anon_sym_concept, + anon_sym_sub_concept, + anon_sym_definition, + [4048] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(430), 14, + ACTIONS(380), 15, ts_builtin_sym_end, anon_sym_use, anon_sym_character, @@ -7052,326 +7231,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_location, anon_sym_species, anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3902] = 3, - ACTIONS(436), 1, anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(434), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, anon_sym_sub_concept, - anon_sym_concept_comparison, - [3926] = 3, - ACTIONS(440), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(438), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3950] = 3, - ACTIONS(444), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(442), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3974] = 3, - ACTIONS(448), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(446), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [3998] = 3, - ACTIONS(452), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(450), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [4022] = 3, - ACTIONS(456), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(454), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [4046] = 3, - ACTIONS(460), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(458), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, + anon_sym_definition, [4070] = 3, - ACTIONS(464), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(462), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [4094] = 3, - ACTIONS(468), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(466), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [4118] = 3, - ACTIONS(472), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(470), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [4142] = 3, - ACTIONS(476), 1, - anon_sym_concept, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(474), 14, - ts_builtin_sym_end, - anon_sym_use, - anon_sym_character, - anon_sym_template, - anon_sym_schedule, - anon_sym_life_arc, - anon_sym_behavior, - anon_sym_institution, - anon_sym_relationship, - anon_sym_location, - anon_sym_species, - anon_sym_enum, - anon_sym_sub_concept, - anon_sym_concept_comparison, - [4166] = 3, - ACTIONS(480), 1, - anon_sym_RBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(478), 13, - anon_sym_include, - anon_sym_choose, - anon_sym_then, - anon_sym_if, - anon_sym_when, - anon_sym_repeat, - anon_sym_invert, - anon_sym_retry, - anon_sym_timeout, - anon_sym_cooldown, - anon_sym_succeed_always, - anon_sym_fail_always, - sym_identifier, - [4189] = 3, - ACTIONS(484), 1, - anon_sym_RBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(482), 13, - anon_sym_include, - anon_sym_choose, - anon_sym_then, - anon_sym_if, - anon_sym_when, - anon_sym_repeat, - anon_sym_invert, - anon_sym_retry, - anon_sym_timeout, - anon_sym_cooldown, - anon_sym_succeed_always, - anon_sym_fail_always, - sym_identifier, - [4212] = 3, - ACTIONS(488), 1, - anon_sym_RBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(486), 13, - anon_sym_include, - anon_sym_choose, - anon_sym_then, - anon_sym_if, - anon_sym_when, - anon_sym_repeat, - anon_sym_invert, - anon_sym_retry, - anon_sym_timeout, - anon_sym_cooldown, - anon_sym_succeed_always, - anon_sym_fail_always, - sym_identifier, - [4235] = 3, - ACTIONS(492), 1, - anon_sym_RBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - ACTIONS(490), 13, - anon_sym_include, - anon_sym_choose, - anon_sym_then, - anon_sym_if, - anon_sym_when, - anon_sym_repeat, - anon_sym_invert, - anon_sym_retry, - anon_sym_timeout, - anon_sym_cooldown, - anon_sym_succeed_always, - anon_sym_fail_always, - sym_identifier, - [4258] = 3, ACTIONS(384), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(380), 13, + ACTIONS(382), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7385,13 +7254,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4281] = 3, - ACTIONS(496), 1, + [4093] = 3, + ACTIONS(388), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(494), 13, + ACTIONS(386), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7405,13 +7274,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4304] = 3, - ACTIONS(500), 1, + [4116] = 3, + ACTIONS(392), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(498), 13, + ACTIONS(390), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7425,13 +7294,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4327] = 3, - ACTIONS(504), 1, + [4139] = 3, + ACTIONS(396), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(502), 13, + ACTIONS(394), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7445,13 +7314,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4350] = 3, - ACTIONS(508), 1, + [4162] = 3, + ACTIONS(334), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(506), 13, + ACTIONS(330), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7465,13 +7334,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4373] = 3, - ACTIONS(512), 1, + [4185] = 3, + ACTIONS(400), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(510), 13, + ACTIONS(398), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7485,13 +7354,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4396] = 3, - ACTIONS(516), 1, + [4208] = 3, + ACTIONS(404), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(514), 13, + ACTIONS(402), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7505,13 +7374,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4419] = 3, - ACTIONS(520), 1, + [4231] = 3, + ACTIONS(408), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(518), 13, + ACTIONS(406), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7525,13 +7394,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4442] = 3, - ACTIONS(524), 1, + [4254] = 3, + ACTIONS(412), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(522), 13, + ACTIONS(410), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7545,13 +7414,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4465] = 3, - ACTIONS(528), 1, + [4277] = 3, + ACTIONS(416), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(526), 13, + ACTIONS(414), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7565,13 +7434,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4488] = 3, - ACTIONS(532), 1, + [4300] = 3, + ACTIONS(420), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(530), 13, + ACTIONS(418), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7585,13 +7454,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4511] = 3, - ACTIONS(536), 1, + [4323] = 3, + ACTIONS(424), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(534), 13, + ACTIONS(422), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7605,13 +7474,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4534] = 3, - ACTIONS(540), 1, + [4346] = 3, + ACTIONS(428), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(538), 13, + ACTIONS(426), 13, anon_sym_include, anon_sym_choose, anon_sym_then, @@ -7625,18 +7494,98 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_succeed_always, anon_sym_fail_always, sym_identifier, - [4557] = 10, + [4369] = 3, + ACTIONS(432), 1, + anon_sym_RBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(430), 13, + anon_sym_include, + anon_sym_choose, + anon_sym_then, + anon_sym_if, + anon_sym_when, + anon_sym_repeat, + anon_sym_invert, + anon_sym_retry, + anon_sym_timeout, + anon_sym_cooldown, + anon_sym_succeed_always, + anon_sym_fail_always, + sym_identifier, + [4392] = 3, + ACTIONS(436), 1, + anon_sym_RBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(434), 13, + anon_sym_include, + anon_sym_choose, + anon_sym_then, + anon_sym_if, + anon_sym_when, + anon_sym_repeat, + anon_sym_invert, + anon_sym_retry, + anon_sym_timeout, + anon_sym_cooldown, + anon_sym_succeed_always, + anon_sym_fail_always, + sym_identifier, + [4415] = 3, + ACTIONS(440), 1, + anon_sym_RBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(438), 13, + anon_sym_include, + anon_sym_choose, + anon_sym_then, + anon_sym_if, + anon_sym_when, + anon_sym_repeat, + anon_sym_invert, + anon_sym_retry, + anon_sym_timeout, + anon_sym_cooldown, + anon_sym_succeed_always, + anon_sym_fail_always, + sym_identifier, + [4438] = 3, + ACTIONS(444), 1, + anon_sym_RBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + ACTIONS(442), 13, + anon_sym_include, + anon_sym_choose, + anon_sym_then, + anon_sym_if, + anon_sym_when, + anon_sym_repeat, + anon_sym_invert, + anon_sym_retry, + anon_sym_timeout, + anon_sym_cooldown, + anon_sym_succeed_always, + anon_sym_fail_always, + sym_identifier, + [4461] = 10, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(544), 1, + ACTIONS(448), 1, anon_sym_RBRACE, - ACTIONS(546), 1, + ACTIONS(450), 1, anon_sym_block, - ACTIONS(548), 1, + ACTIONS(452), 1, anon_sym_override, - ACTIONS(550), 1, + ACTIONS(454), 1, anon_sym_recurrence, STATE(41), 1, sym_prose_block, @@ -7651,18 +7600,18 @@ static const uint16_t ts_small_parse_table[] = { sym_override_block, sym_recurrence_block, aux_sym_schedule_body_repeat1, - [4593] = 10, + [4497] = 10, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(450), 1, anon_sym_block, - ACTIONS(548), 1, + ACTIONS(452), 1, anon_sym_override, - ACTIONS(550), 1, + ACTIONS(454), 1, anon_sym_recurrence, - ACTIONS(552), 1, + ACTIONS(456), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -7677,18 +7626,18 @@ static const uint16_t ts_small_parse_table[] = { sym_override_block, sym_recurrence_block, aux_sym_schedule_body_repeat1, - [4629] = 10, - ACTIONS(554), 1, + [4533] = 10, + ACTIONS(458), 1, sym_identifier, - ACTIONS(557), 1, + ACTIONS(461), 1, anon_sym_RBRACE, - ACTIONS(559), 1, + ACTIONS(463), 1, sym_prose_marker, - ACTIONS(562), 1, + ACTIONS(466), 1, anon_sym_block, - ACTIONS(565), 1, + ACTIONS(469), 1, anon_sym_override, - ACTIONS(568), 1, + ACTIONS(472), 1, anon_sym_recurrence, STATE(41), 1, sym_prose_block, @@ -7703,16 +7652,16 @@ static const uint16_t ts_small_parse_table[] = { sym_override_block, sym_recurrence_block, aux_sym_schedule_body_repeat1, - [4665] = 9, + [4569] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(571), 1, + ACTIONS(475), 1, anon_sym_RBRACE, - ACTIONS(573), 1, + ACTIONS(477), 1, anon_sym_uses, - ACTIONS(575), 1, + ACTIONS(479), 1, anon_sym_include, STATE(41), 1, sym_prose_block, @@ -7727,16 +7676,16 @@ static const uint16_t ts_small_parse_table[] = { sym_include, sym_field, aux_sym_template_body_repeat1, - [4698] = 9, + [4602] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(573), 1, + ACTIONS(477), 1, anon_sym_uses, - ACTIONS(575), 1, + ACTIONS(479), 1, anon_sym_include, - ACTIONS(577), 1, + ACTIONS(481), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -7751,16 +7700,16 @@ static const uint16_t ts_small_parse_table[] = { sym_include, sym_field, aux_sym_template_body_repeat1, - [4731] = 9, - ACTIONS(579), 1, + [4635] = 9, + ACTIONS(483), 1, sym_identifier, - ACTIONS(582), 1, + ACTIONS(486), 1, anon_sym_RBRACE, - ACTIONS(584), 1, + ACTIONS(488), 1, anon_sym_uses, - ACTIONS(587), 1, + ACTIONS(491), 1, anon_sym_include, - ACTIONS(590), 1, + ACTIONS(494), 1, sym_prose_marker, STATE(41), 1, sym_prose_block, @@ -7775,12 +7724,12 @@ static const uint16_t ts_small_parse_table[] = { sym_include, sym_field, aux_sym_template_body_repeat1, - [4764] = 10, + [4668] = 10, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(593), 1, + ACTIONS(497), 1, sym_identifier, - ACTIONS(595), 1, + ACTIONS(499), 1, anon_sym_RBRACE, STATE(8), 1, sym_path_segments, @@ -7799,14 +7748,14 @@ static const uint16_t ts_small_parse_table[] = { STATE(171), 2, sym_field, aux_sym_character_body_repeat1, - [4798] = 10, + [4702] = 10, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(597), 1, + ACTIONS(501), 1, anon_sym_RBRACE, - ACTIONS(599), 1, + ACTIONS(503), 1, anon_sym_on, STATE(41), 1, sym_prose_block, @@ -7823,16 +7772,16 @@ static const uint16_t ts_small_parse_table[] = { STATE(210), 2, sym_transition, aux_sym_state_body_repeat1, - [4832] = 4, - ACTIONS(601), 1, + [4736] = 4, + ACTIONS(505), 1, anon_sym_DOT, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(605), 2, + ACTIONS(509), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(603), 7, + ACTIONS(507), 7, anon_sym_DASH_GT, anon_sym_RPAREN, anon_sym_or, @@ -7840,14 +7789,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_and, anon_sym_GT_EQ, anon_sym_LT_EQ, - [4853] = 3, + [4757] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(609), 2, + ACTIONS(513), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(607), 8, + ACTIONS(511), 8, anon_sym_DOT, anon_sym_DASH_GT, anon_sym_RPAREN, @@ -7856,16 +7805,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_and, anon_sym_GT_EQ, anon_sym_LT_EQ, - [4872] = 10, + [4776] = 10, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(611), 1, + ACTIONS(515), 1, anon_sym_RBRACE, - ACTIONS(613), 1, + ACTIONS(517), 1, anon_sym_remove, - ACTIONS(615), 1, + ACTIONS(519), 1, anon_sym_append, STATE(41), 1, sym_prose_block, @@ -7879,51 +7828,51 @@ static const uint16_t ts_small_parse_table[] = { STATE(148), 2, sym_override_op, aux_sym_override_repeat1, - [4905] = 5, - ACTIONS(601), 1, + [4809] = 5, + ACTIONS(505), 1, anon_sym_DOT, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(621), 2, + ACTIONS(525), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(619), 3, + ACTIONS(523), 3, anon_sym_is, anon_sym_GT_EQ, anon_sym_LT_EQ, - ACTIONS(617), 4, + ACTIONS(521), 4, anon_sym_DASH_GT, anon_sym_RPAREN, anon_sym_or, anon_sym_and, - [4928] = 6, - ACTIONS(601), 1, + [4832] = 6, + ACTIONS(505), 1, anon_sym_DOT, - ACTIONS(625), 1, + ACTIONS(529), 1, anon_sym_and, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(621), 2, + ACTIONS(525), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(619), 3, + ACTIONS(523), 3, anon_sym_is, anon_sym_GT_EQ, anon_sym_LT_EQ, - ACTIONS(623), 3, + ACTIONS(527), 3, anon_sym_DASH_GT, anon_sym_RPAREN, anon_sym_or, - [4953] = 9, + [4857] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(627), 1, + ACTIONS(531), 1, anon_sym_RBRACE, - ACTIONS(629), 1, + ACTIONS(533), 1, anon_sym_on, STATE(41), 1, sym_prose_block, @@ -7938,14 +7887,14 @@ static const uint16_t ts_small_parse_table[] = { STATE(214), 2, sym_transition, aux_sym_state_body_repeat1, - [4984] = 9, + [4888] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(629), 1, + ACTIONS(533), 1, anon_sym_on, - ACTIONS(631), 1, + ACTIONS(535), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -7960,32 +7909,32 @@ static const uint16_t ts_small_parse_table[] = { STATE(219), 2, sym_transition, aux_sym_state_body_repeat1, - [5015] = 5, - ACTIONS(601), 1, + [4919] = 5, + ACTIONS(505), 1, anon_sym_DOT, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(621), 2, + ACTIONS(525), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(619), 3, + ACTIONS(523), 3, anon_sym_is, anon_sym_GT_EQ, anon_sym_LT_EQ, - ACTIONS(633), 4, + ACTIONS(537), 4, anon_sym_DASH_GT, anon_sym_RPAREN, anon_sym_or, anon_sym_and, - [5038] = 9, + [4942] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(635), 1, + ACTIONS(539), 1, anon_sym_RBRACE, - ACTIONS(637), 1, + ACTIONS(541), 1, anon_sym_state, STATE(41), 1, sym_prose_block, @@ -8000,16 +7949,16 @@ static const uint16_t ts_small_parse_table[] = { STATE(207), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [5069] = 10, + [4973] = 10, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(613), 1, + ACTIONS(517), 1, anon_sym_remove, - ACTIONS(615), 1, + ACTIONS(519), 1, anon_sym_append, - ACTIONS(639), 1, + ACTIONS(543), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8023,14 +7972,14 @@ static const uint16_t ts_small_parse_table[] = { STATE(151), 2, sym_override_op, aux_sym_override_repeat1, - [5102] = 3, + [5006] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(643), 2, + ACTIONS(547), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(641), 8, + ACTIONS(545), 8, anon_sym_DOT, anon_sym_DASH_GT, anon_sym_RPAREN, @@ -8039,14 +7988,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_and, anon_sym_GT_EQ, anon_sym_LT_EQ, - [5121] = 9, + [5025] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(637), 1, + ACTIONS(541), 1, anon_sym_state, - ACTIONS(645), 1, + ACTIONS(549), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8061,16 +8010,16 @@ static const uint16_t ts_small_parse_table[] = { STATE(218), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [5152] = 10, - ACTIONS(647), 1, + [5056] = 10, + ACTIONS(551), 1, sym_identifier, - ACTIONS(650), 1, + ACTIONS(554), 1, anon_sym_RBRACE, - ACTIONS(652), 1, + ACTIONS(556), 1, anon_sym_remove, - ACTIONS(655), 1, + ACTIONS(559), 1, anon_sym_append, - ACTIONS(658), 1, + ACTIONS(562), 1, sym_prose_marker, STATE(41), 1, sym_prose_block, @@ -8084,14 +8033,14 @@ static const uint16_t ts_small_parse_table[] = { STATE(151), 2, sym_override_op, aux_sym_override_repeat1, - [5185] = 9, + [5089] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(637), 1, + ACTIONS(541), 1, anon_sym_state, - ACTIONS(661), 1, + ACTIONS(565), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8106,14 +8055,14 @@ static const uint16_t ts_small_parse_table[] = { STATE(206), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [5216] = 3, + [5120] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(665), 2, + ACTIONS(569), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(663), 8, + ACTIONS(567), 8, anon_sym_DOT, anon_sym_DASH_GT, anon_sym_RPAREN, @@ -8122,14 +8071,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_and, anon_sym_GT_EQ, anon_sym_LT_EQ, - [5235] = 9, + [5139] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(637), 1, + ACTIONS(541), 1, anon_sym_state, - ACTIONS(667), 1, + ACTIONS(571), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8144,14 +8093,14 @@ static const uint16_t ts_small_parse_table[] = { STATE(200), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [5266] = 9, + [5170] = 9, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(542), 1, + ACTIONS(446), 1, sym_identifier, - ACTIONS(629), 1, + ACTIONS(533), 1, anon_sym_on, - ACTIONS(631), 1, + ACTIONS(535), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8166,31 +8115,31 @@ static const uint16_t ts_small_parse_table[] = { STATE(219), 2, sym_transition, aux_sym_state_body_repeat1, - [5297] = 7, - ACTIONS(601), 1, + [5201] = 7, + ACTIONS(505), 1, anon_sym_DOT, - ACTIONS(625), 1, + ACTIONS(529), 1, anon_sym_and, - ACTIONS(669), 1, + ACTIONS(573), 1, anon_sym_DASH_GT, - ACTIONS(671), 1, + ACTIONS(575), 1, anon_sym_or, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(621), 2, + ACTIONS(525), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(619), 3, + ACTIONS(523), 3, anon_sym_is, anon_sym_GT_EQ, anon_sym_LT_EQ, - [5323] = 7, + [5227] = 7, ACTIONS(52), 1, anon_sym_COLON_COLON, - ACTIONS(673), 1, + ACTIONS(577), 1, anon_sym_COLON, - ACTIONS(675), 1, + ACTIONS(579), 1, anon_sym_DOT, STATE(7), 1, aux_sym_path_segments_repeat1, @@ -8204,33 +8153,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, anon_sym_RPAREN, anon_sym_as, - [5349] = 7, - ACTIONS(601), 1, + [5253] = 7, + ACTIONS(505), 1, anon_sym_DOT, - ACTIONS(625), 1, + ACTIONS(529), 1, anon_sym_and, - ACTIONS(671), 1, + ACTIONS(575), 1, anon_sym_or, - ACTIONS(677), 1, + ACTIONS(581), 1, anon_sym_RPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(621), 2, + ACTIONS(525), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(619), 3, + ACTIONS(523), 3, anon_sym_is, anon_sym_GT_EQ, anon_sym_LT_EQ, - [5375] = 8, + [5279] = 8, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(575), 1, + ACTIONS(479), 1, anon_sym_include, - ACTIONS(679), 1, + ACTIONS(583), 1, sym_identifier, - ACTIONS(681), 1, + ACTIONS(585), 1, anon_sym_RBRACE, STATE(267), 1, sym_prose_block, @@ -8243,14 +8192,14 @@ static const uint16_t ts_small_parse_table[] = { STATE(182), 2, sym_species_field, aux_sym_species_body_repeat2, - [5403] = 8, + [5307] = 8, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(575), 1, + ACTIONS(479), 1, anon_sym_include, - ACTIONS(679), 1, + ACTIONS(583), 1, sym_identifier, - ACTIONS(683), 1, + ACTIONS(587), 1, anon_sym_RBRACE, STATE(267), 1, sym_prose_block, @@ -8263,74 +8212,74 @@ static const uint16_t ts_small_parse_table[] = { STATE(184), 2, sym_species_field, aux_sym_species_body_repeat2, - [5431] = 5, - ACTIONS(689), 1, + [5335] = 5, + ACTIONS(593), 1, anon_sym_COMMA, STATE(161), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(685), 3, + ACTIONS(589), 3, anon_sym_uses, anon_sym_include, sym_identifier, - ACTIONS(687), 4, + ACTIONS(591), 4, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_RBRACK, sym_prose_marker, - [5453] = 7, - ACTIONS(601), 1, + [5357] = 7, + ACTIONS(505), 1, anon_sym_DOT, - ACTIONS(625), 1, + ACTIONS(529), 1, anon_sym_and, - ACTIONS(671), 1, + ACTIONS(575), 1, anon_sym_or, - ACTIONS(692), 1, + ACTIONS(596), 1, anon_sym_RPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(621), 2, + ACTIONS(525), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(619), 3, + ACTIONS(523), 3, anon_sym_is, anon_sym_GT_EQ, anon_sym_LT_EQ, - [5479] = 3, + [5383] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(685), 3, + ACTIONS(589), 3, anon_sym_uses, anon_sym_include, sym_identifier, - ACTIONS(687), 5, + ACTIONS(591), 5, anon_sym_LBRACE, anon_sym_COMMA, anon_sym_RBRACE, anon_sym_RBRACK, sym_prose_marker, - [5496] = 6, - ACTIONS(694), 1, + [5400] = 6, + ACTIONS(598), 1, sym_integer, - ACTIONS(696), 1, + ACTIONS(600), 1, sym_float, - ACTIONS(698), 1, + ACTIONS(602), 1, sym_string, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(700), 2, + ACTIONS(604), 2, anon_sym_true, anon_sym_false, STATE(253), 2, sym_boolean, sym_range, - [5518] = 6, - ACTIONS(702), 1, + [5422] = 6, + ACTIONS(606), 1, sym_identifier, STATE(8), 1, sym_path_segments, @@ -8339,18 +8288,18 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(705), 2, + ACTIONS(609), 2, anon_sym_RBRACE, sym_prose_marker, STATE(165), 2, sym_participant, aux_sym_relationship_body_repeat1, - [5540] = 7, + [5444] = 7, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(707), 1, + ACTIONS(611), 1, sym_identifier, - ACTIONS(709), 1, + ACTIONS(613), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8362,12 +8311,12 @@ static const uint16_t ts_small_parse_table[] = { STATE(168), 2, sym_field, aux_sym_character_body_repeat1, - [5564] = 7, + [5468] = 7, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(707), 1, + ACTIONS(611), 1, sym_identifier, - ACTIONS(711), 1, + ACTIONS(615), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8379,12 +8328,12 @@ static const uint16_t ts_small_parse_table[] = { STATE(55), 2, sym_field, aux_sym_character_body_repeat1, - [5588] = 7, + [5492] = 7, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(707), 1, + ACTIONS(611), 1, sym_identifier, - ACTIONS(713), 1, + ACTIONS(617), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8396,12 +8345,12 @@ static const uint16_t ts_small_parse_table[] = { STATE(55), 2, sym_field, aux_sym_character_body_repeat1, - [5612] = 7, + [5516] = 7, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(707), 1, + ACTIONS(611), 1, sym_identifier, - ACTIONS(715), 1, + ACTIONS(619), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8413,27 +8362,27 @@ static const uint16_t ts_small_parse_table[] = { STATE(167), 2, sym_field, aux_sym_character_body_repeat1, - [5636] = 5, - ACTIONS(719), 1, + [5540] = 5, + ACTIONS(623), 1, anon_sym_COMMA, STATE(161), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(721), 2, + ACTIONS(625), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(717), 3, + ACTIONS(621), 3, anon_sym_uses, anon_sym_include, sym_identifier, - [5656] = 7, + [5560] = 7, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(707), 1, + ACTIONS(611), 1, sym_identifier, - ACTIONS(723), 1, + ACTIONS(627), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8445,27 +8394,27 @@ static const uint16_t ts_small_parse_table[] = { STATE(55), 2, sym_field, aux_sym_character_body_repeat1, - [5680] = 5, - ACTIONS(727), 1, + [5584] = 5, + ACTIONS(631), 1, anon_sym_COMMA, STATE(170), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(729), 2, + ACTIONS(633), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(725), 3, + ACTIONS(629), 3, anon_sym_uses, anon_sym_include, sym_identifier, - [5700] = 7, + [5604] = 7, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(707), 1, + ACTIONS(611), 1, sym_identifier, - ACTIONS(731), 1, + ACTIONS(635), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8477,12 +8426,12 @@ static const uint16_t ts_small_parse_table[] = { STATE(174), 2, sym_field, aux_sym_character_body_repeat1, - [5724] = 7, + [5628] = 7, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(707), 1, + ACTIONS(611), 1, sym_identifier, - ACTIONS(733), 1, + ACTIONS(637), 1, anon_sym_RBRACE, STATE(41), 1, sym_prose_block, @@ -8494,52 +8443,52 @@ static const uint16_t ts_small_parse_table[] = { STATE(55), 2, sym_field, aux_sym_character_body_repeat1, - [5748] = 5, - ACTIONS(735), 1, + [5652] = 5, + ACTIONS(639), 1, sym_identifier, - ACTIONS(739), 1, + ACTIONS(643), 1, anon_sym_include, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(737), 2, + ACTIONS(641), 2, anon_sym_RBRACE, sym_prose_marker, STATE(175), 2, sym_include, aux_sym_species_body_repeat1, - [5767] = 3, + [5671] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(744), 2, + ACTIONS(648), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(742), 4, + ACTIONS(646), 4, anon_sym_block, anon_sym_override, anon_sym_recurrence, sym_identifier, - [5782] = 5, - ACTIONS(746), 1, + [5686] = 5, + ACTIONS(650), 1, sym_integer, STATE(317), 1, sym_boolean, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(700), 2, + ACTIONS(604), 2, anon_sym_true, anon_sym_false, - ACTIONS(748), 2, + ACTIONS(652), 2, sym_float, sym_string, - [5801] = 6, - ACTIONS(750), 1, + [5705] = 6, + ACTIONS(654), 1, sym_identifier, - ACTIONS(753), 1, + ACTIONS(657), 1, anon_sym_RBRACE, - ACTIONS(755), 1, + ACTIONS(659), 1, sym_prose_marker, STATE(267), 1, sym_prose_block, @@ -8549,48 +8498,48 @@ static const uint16_t ts_small_parse_table[] = { STATE(178), 2, sym_species_field, aux_sym_species_body_repeat2, - [5822] = 3, + [5726] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(760), 2, + ACTIONS(664), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(758), 4, + ACTIONS(662), 4, anon_sym_block, anon_sym_override, anon_sym_recurrence, sym_identifier, - [5837] = 3, + [5741] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(764), 2, + ACTIONS(668), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(762), 4, + ACTIONS(666), 4, anon_sym_block, anon_sym_override, anon_sym_recurrence, sym_identifier, - [5852] = 3, + [5756] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(768), 2, + ACTIONS(672), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(766), 4, + ACTIONS(670), 4, anon_sym_block, anon_sym_override, anon_sym_recurrence, sym_identifier, - [5867] = 6, + [5771] = 6, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(770), 1, + ACTIONS(674), 1, sym_identifier, - ACTIONS(772), 1, + ACTIONS(676), 1, anon_sym_RBRACE, STATE(267), 1, sym_prose_block, @@ -8600,24 +8549,24 @@ static const uint16_t ts_small_parse_table[] = { STATE(178), 2, sym_species_field, aux_sym_species_body_repeat2, - [5888] = 3, + [5792] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(776), 2, + ACTIONS(680), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(774), 4, + ACTIONS(678), 4, anon_sym_block, anon_sym_override, anon_sym_recurrence, sym_identifier, - [5903] = 6, + [5807] = 6, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(681), 1, + ACTIONS(585), 1, anon_sym_RBRACE, - ACTIONS(770), 1, + ACTIONS(674), 1, sym_identifier, STATE(267), 1, sym_prose_block, @@ -8627,18 +8576,18 @@ static const uint16_t ts_small_parse_table[] = { STATE(178), 2, sym_species_field, aux_sym_species_body_repeat2, - [5924] = 3, + [5828] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(780), 2, + ACTIONS(684), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(778), 3, + ACTIONS(682), 3, anon_sym_uses, anon_sym_include, sym_identifier, - [5938] = 3, + [5842] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, @@ -8649,58 +8598,58 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_uses, anon_sym_include, sym_identifier, - [5952] = 3, + [5856] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(784), 2, + ACTIONS(688), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(782), 3, + ACTIONS(686), 3, anon_sym_uses, anon_sym_include, sym_identifier, - [5966] = 6, - ACTIONS(332), 1, + [5870] = 6, + ACTIONS(304), 1, anon_sym_RBRACE, - ACTIONS(334), 1, + ACTIONS(306), 1, anon_sym_LPAREN, - ACTIONS(675), 1, + ACTIONS(579), 1, anon_sym_DOT, - ACTIONS(786), 1, + ACTIONS(690), 1, anon_sym_COLON, STATE(244), 1, aux_sym_dotted_path_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [5986] = 4, - ACTIONS(788), 1, + [5890] = 4, + ACTIONS(692), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(717), 2, + ACTIONS(621), 2, anon_sym_uses, anon_sym_include, - ACTIONS(721), 2, + ACTIONS(625), 2, anon_sym_RBRACE, sym_prose_marker, - [6002] = 3, + [5906] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(793), 2, + ACTIONS(697), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(791), 3, + ACTIONS(695), 3, anon_sym_uses, anon_sym_include, sym_identifier, - [6016] = 6, + [5920] = 6, ACTIONS(118), 1, sym_prose_marker, - ACTIONS(707), 1, + ACTIONS(611), 1, sym_identifier, STATE(41), 1, sym_prose_block, @@ -8711,23 +8660,23 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6036] = 3, + [5940] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(797), 2, + ACTIONS(701), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(795), 3, + ACTIONS(699), 3, anon_sym_remove, anon_sym_append, sym_identifier, - [6050] = 6, - ACTIONS(799), 1, + [5954] = 6, + ACTIONS(703), 1, anon_sym_LBRACE, - ACTIONS(801), 1, + ACTIONS(705), 1, anon_sym_COLON, - ACTIONS(803), 1, + ACTIONS(707), 1, anon_sym_from, STATE(71), 1, sym_character_body, @@ -8736,30 +8685,30 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6070] = 3, + [5974] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(807), 2, + ACTIONS(711), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(805), 3, + ACTIONS(709), 3, anon_sym_remove, anon_sym_append, sym_identifier, - [6084] = 3, + [5988] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(811), 2, + ACTIONS(715), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(809), 3, + ACTIONS(713), 3, anon_sym_uses, anon_sym_include, sym_identifier, - [6098] = 5, - ACTIONS(813), 1, + [6002] = 5, + ACTIONS(717), 1, sym_identifier, STATE(8), 1, sym_path_segments, @@ -8771,18 +8720,18 @@ static const uint16_t ts_small_parse_table[] = { STATE(137), 2, sym_participant, aux_sym_relationship_body_repeat1, - [6116] = 3, + [6020] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(817), 2, + ACTIONS(721), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(815), 3, + ACTIONS(719), 3, anon_sym_uses, anon_sym_include, sym_identifier, - [6130] = 3, + [6034] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, @@ -8793,22 +8742,22 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_uses, anon_sym_include, sym_identifier, - [6144] = 4, - ACTIONS(819), 1, + [6048] = 4, + ACTIONS(723), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(822), 2, + ACTIONS(726), 2, anon_sym_RBRACE, sym_prose_marker, - ACTIONS(824), 2, + ACTIONS(728), 2, anon_sym_uses, anon_sym_include, - [6160] = 4, - ACTIONS(635), 1, + [6064] = 4, + ACTIONS(539), 1, anon_sym_RBRACE, - ACTIONS(826), 1, + ACTIONS(730), 1, anon_sym_state, ACTIONS(3), 2, sym_line_comment, @@ -8816,10 +8765,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(208), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [6175] = 5, - ACTIONS(799), 1, + [6079] = 5, + ACTIONS(703), 1, anon_sym_LBRACE, - ACTIONS(803), 1, + ACTIONS(707), 1, anon_sym_from, STATE(99), 1, sym_character_body, @@ -8828,10 +8777,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6192] = 4, - ACTIONS(828), 1, + [6096] = 4, + ACTIONS(732), 1, sym_identifier, - ACTIONS(830), 1, + ACTIONS(734), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, @@ -8839,10 +8788,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(204), 2, sym_block_field, aux_sym_schedule_block_repeat1, - [6207] = 4, - ACTIONS(828), 1, + [6111] = 4, + ACTIONS(732), 1, sym_identifier, - ACTIONS(832), 1, + ACTIONS(736), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, @@ -8850,10 +8799,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(205), 2, sym_block_field, aux_sym_schedule_block_repeat1, - [6222] = 4, - ACTIONS(828), 1, + [6126] = 4, + ACTIONS(732), 1, sym_identifier, - ACTIONS(834), 1, + ACTIONS(738), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, @@ -8861,10 +8810,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(211), 2, sym_block_field, aux_sym_schedule_block_repeat1, - [6237] = 4, - ACTIONS(828), 1, + [6141] = 4, + ACTIONS(732), 1, sym_identifier, - ACTIONS(836), 1, + ACTIONS(740), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, @@ -8872,10 +8821,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(211), 2, sym_block_field, aux_sym_schedule_block_repeat1, - [6252] = 4, - ACTIONS(826), 1, + [6156] = 4, + ACTIONS(730), 1, anon_sym_state, - ACTIONS(838), 1, + ACTIONS(742), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, @@ -8883,10 +8832,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(208), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [6267] = 4, - ACTIONS(826), 1, + [6171] = 4, + ACTIONS(730), 1, anon_sym_state, - ACTIONS(840), 1, + ACTIONS(744), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, @@ -8894,10 +8843,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(208), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [6282] = 4, - ACTIONS(842), 1, + [6186] = 4, + ACTIONS(746), 1, anon_sym_RBRACE, - ACTIONS(844), 1, + ACTIONS(748), 1, anon_sym_state, ACTIONS(3), 2, sym_line_comment, @@ -8905,20 +8854,20 @@ static const uint16_t ts_small_parse_table[] = { STATE(208), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [6297] = 3, - ACTIONS(849), 1, + [6201] = 3, + ACTIONS(753), 1, sym_integer, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(847), 3, + ACTIONS(751), 3, sym_float, sym_string, sym_identifier, - [6310] = 4, - ACTIONS(631), 1, + [6214] = 4, + ACTIONS(535), 1, anon_sym_RBRACE, - ACTIONS(851), 1, + ACTIONS(755), 1, anon_sym_on, ACTIONS(3), 2, sym_line_comment, @@ -8926,10 +8875,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(221), 2, sym_transition, aux_sym_state_body_repeat1, - [6325] = 4, - ACTIONS(853), 1, + [6229] = 4, + ACTIONS(757), 1, sym_identifier, - ACTIONS(856), 1, + ACTIONS(760), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, @@ -8937,10 +8886,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(211), 2, sym_block_field, aux_sym_schedule_block_repeat1, - [6340] = 4, - ACTIONS(858), 1, + [6244] = 4, + ACTIONS(762), 1, anon_sym_RBRACE, - ACTIONS(860), 1, + ACTIONS(764), 1, anon_sym_block, ACTIONS(3), 2, sym_line_comment, @@ -8948,20 +8897,20 @@ static const uint16_t ts_small_parse_table[] = { STATE(220), 2, sym_schedule_block, aux_sym_recurrence_block_repeat1, - [6355] = 3, + [6259] = 3, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(862), 2, + ACTIONS(766), 2, anon_sym_on, sym_identifier, - ACTIONS(864), 2, + ACTIONS(768), 2, anon_sym_RBRACE, sym_prose_marker, - [6368] = 4, - ACTIONS(851), 1, + [6272] = 4, + ACTIONS(755), 1, anon_sym_on, - ACTIONS(866), 1, + ACTIONS(770), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, @@ -8969,41 +8918,41 @@ static const uint16_t ts_small_parse_table[] = { STATE(221), 2, sym_transition, aux_sym_state_body_repeat1, - [6383] = 4, - ACTIONS(870), 1, + [6287] = 4, + ACTIONS(774), 1, anon_sym_or, STATE(222), 1, aux_sym_is_condition_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(868), 2, + ACTIONS(772), 2, anon_sym_COMMA, anon_sym_RBRACE, - [6398] = 3, + [6302] = 3, ACTIONS(138), 1, anon_sym_DOT_DOT, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(872), 3, + ACTIONS(776), 3, anon_sym_RBRACE, sym_prose_marker, sym_identifier, - [6411] = 3, + [6315] = 3, ACTIONS(136), 1, anon_sym_DOT_DOT, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(872), 3, + ACTIONS(776), 3, anon_sym_RBRACE, sym_prose_marker, sym_identifier, - [6424] = 4, - ACTIONS(661), 1, + [6328] = 4, + ACTIONS(565), 1, anon_sym_RBRACE, - ACTIONS(826), 1, + ACTIONS(730), 1, anon_sym_state, ACTIONS(3), 2, sym_line_comment, @@ -9011,10 +8960,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(208), 2, sym_state_block, aux_sym_life_arc_declaration_repeat1, - [6439] = 4, - ACTIONS(627), 1, + [6343] = 4, + ACTIONS(531), 1, anon_sym_RBRACE, - ACTIONS(851), 1, + ACTIONS(755), 1, anon_sym_on, ACTIONS(3), 2, sym_line_comment, @@ -9022,10 +8971,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(221), 2, sym_transition, aux_sym_state_body_repeat1, - [6454] = 4, - ACTIONS(874), 1, + [6358] = 4, + ACTIONS(778), 1, anon_sym_RBRACE, - ACTIONS(876), 1, + ACTIONS(780), 1, anon_sym_block, ACTIONS(3), 2, sym_line_comment, @@ -9033,10 +8982,10 @@ static const uint16_t ts_small_parse_table[] = { STATE(220), 2, sym_schedule_block, aux_sym_recurrence_block_repeat1, - [6469] = 4, - ACTIONS(879), 1, + [6373] = 4, + ACTIONS(783), 1, anon_sym_RBRACE, - ACTIONS(881), 1, + ACTIONS(785), 1, anon_sym_on, ACTIONS(3), 2, sym_line_comment, @@ -9044,19 +8993,19 @@ static const uint16_t ts_small_parse_table[] = { STATE(221), 2, sym_transition, aux_sym_state_body_repeat1, - [6484] = 4, - ACTIONS(870), 1, + [6388] = 4, + ACTIONS(774), 1, anon_sym_or, STATE(225), 1, aux_sym_is_condition_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(884), 2, + ACTIONS(788), 2, anon_sym_COMMA, anon_sym_RBRACE, - [6499] = 4, - ACTIONS(886), 1, + [6403] = 4, + ACTIONS(790), 1, sym_identifier, STATE(266), 1, sym_sub_concept_field, @@ -9066,45 +9015,45 @@ static const uint16_t ts_small_parse_table[] = { STATE(408), 2, sym_sub_concept_enum_body, sym_sub_concept_record_body, - [6514] = 5, - ACTIONS(888), 1, + [6418] = 5, + ACTIONS(792), 1, anon_sym_LBRACE, - ACTIONS(890), 1, + ACTIONS(794), 1, anon_sym_COLON, - ACTIONS(892), 1, + ACTIONS(796), 1, anon_sym_strict, STATE(89), 1, sym_template_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6531] = 4, - ACTIONS(896), 1, + [6435] = 4, + ACTIONS(800), 1, anon_sym_or, STATE(225), 1, aux_sym_is_condition_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(894), 2, + ACTIONS(798), 2, anon_sym_COMMA, anon_sym_RBRACE, - [6546] = 5, - ACTIONS(899), 1, + [6450] = 5, + ACTIONS(803), 1, anon_sym_COMMA, - ACTIONS(901), 1, + ACTIONS(805), 1, anon_sym_RBRACE, - ACTIONS(903), 1, + ACTIONS(807), 1, anon_sym_COLON, STATE(239), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6563] = 5, - ACTIONS(905), 1, + [6467] = 5, + ACTIONS(809), 1, sym_identifier, - ACTIONS(907), 1, + ACTIONS(811), 1, sym_any_type, STATE(215), 1, sym_is_value, @@ -9113,213 +9062,213 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6580] = 2, + [6484] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(894), 3, + ACTIONS(798), 3, anon_sym_COMMA, anon_sym_RBRACE, anon_sym_or, - [6590] = 4, - ACTIONS(909), 1, + [6494] = 4, + ACTIONS(813), 1, sym_identifier, - ACTIONS(911), 1, + ACTIONS(815), 1, anon_sym_RBRACE, STATE(319), 1, sym_sub_concept_field, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6604] = 4, - ACTIONS(913), 1, + [6508] = 4, + ACTIONS(817), 1, anon_sym_COMMA, - ACTIONS(916), 1, + ACTIONS(820), 1, anon_sym_RBRACE, STATE(230), 1, aux_sym_sub_concept_record_body_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6618] = 2, + [6522] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(918), 3, + ACTIONS(822), 3, anon_sym_RBRACE, sym_prose_marker, sym_identifier, - [6628] = 4, - ACTIONS(920), 1, + [6532] = 4, + ACTIONS(824), 1, sym_identifier, - ACTIONS(922), 1, + ACTIONS(826), 1, anon_sym_RBRACE, STATE(334), 1, sym_field_condition, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6642] = 4, - ACTIONS(922), 1, + [6546] = 4, + ACTIONS(826), 1, anon_sym_RBRACE, - ACTIONS(924), 1, + ACTIONS(828), 1, anon_sym_COMMA, STATE(258), 1, aux_sym_variant_pattern_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6656] = 4, - ACTIONS(926), 1, + [6560] = 4, + ACTIONS(830), 1, anon_sym_COLON, - ACTIONS(928), 1, + ACTIONS(832), 1, anon_sym_DOT, STATE(234), 1, aux_sym_dotted_path_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6670] = 4, + [6574] = 4, ACTIONS(246), 1, anon_sym_RBRACK, - ACTIONS(931), 1, + ACTIONS(835), 1, anon_sym_COMMA, STATE(237), 1, aux_sym_list_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6684] = 4, - ACTIONS(933), 1, + [6588] = 4, + ACTIONS(837), 1, anon_sym_LBRACE, - ACTIONS(935), 1, + ACTIONS(839), 1, anon_sym_COMMA, STATE(263), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6698] = 4, - ACTIONS(937), 1, + [6602] = 4, + ACTIONS(841), 1, anon_sym_COMMA, - ACTIONS(940), 1, + ACTIONS(844), 1, anon_sym_RBRACK, STATE(237), 1, aux_sym_list_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6712] = 4, - ACTIONS(942), 1, + [6616] = 4, + ACTIONS(846), 1, anon_sym_COMMA, - ACTIONS(944), 1, + ACTIONS(848), 1, anon_sym_RPAREN, STATE(252), 1, aux_sym_action_node_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6726] = 4, - ACTIONS(946), 1, + [6630] = 4, + ACTIONS(850), 1, anon_sym_COMMA, - ACTIONS(948), 1, + ACTIONS(852), 1, anon_sym_RBRACE, STATE(161), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6740] = 4, - ACTIONS(950), 1, + [6644] = 4, + ACTIONS(854), 1, anon_sym_LBRACE, - ACTIONS(952), 1, + ACTIONS(856), 1, anon_sym_LPAREN, STATE(437), 1, sym_decorator_params, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6754] = 4, + [6658] = 4, ACTIONS(214), 1, anon_sym_LBRACE, - ACTIONS(954), 1, + ACTIONS(858), 1, anon_sym_as, STATE(231), 1, sym_block, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6768] = 4, - ACTIONS(956), 1, + [6672] = 4, + ACTIONS(860), 1, anon_sym_COMMA, - ACTIONS(958), 1, + ACTIONS(862), 1, anon_sym_RBRACK, STATE(245), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6782] = 4, - ACTIONS(960), 1, + [6686] = 4, + ACTIONS(864), 1, anon_sym_LBRACE, - ACTIONS(962), 1, + ACTIONS(866), 1, anon_sym_requires, STATE(435), 1, sym_requires_clause, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6796] = 4, - ACTIONS(675), 1, + [6700] = 4, + ACTIONS(579), 1, anon_sym_DOT, - ACTIONS(964), 1, + ACTIONS(868), 1, anon_sym_COLON, STATE(234), 1, aux_sym_dotted_path_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6810] = 4, - ACTIONS(966), 1, + [6714] = 4, + ACTIONS(870), 1, anon_sym_COMMA, - ACTIONS(968), 1, + ACTIONS(872), 1, anon_sym_RBRACK, STATE(161), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6824] = 3, - ACTIONS(972), 1, + [6728] = 3, + ACTIONS(876), 1, anon_sym_COMMA, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(970), 2, + ACTIONS(874), 2, anon_sym_RBRACE, sym_identifier, - [6836] = 4, + [6740] = 4, ACTIONS(54), 1, anon_sym_SEMI, - ACTIONS(974), 1, + ACTIONS(878), 1, anon_sym_COLON_COLON, STATE(265), 1, aux_sym_path_segments_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6850] = 4, - ACTIONS(909), 1, + [6754] = 4, + ACTIONS(813), 1, sym_identifier, - ACTIONS(977), 1, + ACTIONS(881), 1, anon_sym_RBRACE, STATE(319), 1, sym_sub_concept_field, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6864] = 3, - ACTIONS(860), 1, + [6768] = 3, + ACTIONS(764), 1, anon_sym_block, ACTIONS(3), 2, sym_line_comment, @@ -9327,94 +9276,94 @@ static const uint16_t ts_small_parse_table[] = { STATE(212), 2, sym_schedule_block, aux_sym_recurrence_block_repeat1, - [6876] = 4, - ACTIONS(979), 1, + [6780] = 4, + ACTIONS(883), 1, sym_identifier, - ACTIONS(981), 1, + ACTIONS(885), 1, anon_sym_RBRACE, STATE(286), 1, sym_required_field, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6890] = 4, - ACTIONS(977), 1, + [6794] = 4, + ACTIONS(881), 1, anon_sym_RBRACE, - ACTIONS(983), 1, + ACTIONS(887), 1, anon_sym_COMMA, STATE(230), 1, aux_sym_sub_concept_record_body_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6904] = 4, + [6808] = 4, ACTIONS(232), 1, anon_sym_RPAREN, - ACTIONS(985), 1, + ACTIONS(889), 1, anon_sym_COMMA, STATE(279), 1, aux_sym_action_node_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6918] = 2, + [6822] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(872), 3, + ACTIONS(776), 3, anon_sym_RBRACE, sym_prose_marker, sym_identifier, - [6928] = 4, - ACTIONS(987), 1, + [6832] = 4, + ACTIONS(891), 1, anon_sym_COMMA, - ACTIONS(990), 1, + ACTIONS(894), 1, anon_sym_RBRACE, STATE(254), 1, aux_sym_requires_clause_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6942] = 4, - ACTIONS(992), 1, + [6846] = 4, + ACTIONS(896), 1, anon_sym_COMMA, - ACTIONS(994), 1, + ACTIONS(898), 1, anon_sym_RBRACE, STATE(280), 1, aux_sym_requires_clause_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6956] = 2, + [6860] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(996), 3, + ACTIONS(900), 3, anon_sym_RBRACE, sym_prose_marker, sym_identifier, - [6966] = 4, - ACTIONS(920), 1, + [6870] = 4, + ACTIONS(824), 1, sym_identifier, - ACTIONS(998), 1, + ACTIONS(902), 1, anon_sym_RBRACE, STATE(334), 1, sym_field_condition, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6980] = 4, - ACTIONS(1000), 1, + [6884] = 4, + ACTIONS(904), 1, anon_sym_COMMA, - ACTIONS(1003), 1, + ACTIONS(907), 1, anon_sym_RBRACE, STATE(258), 1, aux_sym_variant_pattern_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [6994] = 4, - ACTIONS(813), 1, + [6898] = 4, + ACTIONS(717), 1, sym_identifier, STATE(8), 1, sym_path_segments, @@ -9423,8 +9372,8 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7008] = 4, - ACTIONS(813), 1, + [6912] = 4, + ACTIONS(717), 1, sym_identifier, STATE(8), 1, sym_path_segments, @@ -9433,349 +9382,349 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7022] = 4, - ACTIONS(1005), 1, + [6926] = 4, + ACTIONS(909), 1, anon_sym_COMMA, - ACTIONS(1007), 1, + ACTIONS(911), 1, anon_sym_RBRACE, STATE(161), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7036] = 4, - ACTIONS(888), 1, + [6940] = 4, + ACTIONS(792), 1, anon_sym_LBRACE, - ACTIONS(1009), 1, + ACTIONS(913), 1, anon_sym_strict, STATE(101), 1, sym_template_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7050] = 4, - ACTIONS(1011), 1, + [6954] = 4, + ACTIONS(915), 1, anon_sym_LBRACE, - ACTIONS(1013), 1, + ACTIONS(917), 1, anon_sym_COMMA, STATE(161), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7064] = 4, - ACTIONS(1015), 1, + [6968] = 4, + ACTIONS(919), 1, anon_sym_LBRACE, - ACTIONS(1017), 1, + ACTIONS(921), 1, anon_sym_modifies, STATE(97), 1, sym_schedule_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7078] = 4, + [6982] = 4, ACTIONS(58), 1, anon_sym_SEMI, - ACTIONS(1019), 1, + ACTIONS(923), 1, anon_sym_COLON_COLON, STATE(3), 1, aux_sym_path_segments_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7092] = 4, - ACTIONS(1022), 1, + [6996] = 4, + ACTIONS(926), 1, anon_sym_COMMA, - ACTIONS(1024), 1, + ACTIONS(928), 1, anon_sym_RBRACE, STATE(251), 1, aux_sym_sub_concept_record_body_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7106] = 2, + [7010] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1026), 3, + ACTIONS(930), 3, anon_sym_RBRACE, sym_prose_marker, sym_identifier, - [7116] = 4, - ACTIONS(1028), 1, + [7020] = 4, + ACTIONS(932), 1, sym_identifier, - ACTIONS(1030), 1, + ACTIONS(934), 1, anon_sym_RBRACE, STATE(337), 1, sym_variant_pattern, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7130] = 4, - ACTIONS(675), 1, + [7034] = 4, + ACTIONS(579), 1, anon_sym_DOT, - ACTIONS(786), 1, + ACTIONS(690), 1, anon_sym_COLON, STATE(244), 1, aux_sym_dotted_path_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7144] = 4, - ACTIONS(1028), 1, + [7048] = 4, + ACTIONS(932), 1, sym_identifier, - ACTIONS(1032), 1, + ACTIONS(936), 1, anon_sym_RBRACE, STATE(337), 1, sym_variant_pattern, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7158] = 4, - ACTIONS(1034), 1, + [7062] = 4, + ACTIONS(938), 1, anon_sym_COMMA, - ACTIONS(1037), 1, + ACTIONS(941), 1, anon_sym_RBRACE, STATE(271), 1, - aux_sym_concept_comparison_repeat1, + aux_sym_definition_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7172] = 2, + [7076] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1039), 3, + ACTIONS(943), 3, anon_sym_COMMA, anon_sym_RBRACE, anon_sym_or, - [7182] = 4, - ACTIONS(1041), 1, + [7086] = 4, + ACTIONS(945), 1, anon_sym_behaviors, - ACTIONS(1043), 1, + ACTIONS(947), 1, anon_sym_schedule, - ACTIONS(1045), 1, + ACTIONS(949), 1, anon_sym_schedules, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7196] = 4, - ACTIONS(1030), 1, + [7100] = 4, + ACTIONS(934), 1, anon_sym_RBRACE, - ACTIONS(1047), 1, + ACTIONS(951), 1, anon_sym_COMMA, STATE(271), 1, - aux_sym_concept_comparison_repeat1, + aux_sym_definition_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7210] = 4, - ACTIONS(1049), 1, + [7114] = 4, + ACTIONS(953), 1, anon_sym_COMMA, - ACTIONS(1051), 1, + ACTIONS(955), 1, anon_sym_RBRACE, STATE(261), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7224] = 4, - ACTIONS(1053), 1, + [7128] = 4, + ACTIONS(957), 1, anon_sym_COMMA, - ACTIONS(1055), 1, + ACTIONS(959), 1, anon_sym_RBRACE, STATE(274), 1, - aux_sym_concept_comparison_repeat1, + aux_sym_definition_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7238] = 4, - ACTIONS(979), 1, + [7142] = 4, + ACTIONS(883), 1, sym_identifier, - ACTIONS(1057), 1, + ACTIONS(961), 1, anon_sym_RBRACE, STATE(286), 1, sym_required_field, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7252] = 4, - ACTIONS(1059), 1, + [7156] = 4, + ACTIONS(963), 1, anon_sym_COMMA, - ACTIONS(1061), 1, + ACTIONS(965), 1, anon_sym_RBRACE, STATE(161), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7266] = 4, - ACTIONS(1063), 1, + [7170] = 4, + ACTIONS(967), 1, anon_sym_COMMA, - ACTIONS(1066), 1, + ACTIONS(970), 1, anon_sym_RPAREN, STATE(279), 1, aux_sym_action_node_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7280] = 4, - ACTIONS(1057), 1, + [7184] = 4, + ACTIONS(961), 1, anon_sym_RBRACE, - ACTIONS(1068), 1, + ACTIONS(972), 1, anon_sym_COMMA, STATE(254), 1, aux_sym_requires_clause_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7294] = 4, - ACTIONS(1070), 1, + [7198] = 4, + ACTIONS(974), 1, anon_sym_COMMA, - ACTIONS(1072), 1, + ACTIONS(976), 1, anon_sym_RBRACE, STATE(278), 1, aux_sym_use_declaration_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7308] = 4, - ACTIONS(1074), 1, + [7212] = 4, + ACTIONS(978), 1, anon_sym_COMMA, - ACTIONS(1076), 1, + ACTIONS(980), 1, anon_sym_RBRACK, STATE(235), 1, aux_sym_list_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7322] = 4, - ACTIONS(1078), 1, + [7226] = 4, + ACTIONS(982), 1, anon_sym_COMMA, - ACTIONS(1080), 1, + ACTIONS(984), 1, anon_sym_RBRACE, STATE(233), 1, aux_sym_variant_pattern_repeat1, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7336] = 3, - ACTIONS(968), 1, + [7240] = 3, + ACTIONS(872), 1, anon_sym_RBRACK, - ACTIONS(1082), 1, + ACTIONS(986), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7347] = 2, + [7251] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1084), 2, + ACTIONS(988), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7356] = 2, + [7260] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(990), 2, + ACTIONS(894), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7365] = 3, - ACTIONS(1086), 1, + [7269] = 3, + ACTIONS(990), 1, sym_identifier, STATE(293), 1, sym_path_segments, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7376] = 3, - ACTIONS(1088), 1, + [7280] = 3, + ACTIONS(992), 1, sym_identifier, - ACTIONS(1090), 1, + ACTIONS(994), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7387] = 3, - ACTIONS(1092), 1, + [7291] = 3, + ACTIONS(996), 1, sym_identifier, - ACTIONS(1094), 1, + ACTIONS(998), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7398] = 3, - ACTIONS(1096), 1, + [7302] = 3, + ACTIONS(1000), 1, anon_sym_LBRACE, - ACTIONS(1098), 1, + ACTIONS(1002), 1, anon_sym_LPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7409] = 2, + [7313] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1100), 2, + ACTIONS(1004), 2, anon_sym_LBRACE, anon_sym_LPAREN, - [7418] = 3, - ACTIONS(1007), 1, + [7322] = 3, + ACTIONS(911), 1, anon_sym_RBRACE, - ACTIONS(1082), 1, + ACTIONS(986), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7429] = 3, - ACTIONS(1102), 1, + [7333] = 3, + ACTIONS(1006), 1, anon_sym_COLON_COLON, - ACTIONS(1104), 1, + ACTIONS(1008), 1, anon_sym_SEMI, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7440] = 3, - ACTIONS(948), 1, + [7344] = 3, + ACTIONS(852), 1, anon_sym_RBRACE, - ACTIONS(1082), 1, + ACTIONS(986), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7451] = 3, - ACTIONS(1061), 1, + [7355] = 3, + ACTIONS(965), 1, anon_sym_RBRACE, - ACTIONS(1082), 1, + ACTIONS(986), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7462] = 2, + [7366] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(926), 2, + ACTIONS(830), 2, anon_sym_COLON, anon_sym_DOT, - [7471] = 3, - ACTIONS(1106), 1, + [7375] = 3, + ACTIONS(1010), 1, anon_sym_LBRACE, STATE(108), 1, sym_behavior_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7482] = 3, - ACTIONS(1028), 1, + [7386] = 3, + ACTIONS(932), 1, sym_identifier, STATE(337), 1, sym_variant_pattern, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7493] = 3, + [7397] = 3, ACTIONS(214), 1, anon_sym_LBRACE, STATE(109), 1, @@ -9783,15 +9732,15 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7504] = 3, - ACTIONS(1108), 1, + [7408] = 3, + ACTIONS(1012), 1, anon_sym_LBRACE, STATE(110), 1, sym_relationship_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7515] = 3, + [7419] = 3, ACTIONS(214), 1, anon_sym_LBRACE, STATE(111), 1, @@ -9799,47 +9748,47 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7526] = 3, - ACTIONS(1028), 1, + [7430] = 3, + ACTIONS(932), 1, sym_identifier, STATE(276), 1, sym_variant_pattern, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7537] = 3, - ACTIONS(1110), 1, + [7441] = 3, + ACTIONS(1014), 1, anon_sym_LBRACE, STATE(88), 1, sym_species_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7548] = 3, - ACTIONS(1082), 1, + [7452] = 3, + ACTIONS(986), 1, sym_identifier, - ACTIONS(1112), 1, + ACTIONS(1016), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7559] = 3, - ACTIONS(1116), 1, + [7463] = 3, + ACTIONS(1020), 1, aux_sym_prose_block_token1, - ACTIONS(1118), 1, + ACTIONS(1022), 1, sym_prose_content, - ACTIONS(1114), 2, + ACTIONS(1018), 2, sym_line_comment, sym_block_comment, - [7570] = 3, - ACTIONS(1120), 1, + [7474] = 3, + ACTIONS(1024), 1, sym_identifier, - ACTIONS(1122), 1, + ACTIONS(1026), 1, anon_sym_LBRACK, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7581] = 3, + [7485] = 3, ACTIONS(214), 1, anon_sym_LBRACE, STATE(213), 1, @@ -9847,150 +9796,150 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7592] = 3, - ACTIONS(1124), 1, + [7496] = 3, + ACTIONS(1028), 1, sym_time, STATE(202), 1, sym_time_range, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7603] = 2, + [7507] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1126), 2, + ACTIONS(1030), 2, anon_sym_RBRACE, anon_sym_state, - [7612] = 3, - ACTIONS(1124), 1, + [7516] = 3, + ACTIONS(1028), 1, sym_time, STATE(203), 1, sym_time_range, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7623] = 2, + [7527] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1128), 2, + ACTIONS(1032), 2, anon_sym_RBRACE, anon_sym_state, - [7632] = 3, - ACTIONS(979), 1, + [7536] = 3, + ACTIONS(883), 1, sym_identifier, STATE(286), 1, sym_required_field, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7643] = 3, - ACTIONS(799), 1, + [7547] = 3, + ACTIONS(703), 1, anon_sym_LBRACE, STATE(74), 1, sym_character_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7654] = 3, - ACTIONS(1011), 1, + [7558] = 3, + ACTIONS(915), 1, anon_sym_LBRACE, - ACTIONS(1082), 1, + ACTIONS(986), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7665] = 2, + [7569] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1130), 2, + ACTIONS(1034), 2, anon_sym_COMMA, anon_sym_RPAREN, - [7674] = 2, + [7578] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1066), 2, + ACTIONS(970), 2, anon_sym_COMMA, anon_sym_RPAREN, - [7683] = 2, + [7587] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1132), 2, + ACTIONS(1036), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7692] = 3, - ACTIONS(1082), 1, + [7596] = 3, + ACTIONS(986), 1, sym_identifier, - ACTIONS(1134), 1, + ACTIONS(1038), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7703] = 2, + [7607] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(916), 2, + ACTIONS(820), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7712] = 3, - ACTIONS(1136), 1, + [7616] = 3, + ACTIONS(1040), 1, sym_integer, - ACTIONS(1138), 1, + ACTIONS(1042), 1, sym_duration, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7723] = 2, + [7627] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1140), 2, + ACTIONS(1044), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7732] = 3, - ACTIONS(1142), 1, + [7636] = 3, + ACTIONS(1046), 1, anon_sym_DOT_DOT, - ACTIONS(1144), 1, + ACTIONS(1048), 1, anon_sym_RPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7743] = 2, + [7647] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(940), 2, + ACTIONS(844), 2, anon_sym_COMMA, anon_sym_RBRACK, - [7752] = 2, + [7656] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1146), 2, + ACTIONS(1050), 2, anon_sym_COMMA, anon_sym_RPAREN, - [7761] = 3, - ACTIONS(1148), 1, + [7665] = 3, + ACTIONS(1052), 1, anon_sym_DOT_DOT, - ACTIONS(1150), 1, + ACTIONS(1054), 1, anon_sym_RPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7772] = 3, - ACTIONS(1152), 1, + [7676] = 3, + ACTIONS(1056), 1, anon_sym_LBRACE, - ACTIONS(1154), 1, + ACTIONS(1058), 1, anon_sym_STAR, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7783] = 3, + [7687] = 3, ACTIONS(214), 1, anon_sym_LBRACE, STATE(256), 1, @@ -9998,797 +9947,797 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7794] = 3, - ACTIONS(1156), 1, + [7698] = 3, + ACTIONS(1060), 1, anon_sym_LBRACE, STATE(311), 1, sym_state_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7805] = 2, + [7709] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1158), 2, + ACTIONS(1062), 2, anon_sym_RBRACE, anon_sym_state, - [7814] = 3, - ACTIONS(1082), 1, + [7718] = 3, + ACTIONS(986), 1, sym_identifier, - ACTIONS(1160), 1, + ACTIONS(1064), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7825] = 3, - ACTIONS(909), 1, + [7729] = 3, + ACTIONS(813), 1, sym_identifier, STATE(319), 1, sym_sub_concept_field, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7836] = 2, + [7740] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1162), 2, + ACTIONS(1066), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7845] = 2, + [7749] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1164), 2, + ACTIONS(1068), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7854] = 2, + [7758] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1003), 2, + ACTIONS(907), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7863] = 3, - ACTIONS(920), 1, + [7767] = 3, + ACTIONS(824), 1, sym_identifier, STATE(283), 1, sym_field_condition, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7874] = 3, - ACTIONS(799), 1, + [7778] = 3, + ACTIONS(703), 1, anon_sym_LBRACE, STATE(72), 1, sym_character_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7885] = 2, + [7789] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1037), 2, + ACTIONS(941), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7894] = 3, - ACTIONS(1082), 1, + [7798] = 3, + ACTIONS(986), 1, sym_identifier, - ACTIONS(1166), 1, + ACTIONS(1070), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7905] = 3, - ACTIONS(1082), 1, + [7809] = 3, + ACTIONS(986), 1, sym_identifier, - ACTIONS(1168), 1, + ACTIONS(1072), 1, anon_sym_RBRACK, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7916] = 2, + [7820] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1170), 2, + ACTIONS(1074), 2, anon_sym_RBRACE, sym_identifier, - [7925] = 2, + [7829] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1172), 2, + ACTIONS(1076), 2, anon_sym_RBRACE, sym_identifier, - [7934] = 2, + [7838] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1174), 2, + ACTIONS(1078), 2, anon_sym_RBRACE, anon_sym_on, - [7943] = 2, + [7847] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1176), 2, + ACTIONS(1080), 2, anon_sym_RBRACE, anon_sym_state, - [7952] = 3, - ACTIONS(1178), 1, + [7856] = 3, + ACTIONS(1082), 1, sym_identifier, STATE(228), 1, sym_is_value, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7963] = 2, + [7867] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1180), 2, + ACTIONS(1084), 2, anon_sym_COMMA, anon_sym_RBRACE, - [7972] = 3, - ACTIONS(920), 1, + [7876] = 3, + ACTIONS(824), 1, sym_identifier, STATE(334), 1, sym_field_condition, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7983] = 3, - ACTIONS(979), 1, + [7887] = 3, + ACTIONS(883), 1, sym_identifier, STATE(255), 1, sym_required_field, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [7994] = 3, - ACTIONS(1015), 1, + [7898] = 3, + ACTIONS(919), 1, anon_sym_LBRACE, STATE(104), 1, sym_schedule_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8005] = 3, - ACTIONS(1182), 1, + [7909] = 3, + ACTIONS(1086), 1, sym_integer, - ACTIONS(1184), 1, + ACTIONS(1088), 1, sym_duration, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8016] = 2, + [7920] = 2, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - ACTIONS(1186), 2, + ACTIONS(1090), 2, anon_sym_RBRACE, anon_sym_state, - [8025] = 3, - ACTIONS(888), 1, + [7929] = 3, + ACTIONS(792), 1, anon_sym_LBRACE, STATE(79), 1, sym_template_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8036] = 3, - ACTIONS(888), 1, + [7940] = 3, + ACTIONS(792), 1, anon_sym_LBRACE, STATE(75), 1, sym_template_body, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8047] = 2, - ACTIONS(1188), 1, + [7951] = 2, + ACTIONS(1092), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8055] = 2, - ACTIONS(1190), 1, + [7959] = 2, + ACTIONS(1094), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8063] = 2, - ACTIONS(1192), 1, + [7967] = 2, + ACTIONS(1096), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8071] = 2, - ACTIONS(1194), 1, + [7975] = 2, + ACTIONS(1098), 1, anon_sym_SEMI, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8079] = 2, - ACTIONS(1196), 1, + [7983] = 2, + ACTIONS(1100), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8087] = 2, - ACTIONS(1198), 1, + [7991] = 2, + ACTIONS(1102), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8095] = 2, - ACTIONS(1200), 1, + [7999] = 2, + ACTIONS(1104), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8103] = 2, - ACTIONS(1202), 1, + [8007] = 2, + ACTIONS(1106), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8111] = 2, - ACTIONS(1204), 1, + [8015] = 2, + ACTIONS(1108), 1, anon_sym_RPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8119] = 2, - ACTIONS(1206), 1, + [8023] = 2, + ACTIONS(1110), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, + [8031] = 2, + ACTIONS(1112), 1, + sym_identifier, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8039] = 2, + ACTIONS(1114), 1, + anon_sym_DOT, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8047] = 2, + ACTIONS(1116), 1, + anon_sym_RBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8055] = 2, + ACTIONS(1118), 1, + anon_sym_COLON, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8063] = 2, + ACTIONS(1120), 1, + anon_sym_COLON, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8071] = 2, + ACTIONS(1122), 1, + anon_sym_RPAREN, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8079] = 2, + ACTIONS(1124), 1, + anon_sym_COLON, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8087] = 2, + ACTIONS(1126), 1, + anon_sym_LPAREN, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8095] = 2, + ACTIONS(1128), 1, + anon_sym_SEMI, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8103] = 2, + ACTIONS(807), 1, + anon_sym_COLON, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8111] = 2, + ACTIONS(1130), 1, + sym_identifier, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8119] = 2, + ACTIONS(1132), 1, + anon_sym_LBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, [8127] = 2, - ACTIONS(1208), 1, + ACTIONS(1134), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8135] = 2, - ACTIONS(1210), 1, - anon_sym_DOT, - ACTIONS(3), 2, + ACTIONS(1136), 1, + sym_prose_content, + ACTIONS(1018), 2, sym_line_comment, sym_block_comment, [8143] = 2, - ACTIONS(1212), 1, - anon_sym_RBRACE, + ACTIONS(1138), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8151] = 2, - ACTIONS(1214), 1, - anon_sym_COLON, + ACTIONS(1140), 1, + sym_prose_marker, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8159] = 2, - ACTIONS(1216), 1, - anon_sym_COLON, + ACTIONS(1142), 1, + anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8167] = 2, - ACTIONS(1218), 1, - anon_sym_RPAREN, + ACTIONS(1144), 1, + anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8175] = 2, - ACTIONS(1220), 1, + ACTIONS(1146), 1, anon_sym_COLON, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8183] = 2, - ACTIONS(1222), 1, + ACTIONS(1148), 1, anon_sym_LPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8191] = 2, - ACTIONS(1224), 1, - anon_sym_SEMI, + ACTIONS(1048), 1, + anon_sym_RPAREN, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8199] = 2, - ACTIONS(903), 1, - anon_sym_COLON, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8207] = 2, - ACTIONS(1226), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8215] = 2, - ACTIONS(1228), 1, + ACTIONS(1150), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, + [8207] = 2, + ACTIONS(1152), 1, + anon_sym_COLON, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8215] = 2, + ACTIONS(1154), 1, + sym_identifier, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, [8223] = 2, - ACTIONS(1230), 1, + ACTIONS(1156), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8231] = 2, - ACTIONS(1232), 1, - sym_prose_content, - ACTIONS(1114), 2, + ACTIONS(1158), 1, + anon_sym_on, + ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8239] = 2, - ACTIONS(1234), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8247] = 2, - ACTIONS(1236), 1, - sym_prose_marker, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8255] = 2, - ACTIONS(1238), 1, - anon_sym_LBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8263] = 2, - ACTIONS(1240), 1, + ACTIONS(1160), 1, anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, + [8247] = 2, + ACTIONS(1162), 1, + anon_sym_LBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8255] = 2, + ACTIONS(1054), 1, + anon_sym_RPAREN, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8263] = 2, + ACTIONS(1164), 1, + sym_identifier, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, [8271] = 2, - ACTIONS(1242), 1, + ACTIONS(1166), 1, anon_sym_COLON, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8279] = 2, - ACTIONS(1244), 1, - anon_sym_LPAREN, + ACTIONS(1168), 1, + anon_sym_SEMI, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8287] = 2, - ACTIONS(1144), 1, - anon_sym_RPAREN, + ACTIONS(1170), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8295] = 2, - ACTIONS(1246), 1, - anon_sym_LBRACE, + ACTIONS(1172), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8303] = 2, - ACTIONS(1248), 1, - anon_sym_COLON, + ACTIONS(1174), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8311] = 2, - ACTIONS(1250), 1, + ACTIONS(1176), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8319] = 2, - ACTIONS(1252), 1, + ACTIONS(1178), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8327] = 2, - ACTIONS(1254), 1, - anon_sym_on, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8335] = 2, - ACTIONS(1256), 1, - anon_sym_RBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8343] = 2, - ACTIONS(1258), 1, - anon_sym_LBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8351] = 2, - ACTIONS(1150), 1, - anon_sym_RPAREN, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8359] = 2, - ACTIONS(1260), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8367] = 2, - ACTIONS(1262), 1, + ACTIONS(1180), 1, anon_sym_COLON, ACTIONS(3), 2, sym_line_comment, sym_block_comment, + [8335] = 2, + ACTIONS(1182), 1, + sym_identifier, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8343] = 2, + ACTIONS(1184), 1, + sym_identifier, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8351] = 2, + ACTIONS(1186), 1, + anon_sym_RBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8359] = 2, + ACTIONS(1188), 1, + anon_sym_RBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8367] = 2, + ACTIONS(1190), 1, + anon_sym_LBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, [8375] = 2, - ACTIONS(1264), 1, - anon_sym_SEMI, + ACTIONS(1192), 1, + anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8383] = 2, - ACTIONS(1266), 1, + ACTIONS(1194), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8391] = 2, - ACTIONS(1268), 1, - sym_identifier, + ACTIONS(1196), 1, + anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8399] = 2, - ACTIONS(1270), 1, - sym_identifier, + ACTIONS(1198), 1, + anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8407] = 2, - ACTIONS(1272), 1, + ACTIONS(1200), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8415] = 2, - ACTIONS(1274), 1, - sym_identifier, + ACTIONS(1202), 1, + anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8423] = 2, - ACTIONS(1276), 1, - anon_sym_COLON, + ACTIONS(1204), 1, + anon_sym_is, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8431] = 2, - ACTIONS(1278), 1, + ACTIONS(1206), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8439] = 2, - ACTIONS(1280), 1, - sym_identifier, + ACTIONS(1208), 1, + anon_sym_COLON, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8447] = 2, - ACTIONS(1282), 1, - anon_sym_RBRACE, + ACTIONS(1210), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8455] = 2, - ACTIONS(1284), 1, - anon_sym_RBRACE, + ACTIONS(1212), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8463] = 2, - ACTIONS(1286), 1, - anon_sym_LBRACE, + ACTIONS(1214), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8471] = 2, - ACTIONS(1288), 1, - anon_sym_RBRACE, + ACTIONS(1216), 1, + sym_time, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8479] = 2, - ACTIONS(1290), 1, + ACTIONS(1218), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8487] = 2, - ACTIONS(1292), 1, - anon_sym_RBRACE, + ACTIONS(1220), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8495] = 2, - ACTIONS(1294), 1, - anon_sym_LBRACE, + ACTIONS(1222), 1, + anon_sym_SEMI, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8503] = 2, - ACTIONS(1296), 1, + ACTIONS(1224), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8511] = 2, - ACTIONS(1298), 1, - anon_sym_LBRACE, + ACTIONS(1226), 1, + sym_integer, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8519] = 2, - ACTIONS(1300), 1, - anon_sym_is, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8527] = 2, - ACTIONS(1302), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8535] = 2, - ACTIONS(1304), 1, + ACTIONS(1228), 1, anon_sym_COLON, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8543] = 2, - ACTIONS(1306), 1, + [8527] = 2, + ACTIONS(1230), 1, + anon_sym_LBRACE, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, + [8535] = 2, + ACTIONS(1232), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, + [8543] = 2, + ACTIONS(1234), 1, + sym_prose_marker, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, [8551] = 2, - ACTIONS(1308), 1, - sym_identifier, + ACTIONS(1236), 1, + anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8559] = 2, - ACTIONS(1310), 1, - sym_identifier, + ACTIONS(1238), 1, + anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8567] = 2, - ACTIONS(1312), 1, - sym_time, + ACTIONS(1240), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8575] = 2, - ACTIONS(1314), 1, + ACTIONS(1242), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8583] = 2, - ACTIONS(1316), 1, - sym_identifier, + ACTIONS(1244), 1, + anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8591] = 2, - ACTIONS(1318), 1, - anon_sym_SEMI, + ACTIONS(1246), 1, + sym_integer, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8599] = 2, - ACTIONS(1320), 1, + ACTIONS(1248), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8607] = 2, - ACTIONS(1322), 1, - sym_integer, + ACTIONS(1250), 1, + anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8615] = 2, - ACTIONS(1324), 1, - anon_sym_COLON, + ACTIONS(1246), 1, + sym_float, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8623] = 2, - ACTIONS(1326), 1, + ACTIONS(1252), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8631] = 2, - ACTIONS(1328), 1, - sym_identifier, + ACTIONS(1254), 1, + anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8639] = 2, - ACTIONS(1330), 1, - sym_prose_marker, + ACTIONS(1256), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8647] = 2, - ACTIONS(1332), 1, - anon_sym_LBRACE, + ACTIONS(1258), 1, + anon_sym_RBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8655] = 2, - ACTIONS(1334), 1, - anon_sym_LBRACE, + ACTIONS(986), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8663] = 2, - ACTIONS(1336), 1, + ACTIONS(1260), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8671] = 2, - ACTIONS(1338), 1, + ACTIONS(1262), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8679] = 2, - ACTIONS(1340), 1, - anon_sym_LBRACE, + ACTIONS(1264), 1, + sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8687] = 2, - ACTIONS(1342), 1, - sym_integer, + ACTIONS(1266), 1, + anon_sym_DASH_GT, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8695] = 2, - ACTIONS(1344), 1, + ACTIONS(1268), 1, sym_identifier, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8703] = 2, - ACTIONS(1346), 1, + ACTIONS(1270), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8711] = 2, - ACTIONS(1342), 1, - sym_float, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8719] = 2, - ACTIONS(1348), 1, + ACTIONS(1272), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, + [8719] = 2, + ACTIONS(1274), 1, + sym_integer, + ACTIONS(3), 2, + sym_line_comment, + sym_block_comment, [8727] = 2, - ACTIONS(1350), 1, + ACTIONS(1276), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, sym_block_comment, [8735] = 2, - ACTIONS(1352), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8743] = 2, - ACTIONS(1354), 1, - anon_sym_RBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8751] = 2, - ACTIONS(1082), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8759] = 2, - ACTIONS(1356), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8767] = 2, - ACTIONS(1358), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8775] = 2, - ACTIONS(1360), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8783] = 2, - ACTIONS(1362), 1, - anon_sym_DASH_GT, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8791] = 2, - ACTIONS(1364), 1, - sym_identifier, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8799] = 2, - ACTIONS(1366), 1, - anon_sym_LBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8807] = 2, - ACTIONS(1368), 1, - anon_sym_LBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8815] = 2, - ACTIONS(1370), 1, - sym_integer, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8823] = 2, - ACTIONS(1372), 1, - anon_sym_LBRACE, - ACTIONS(3), 2, - sym_line_comment, - sym_block_comment, - [8831] = 2, - ACTIONS(1374), 1, + ACTIONS(1278), 1, ts_builtin_sym_end, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8839] = 2, - ACTIONS(1376), 1, + [8743] = 2, + ACTIONS(1280), 1, anon_sym_COLON, ACTIONS(3), 2, sym_line_comment, sym_block_comment, - [8847] = 2, - ACTIONS(1378), 1, + [8751] = 2, + ACTIONS(1282), 1, anon_sym_LBRACE, ACTIONS(3), 2, sym_line_comment, @@ -10859,395 +10808,395 @@ static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(62)] = 2878, [SMALL_STATE(63)] = 2920, [SMALL_STATE(64)] = 2962, - [SMALL_STATE(65)] = 2986, - [SMALL_STATE(66)] = 3010, - [SMALL_STATE(67)] = 3034, - [SMALL_STATE(68)] = 3058, - [SMALL_STATE(69)] = 3082, - [SMALL_STATE(70)] = 3106, - [SMALL_STATE(71)] = 3130, - [SMALL_STATE(72)] = 3154, - [SMALL_STATE(73)] = 3178, - [SMALL_STATE(74)] = 3202, - [SMALL_STATE(75)] = 3226, - [SMALL_STATE(76)] = 3250, - [SMALL_STATE(77)] = 3274, - [SMALL_STATE(78)] = 3298, - [SMALL_STATE(79)] = 3324, - [SMALL_STATE(80)] = 3348, - [SMALL_STATE(81)] = 3372, - [SMALL_STATE(82)] = 3396, - [SMALL_STATE(83)] = 3420, - [SMALL_STATE(84)] = 3444, - [SMALL_STATE(85)] = 3468, - [SMALL_STATE(86)] = 3492, - [SMALL_STATE(87)] = 3516, - [SMALL_STATE(88)] = 3540, - [SMALL_STATE(89)] = 3564, - [SMALL_STATE(90)] = 3588, - [SMALL_STATE(91)] = 3614, - [SMALL_STATE(92)] = 3638, - [SMALL_STATE(93)] = 3662, - [SMALL_STATE(94)] = 3686, - [SMALL_STATE(95)] = 3710, - [SMALL_STATE(96)] = 3734, - [SMALL_STATE(97)] = 3758, - [SMALL_STATE(98)] = 3782, - [SMALL_STATE(99)] = 3806, - [SMALL_STATE(100)] = 3830, - [SMALL_STATE(101)] = 3854, - [SMALL_STATE(102)] = 3878, - [SMALL_STATE(103)] = 3902, - [SMALL_STATE(104)] = 3926, - [SMALL_STATE(105)] = 3950, - [SMALL_STATE(106)] = 3974, - [SMALL_STATE(107)] = 3998, - [SMALL_STATE(108)] = 4022, - [SMALL_STATE(109)] = 4046, - [SMALL_STATE(110)] = 4070, - [SMALL_STATE(111)] = 4094, - [SMALL_STATE(112)] = 4118, - [SMALL_STATE(113)] = 4142, - [SMALL_STATE(114)] = 4166, - [SMALL_STATE(115)] = 4189, - [SMALL_STATE(116)] = 4212, - [SMALL_STATE(117)] = 4235, - [SMALL_STATE(118)] = 4258, - [SMALL_STATE(119)] = 4281, - [SMALL_STATE(120)] = 4304, - [SMALL_STATE(121)] = 4327, - [SMALL_STATE(122)] = 4350, - [SMALL_STATE(123)] = 4373, - [SMALL_STATE(124)] = 4396, - [SMALL_STATE(125)] = 4419, - [SMALL_STATE(126)] = 4442, - [SMALL_STATE(127)] = 4465, - [SMALL_STATE(128)] = 4488, - [SMALL_STATE(129)] = 4511, - [SMALL_STATE(130)] = 4534, - [SMALL_STATE(131)] = 4557, - [SMALL_STATE(132)] = 4593, - [SMALL_STATE(133)] = 4629, - [SMALL_STATE(134)] = 4665, - [SMALL_STATE(135)] = 4698, - [SMALL_STATE(136)] = 4731, - [SMALL_STATE(137)] = 4764, - [SMALL_STATE(138)] = 4798, - [SMALL_STATE(139)] = 4832, - [SMALL_STATE(140)] = 4853, - [SMALL_STATE(141)] = 4872, - [SMALL_STATE(142)] = 4905, - [SMALL_STATE(143)] = 4928, - [SMALL_STATE(144)] = 4953, - [SMALL_STATE(145)] = 4984, - [SMALL_STATE(146)] = 5015, - [SMALL_STATE(147)] = 5038, - [SMALL_STATE(148)] = 5069, - [SMALL_STATE(149)] = 5102, - [SMALL_STATE(150)] = 5121, - [SMALL_STATE(151)] = 5152, - [SMALL_STATE(152)] = 5185, - [SMALL_STATE(153)] = 5216, - [SMALL_STATE(154)] = 5235, - [SMALL_STATE(155)] = 5266, - [SMALL_STATE(156)] = 5297, - [SMALL_STATE(157)] = 5323, - [SMALL_STATE(158)] = 5349, - [SMALL_STATE(159)] = 5375, - [SMALL_STATE(160)] = 5403, - [SMALL_STATE(161)] = 5431, - [SMALL_STATE(162)] = 5453, - [SMALL_STATE(163)] = 5479, - [SMALL_STATE(164)] = 5496, - [SMALL_STATE(165)] = 5518, - [SMALL_STATE(166)] = 5540, - [SMALL_STATE(167)] = 5564, - [SMALL_STATE(168)] = 5588, - [SMALL_STATE(169)] = 5612, - [SMALL_STATE(170)] = 5636, - [SMALL_STATE(171)] = 5656, - [SMALL_STATE(172)] = 5680, - [SMALL_STATE(173)] = 5700, - [SMALL_STATE(174)] = 5724, - [SMALL_STATE(175)] = 5748, - [SMALL_STATE(176)] = 5767, - [SMALL_STATE(177)] = 5782, - [SMALL_STATE(178)] = 5801, - [SMALL_STATE(179)] = 5822, - [SMALL_STATE(180)] = 5837, - [SMALL_STATE(181)] = 5852, - [SMALL_STATE(182)] = 5867, - [SMALL_STATE(183)] = 5888, - [SMALL_STATE(184)] = 5903, - [SMALL_STATE(185)] = 5924, - [SMALL_STATE(186)] = 5938, - [SMALL_STATE(187)] = 5952, - [SMALL_STATE(188)] = 5966, - [SMALL_STATE(189)] = 5986, - [SMALL_STATE(190)] = 6002, - [SMALL_STATE(191)] = 6016, - [SMALL_STATE(192)] = 6036, - [SMALL_STATE(193)] = 6050, - [SMALL_STATE(194)] = 6070, - [SMALL_STATE(195)] = 6084, - [SMALL_STATE(196)] = 6098, - [SMALL_STATE(197)] = 6116, - [SMALL_STATE(198)] = 6130, - [SMALL_STATE(199)] = 6144, - [SMALL_STATE(200)] = 6160, - [SMALL_STATE(201)] = 6175, - [SMALL_STATE(202)] = 6192, - [SMALL_STATE(203)] = 6207, - [SMALL_STATE(204)] = 6222, - [SMALL_STATE(205)] = 6237, - [SMALL_STATE(206)] = 6252, - [SMALL_STATE(207)] = 6267, - [SMALL_STATE(208)] = 6282, - [SMALL_STATE(209)] = 6297, - [SMALL_STATE(210)] = 6310, - [SMALL_STATE(211)] = 6325, - [SMALL_STATE(212)] = 6340, - [SMALL_STATE(213)] = 6355, - [SMALL_STATE(214)] = 6368, - [SMALL_STATE(215)] = 6383, - [SMALL_STATE(216)] = 6398, - [SMALL_STATE(217)] = 6411, - [SMALL_STATE(218)] = 6424, - [SMALL_STATE(219)] = 6439, - [SMALL_STATE(220)] = 6454, - [SMALL_STATE(221)] = 6469, - [SMALL_STATE(222)] = 6484, - [SMALL_STATE(223)] = 6499, - [SMALL_STATE(224)] = 6514, - [SMALL_STATE(225)] = 6531, - [SMALL_STATE(226)] = 6546, - [SMALL_STATE(227)] = 6563, - [SMALL_STATE(228)] = 6580, - [SMALL_STATE(229)] = 6590, - [SMALL_STATE(230)] = 6604, - [SMALL_STATE(231)] = 6618, - [SMALL_STATE(232)] = 6628, - [SMALL_STATE(233)] = 6642, - [SMALL_STATE(234)] = 6656, - [SMALL_STATE(235)] = 6670, - [SMALL_STATE(236)] = 6684, - [SMALL_STATE(237)] = 6698, - [SMALL_STATE(238)] = 6712, - [SMALL_STATE(239)] = 6726, - [SMALL_STATE(240)] = 6740, - [SMALL_STATE(241)] = 6754, - [SMALL_STATE(242)] = 6768, - [SMALL_STATE(243)] = 6782, - [SMALL_STATE(244)] = 6796, - [SMALL_STATE(245)] = 6810, - [SMALL_STATE(246)] = 6824, - [SMALL_STATE(247)] = 6836, - [SMALL_STATE(248)] = 6850, - [SMALL_STATE(249)] = 6864, - [SMALL_STATE(250)] = 6876, - [SMALL_STATE(251)] = 6890, - [SMALL_STATE(252)] = 6904, - [SMALL_STATE(253)] = 6918, - [SMALL_STATE(254)] = 6928, - [SMALL_STATE(255)] = 6942, - [SMALL_STATE(256)] = 6956, - [SMALL_STATE(257)] = 6966, - [SMALL_STATE(258)] = 6980, - [SMALL_STATE(259)] = 6994, - [SMALL_STATE(260)] = 7008, - [SMALL_STATE(261)] = 7022, - [SMALL_STATE(262)] = 7036, - [SMALL_STATE(263)] = 7050, - [SMALL_STATE(264)] = 7064, - [SMALL_STATE(265)] = 7078, - [SMALL_STATE(266)] = 7092, - [SMALL_STATE(267)] = 7106, - [SMALL_STATE(268)] = 7116, - [SMALL_STATE(269)] = 7130, - [SMALL_STATE(270)] = 7144, - [SMALL_STATE(271)] = 7158, - [SMALL_STATE(272)] = 7172, - [SMALL_STATE(273)] = 7182, - [SMALL_STATE(274)] = 7196, - [SMALL_STATE(275)] = 7210, - [SMALL_STATE(276)] = 7224, - [SMALL_STATE(277)] = 7238, - [SMALL_STATE(278)] = 7252, - [SMALL_STATE(279)] = 7266, - [SMALL_STATE(280)] = 7280, - [SMALL_STATE(281)] = 7294, - [SMALL_STATE(282)] = 7308, - [SMALL_STATE(283)] = 7322, - [SMALL_STATE(284)] = 7336, - [SMALL_STATE(285)] = 7347, - [SMALL_STATE(286)] = 7356, - [SMALL_STATE(287)] = 7365, - [SMALL_STATE(288)] = 7376, - [SMALL_STATE(289)] = 7387, - [SMALL_STATE(290)] = 7398, - [SMALL_STATE(291)] = 7409, - [SMALL_STATE(292)] = 7418, - [SMALL_STATE(293)] = 7429, - [SMALL_STATE(294)] = 7440, - [SMALL_STATE(295)] = 7451, - [SMALL_STATE(296)] = 7462, - [SMALL_STATE(297)] = 7471, - [SMALL_STATE(298)] = 7482, - [SMALL_STATE(299)] = 7493, - [SMALL_STATE(300)] = 7504, - [SMALL_STATE(301)] = 7515, - [SMALL_STATE(302)] = 7526, - [SMALL_STATE(303)] = 7537, - [SMALL_STATE(304)] = 7548, - [SMALL_STATE(305)] = 7559, - [SMALL_STATE(306)] = 7570, - [SMALL_STATE(307)] = 7581, - [SMALL_STATE(308)] = 7592, - [SMALL_STATE(309)] = 7603, - [SMALL_STATE(310)] = 7612, - [SMALL_STATE(311)] = 7623, - [SMALL_STATE(312)] = 7632, - [SMALL_STATE(313)] = 7643, - [SMALL_STATE(314)] = 7654, - [SMALL_STATE(315)] = 7665, - [SMALL_STATE(316)] = 7674, - [SMALL_STATE(317)] = 7683, - [SMALL_STATE(318)] = 7692, - [SMALL_STATE(319)] = 7703, - [SMALL_STATE(320)] = 7712, - [SMALL_STATE(321)] = 7723, - [SMALL_STATE(322)] = 7732, - [SMALL_STATE(323)] = 7743, - [SMALL_STATE(324)] = 7752, - [SMALL_STATE(325)] = 7761, - [SMALL_STATE(326)] = 7772, - [SMALL_STATE(327)] = 7783, - [SMALL_STATE(328)] = 7794, - [SMALL_STATE(329)] = 7805, - [SMALL_STATE(330)] = 7814, - [SMALL_STATE(331)] = 7825, - [SMALL_STATE(332)] = 7836, - [SMALL_STATE(333)] = 7845, - [SMALL_STATE(334)] = 7854, - [SMALL_STATE(335)] = 7863, - [SMALL_STATE(336)] = 7874, - [SMALL_STATE(337)] = 7885, - [SMALL_STATE(338)] = 7894, - [SMALL_STATE(339)] = 7905, - [SMALL_STATE(340)] = 7916, - [SMALL_STATE(341)] = 7925, - [SMALL_STATE(342)] = 7934, - [SMALL_STATE(343)] = 7943, - [SMALL_STATE(344)] = 7952, - [SMALL_STATE(345)] = 7963, - [SMALL_STATE(346)] = 7972, - [SMALL_STATE(347)] = 7983, - [SMALL_STATE(348)] = 7994, - [SMALL_STATE(349)] = 8005, - [SMALL_STATE(350)] = 8016, - [SMALL_STATE(351)] = 8025, - [SMALL_STATE(352)] = 8036, - [SMALL_STATE(353)] = 8047, - [SMALL_STATE(354)] = 8055, - [SMALL_STATE(355)] = 8063, - [SMALL_STATE(356)] = 8071, - [SMALL_STATE(357)] = 8079, - [SMALL_STATE(358)] = 8087, - [SMALL_STATE(359)] = 8095, - [SMALL_STATE(360)] = 8103, - [SMALL_STATE(361)] = 8111, - [SMALL_STATE(362)] = 8119, - [SMALL_STATE(363)] = 8127, - [SMALL_STATE(364)] = 8135, - [SMALL_STATE(365)] = 8143, - [SMALL_STATE(366)] = 8151, - [SMALL_STATE(367)] = 8159, - [SMALL_STATE(368)] = 8167, - [SMALL_STATE(369)] = 8175, - [SMALL_STATE(370)] = 8183, - [SMALL_STATE(371)] = 8191, - [SMALL_STATE(372)] = 8199, - [SMALL_STATE(373)] = 8207, - [SMALL_STATE(374)] = 8215, - [SMALL_STATE(375)] = 8223, - [SMALL_STATE(376)] = 8231, - [SMALL_STATE(377)] = 8239, - [SMALL_STATE(378)] = 8247, - [SMALL_STATE(379)] = 8255, - [SMALL_STATE(380)] = 8263, - [SMALL_STATE(381)] = 8271, - [SMALL_STATE(382)] = 8279, - [SMALL_STATE(383)] = 8287, - [SMALL_STATE(384)] = 8295, - [SMALL_STATE(385)] = 8303, - [SMALL_STATE(386)] = 8311, - [SMALL_STATE(387)] = 8319, - [SMALL_STATE(388)] = 8327, - [SMALL_STATE(389)] = 8335, - [SMALL_STATE(390)] = 8343, - [SMALL_STATE(391)] = 8351, - [SMALL_STATE(392)] = 8359, - [SMALL_STATE(393)] = 8367, - [SMALL_STATE(394)] = 8375, - [SMALL_STATE(395)] = 8383, - [SMALL_STATE(396)] = 8391, - [SMALL_STATE(397)] = 8399, - [SMALL_STATE(398)] = 8407, - [SMALL_STATE(399)] = 8415, - [SMALL_STATE(400)] = 8423, - [SMALL_STATE(401)] = 8431, - [SMALL_STATE(402)] = 8439, - [SMALL_STATE(403)] = 8447, - [SMALL_STATE(404)] = 8455, - [SMALL_STATE(405)] = 8463, - [SMALL_STATE(406)] = 8471, - [SMALL_STATE(407)] = 8479, - [SMALL_STATE(408)] = 8487, - [SMALL_STATE(409)] = 8495, - [SMALL_STATE(410)] = 8503, - [SMALL_STATE(411)] = 8511, - [SMALL_STATE(412)] = 8519, - [SMALL_STATE(413)] = 8527, - [SMALL_STATE(414)] = 8535, - [SMALL_STATE(415)] = 8543, - [SMALL_STATE(416)] = 8551, - [SMALL_STATE(417)] = 8559, - [SMALL_STATE(418)] = 8567, - [SMALL_STATE(419)] = 8575, - [SMALL_STATE(420)] = 8583, - [SMALL_STATE(421)] = 8591, - [SMALL_STATE(422)] = 8599, - [SMALL_STATE(423)] = 8607, - [SMALL_STATE(424)] = 8615, - [SMALL_STATE(425)] = 8623, - [SMALL_STATE(426)] = 8631, - [SMALL_STATE(427)] = 8639, - [SMALL_STATE(428)] = 8647, - [SMALL_STATE(429)] = 8655, - [SMALL_STATE(430)] = 8663, - [SMALL_STATE(431)] = 8671, - [SMALL_STATE(432)] = 8679, - [SMALL_STATE(433)] = 8687, - [SMALL_STATE(434)] = 8695, - [SMALL_STATE(435)] = 8703, - [SMALL_STATE(436)] = 8711, - [SMALL_STATE(437)] = 8719, - [SMALL_STATE(438)] = 8727, - [SMALL_STATE(439)] = 8735, - [SMALL_STATE(440)] = 8743, - [SMALL_STATE(441)] = 8751, - [SMALL_STATE(442)] = 8759, - [SMALL_STATE(443)] = 8767, - [SMALL_STATE(444)] = 8775, - [SMALL_STATE(445)] = 8783, - [SMALL_STATE(446)] = 8791, - [SMALL_STATE(447)] = 8799, - [SMALL_STATE(448)] = 8807, - [SMALL_STATE(449)] = 8815, - [SMALL_STATE(450)] = 8823, - [SMALL_STATE(451)] = 8831, - [SMALL_STATE(452)] = 8839, - [SMALL_STATE(453)] = 8847, + [SMALL_STATE(65)] = 2984, + [SMALL_STATE(66)] = 3006, + [SMALL_STATE(67)] = 3028, + [SMALL_STATE(68)] = 3050, + [SMALL_STATE(69)] = 3072, + [SMALL_STATE(70)] = 3094, + [SMALL_STATE(71)] = 3116, + [SMALL_STATE(72)] = 3138, + [SMALL_STATE(73)] = 3160, + [SMALL_STATE(74)] = 3182, + [SMALL_STATE(75)] = 3204, + [SMALL_STATE(76)] = 3226, + [SMALL_STATE(77)] = 3248, + [SMALL_STATE(78)] = 3270, + [SMALL_STATE(79)] = 3296, + [SMALL_STATE(80)] = 3318, + [SMALL_STATE(81)] = 3340, + [SMALL_STATE(82)] = 3362, + [SMALL_STATE(83)] = 3384, + [SMALL_STATE(84)] = 3406, + [SMALL_STATE(85)] = 3428, + [SMALL_STATE(86)] = 3450, + [SMALL_STATE(87)] = 3472, + [SMALL_STATE(88)] = 3494, + [SMALL_STATE(89)] = 3516, + [SMALL_STATE(90)] = 3538, + [SMALL_STATE(91)] = 3564, + [SMALL_STATE(92)] = 3586, + [SMALL_STATE(93)] = 3608, + [SMALL_STATE(94)] = 3630, + [SMALL_STATE(95)] = 3652, + [SMALL_STATE(96)] = 3674, + [SMALL_STATE(97)] = 3696, + [SMALL_STATE(98)] = 3718, + [SMALL_STATE(99)] = 3740, + [SMALL_STATE(100)] = 3762, + [SMALL_STATE(101)] = 3784, + [SMALL_STATE(102)] = 3806, + [SMALL_STATE(103)] = 3828, + [SMALL_STATE(104)] = 3850, + [SMALL_STATE(105)] = 3872, + [SMALL_STATE(106)] = 3894, + [SMALL_STATE(107)] = 3916, + [SMALL_STATE(108)] = 3938, + [SMALL_STATE(109)] = 3960, + [SMALL_STATE(110)] = 3982, + [SMALL_STATE(111)] = 4004, + [SMALL_STATE(112)] = 4026, + [SMALL_STATE(113)] = 4048, + [SMALL_STATE(114)] = 4070, + [SMALL_STATE(115)] = 4093, + [SMALL_STATE(116)] = 4116, + [SMALL_STATE(117)] = 4139, + [SMALL_STATE(118)] = 4162, + [SMALL_STATE(119)] = 4185, + [SMALL_STATE(120)] = 4208, + [SMALL_STATE(121)] = 4231, + [SMALL_STATE(122)] = 4254, + [SMALL_STATE(123)] = 4277, + [SMALL_STATE(124)] = 4300, + [SMALL_STATE(125)] = 4323, + [SMALL_STATE(126)] = 4346, + [SMALL_STATE(127)] = 4369, + [SMALL_STATE(128)] = 4392, + [SMALL_STATE(129)] = 4415, + [SMALL_STATE(130)] = 4438, + [SMALL_STATE(131)] = 4461, + [SMALL_STATE(132)] = 4497, + [SMALL_STATE(133)] = 4533, + [SMALL_STATE(134)] = 4569, + [SMALL_STATE(135)] = 4602, + [SMALL_STATE(136)] = 4635, + [SMALL_STATE(137)] = 4668, + [SMALL_STATE(138)] = 4702, + [SMALL_STATE(139)] = 4736, + [SMALL_STATE(140)] = 4757, + [SMALL_STATE(141)] = 4776, + [SMALL_STATE(142)] = 4809, + [SMALL_STATE(143)] = 4832, + [SMALL_STATE(144)] = 4857, + [SMALL_STATE(145)] = 4888, + [SMALL_STATE(146)] = 4919, + [SMALL_STATE(147)] = 4942, + [SMALL_STATE(148)] = 4973, + [SMALL_STATE(149)] = 5006, + [SMALL_STATE(150)] = 5025, + [SMALL_STATE(151)] = 5056, + [SMALL_STATE(152)] = 5089, + [SMALL_STATE(153)] = 5120, + [SMALL_STATE(154)] = 5139, + [SMALL_STATE(155)] = 5170, + [SMALL_STATE(156)] = 5201, + [SMALL_STATE(157)] = 5227, + [SMALL_STATE(158)] = 5253, + [SMALL_STATE(159)] = 5279, + [SMALL_STATE(160)] = 5307, + [SMALL_STATE(161)] = 5335, + [SMALL_STATE(162)] = 5357, + [SMALL_STATE(163)] = 5383, + [SMALL_STATE(164)] = 5400, + [SMALL_STATE(165)] = 5422, + [SMALL_STATE(166)] = 5444, + [SMALL_STATE(167)] = 5468, + [SMALL_STATE(168)] = 5492, + [SMALL_STATE(169)] = 5516, + [SMALL_STATE(170)] = 5540, + [SMALL_STATE(171)] = 5560, + [SMALL_STATE(172)] = 5584, + [SMALL_STATE(173)] = 5604, + [SMALL_STATE(174)] = 5628, + [SMALL_STATE(175)] = 5652, + [SMALL_STATE(176)] = 5671, + [SMALL_STATE(177)] = 5686, + [SMALL_STATE(178)] = 5705, + [SMALL_STATE(179)] = 5726, + [SMALL_STATE(180)] = 5741, + [SMALL_STATE(181)] = 5756, + [SMALL_STATE(182)] = 5771, + [SMALL_STATE(183)] = 5792, + [SMALL_STATE(184)] = 5807, + [SMALL_STATE(185)] = 5828, + [SMALL_STATE(186)] = 5842, + [SMALL_STATE(187)] = 5856, + [SMALL_STATE(188)] = 5870, + [SMALL_STATE(189)] = 5890, + [SMALL_STATE(190)] = 5906, + [SMALL_STATE(191)] = 5920, + [SMALL_STATE(192)] = 5940, + [SMALL_STATE(193)] = 5954, + [SMALL_STATE(194)] = 5974, + [SMALL_STATE(195)] = 5988, + [SMALL_STATE(196)] = 6002, + [SMALL_STATE(197)] = 6020, + [SMALL_STATE(198)] = 6034, + [SMALL_STATE(199)] = 6048, + [SMALL_STATE(200)] = 6064, + [SMALL_STATE(201)] = 6079, + [SMALL_STATE(202)] = 6096, + [SMALL_STATE(203)] = 6111, + [SMALL_STATE(204)] = 6126, + [SMALL_STATE(205)] = 6141, + [SMALL_STATE(206)] = 6156, + [SMALL_STATE(207)] = 6171, + [SMALL_STATE(208)] = 6186, + [SMALL_STATE(209)] = 6201, + [SMALL_STATE(210)] = 6214, + [SMALL_STATE(211)] = 6229, + [SMALL_STATE(212)] = 6244, + [SMALL_STATE(213)] = 6259, + [SMALL_STATE(214)] = 6272, + [SMALL_STATE(215)] = 6287, + [SMALL_STATE(216)] = 6302, + [SMALL_STATE(217)] = 6315, + [SMALL_STATE(218)] = 6328, + [SMALL_STATE(219)] = 6343, + [SMALL_STATE(220)] = 6358, + [SMALL_STATE(221)] = 6373, + [SMALL_STATE(222)] = 6388, + [SMALL_STATE(223)] = 6403, + [SMALL_STATE(224)] = 6418, + [SMALL_STATE(225)] = 6435, + [SMALL_STATE(226)] = 6450, + [SMALL_STATE(227)] = 6467, + [SMALL_STATE(228)] = 6484, + [SMALL_STATE(229)] = 6494, + [SMALL_STATE(230)] = 6508, + [SMALL_STATE(231)] = 6522, + [SMALL_STATE(232)] = 6532, + [SMALL_STATE(233)] = 6546, + [SMALL_STATE(234)] = 6560, + [SMALL_STATE(235)] = 6574, + [SMALL_STATE(236)] = 6588, + [SMALL_STATE(237)] = 6602, + [SMALL_STATE(238)] = 6616, + [SMALL_STATE(239)] = 6630, + [SMALL_STATE(240)] = 6644, + [SMALL_STATE(241)] = 6658, + [SMALL_STATE(242)] = 6672, + [SMALL_STATE(243)] = 6686, + [SMALL_STATE(244)] = 6700, + [SMALL_STATE(245)] = 6714, + [SMALL_STATE(246)] = 6728, + [SMALL_STATE(247)] = 6740, + [SMALL_STATE(248)] = 6754, + [SMALL_STATE(249)] = 6768, + [SMALL_STATE(250)] = 6780, + [SMALL_STATE(251)] = 6794, + [SMALL_STATE(252)] = 6808, + [SMALL_STATE(253)] = 6822, + [SMALL_STATE(254)] = 6832, + [SMALL_STATE(255)] = 6846, + [SMALL_STATE(256)] = 6860, + [SMALL_STATE(257)] = 6870, + [SMALL_STATE(258)] = 6884, + [SMALL_STATE(259)] = 6898, + [SMALL_STATE(260)] = 6912, + [SMALL_STATE(261)] = 6926, + [SMALL_STATE(262)] = 6940, + [SMALL_STATE(263)] = 6954, + [SMALL_STATE(264)] = 6968, + [SMALL_STATE(265)] = 6982, + [SMALL_STATE(266)] = 6996, + [SMALL_STATE(267)] = 7010, + [SMALL_STATE(268)] = 7020, + [SMALL_STATE(269)] = 7034, + [SMALL_STATE(270)] = 7048, + [SMALL_STATE(271)] = 7062, + [SMALL_STATE(272)] = 7076, + [SMALL_STATE(273)] = 7086, + [SMALL_STATE(274)] = 7100, + [SMALL_STATE(275)] = 7114, + [SMALL_STATE(276)] = 7128, + [SMALL_STATE(277)] = 7142, + [SMALL_STATE(278)] = 7156, + [SMALL_STATE(279)] = 7170, + [SMALL_STATE(280)] = 7184, + [SMALL_STATE(281)] = 7198, + [SMALL_STATE(282)] = 7212, + [SMALL_STATE(283)] = 7226, + [SMALL_STATE(284)] = 7240, + [SMALL_STATE(285)] = 7251, + [SMALL_STATE(286)] = 7260, + [SMALL_STATE(287)] = 7269, + [SMALL_STATE(288)] = 7280, + [SMALL_STATE(289)] = 7291, + [SMALL_STATE(290)] = 7302, + [SMALL_STATE(291)] = 7313, + [SMALL_STATE(292)] = 7322, + [SMALL_STATE(293)] = 7333, + [SMALL_STATE(294)] = 7344, + [SMALL_STATE(295)] = 7355, + [SMALL_STATE(296)] = 7366, + [SMALL_STATE(297)] = 7375, + [SMALL_STATE(298)] = 7386, + [SMALL_STATE(299)] = 7397, + [SMALL_STATE(300)] = 7408, + [SMALL_STATE(301)] = 7419, + [SMALL_STATE(302)] = 7430, + [SMALL_STATE(303)] = 7441, + [SMALL_STATE(304)] = 7452, + [SMALL_STATE(305)] = 7463, + [SMALL_STATE(306)] = 7474, + [SMALL_STATE(307)] = 7485, + [SMALL_STATE(308)] = 7496, + [SMALL_STATE(309)] = 7507, + [SMALL_STATE(310)] = 7516, + [SMALL_STATE(311)] = 7527, + [SMALL_STATE(312)] = 7536, + [SMALL_STATE(313)] = 7547, + [SMALL_STATE(314)] = 7558, + [SMALL_STATE(315)] = 7569, + [SMALL_STATE(316)] = 7578, + [SMALL_STATE(317)] = 7587, + [SMALL_STATE(318)] = 7596, + [SMALL_STATE(319)] = 7607, + [SMALL_STATE(320)] = 7616, + [SMALL_STATE(321)] = 7627, + [SMALL_STATE(322)] = 7636, + [SMALL_STATE(323)] = 7647, + [SMALL_STATE(324)] = 7656, + [SMALL_STATE(325)] = 7665, + [SMALL_STATE(326)] = 7676, + [SMALL_STATE(327)] = 7687, + [SMALL_STATE(328)] = 7698, + [SMALL_STATE(329)] = 7709, + [SMALL_STATE(330)] = 7718, + [SMALL_STATE(331)] = 7729, + [SMALL_STATE(332)] = 7740, + [SMALL_STATE(333)] = 7749, + [SMALL_STATE(334)] = 7758, + [SMALL_STATE(335)] = 7767, + [SMALL_STATE(336)] = 7778, + [SMALL_STATE(337)] = 7789, + [SMALL_STATE(338)] = 7798, + [SMALL_STATE(339)] = 7809, + [SMALL_STATE(340)] = 7820, + [SMALL_STATE(341)] = 7829, + [SMALL_STATE(342)] = 7838, + [SMALL_STATE(343)] = 7847, + [SMALL_STATE(344)] = 7856, + [SMALL_STATE(345)] = 7867, + [SMALL_STATE(346)] = 7876, + [SMALL_STATE(347)] = 7887, + [SMALL_STATE(348)] = 7898, + [SMALL_STATE(349)] = 7909, + [SMALL_STATE(350)] = 7920, + [SMALL_STATE(351)] = 7929, + [SMALL_STATE(352)] = 7940, + [SMALL_STATE(353)] = 7951, + [SMALL_STATE(354)] = 7959, + [SMALL_STATE(355)] = 7967, + [SMALL_STATE(356)] = 7975, + [SMALL_STATE(357)] = 7983, + [SMALL_STATE(358)] = 7991, + [SMALL_STATE(359)] = 7999, + [SMALL_STATE(360)] = 8007, + [SMALL_STATE(361)] = 8015, + [SMALL_STATE(362)] = 8023, + [SMALL_STATE(363)] = 8031, + [SMALL_STATE(364)] = 8039, + [SMALL_STATE(365)] = 8047, + [SMALL_STATE(366)] = 8055, + [SMALL_STATE(367)] = 8063, + [SMALL_STATE(368)] = 8071, + [SMALL_STATE(369)] = 8079, + [SMALL_STATE(370)] = 8087, + [SMALL_STATE(371)] = 8095, + [SMALL_STATE(372)] = 8103, + [SMALL_STATE(373)] = 8111, + [SMALL_STATE(374)] = 8119, + [SMALL_STATE(375)] = 8127, + [SMALL_STATE(376)] = 8135, + [SMALL_STATE(377)] = 8143, + [SMALL_STATE(378)] = 8151, + [SMALL_STATE(379)] = 8159, + [SMALL_STATE(380)] = 8167, + [SMALL_STATE(381)] = 8175, + [SMALL_STATE(382)] = 8183, + [SMALL_STATE(383)] = 8191, + [SMALL_STATE(384)] = 8199, + [SMALL_STATE(385)] = 8207, + [SMALL_STATE(386)] = 8215, + [SMALL_STATE(387)] = 8223, + [SMALL_STATE(388)] = 8231, + [SMALL_STATE(389)] = 8239, + [SMALL_STATE(390)] = 8247, + [SMALL_STATE(391)] = 8255, + [SMALL_STATE(392)] = 8263, + [SMALL_STATE(393)] = 8271, + [SMALL_STATE(394)] = 8279, + [SMALL_STATE(395)] = 8287, + [SMALL_STATE(396)] = 8295, + [SMALL_STATE(397)] = 8303, + [SMALL_STATE(398)] = 8311, + [SMALL_STATE(399)] = 8319, + [SMALL_STATE(400)] = 8327, + [SMALL_STATE(401)] = 8335, + [SMALL_STATE(402)] = 8343, + [SMALL_STATE(403)] = 8351, + [SMALL_STATE(404)] = 8359, + [SMALL_STATE(405)] = 8367, + [SMALL_STATE(406)] = 8375, + [SMALL_STATE(407)] = 8383, + [SMALL_STATE(408)] = 8391, + [SMALL_STATE(409)] = 8399, + [SMALL_STATE(410)] = 8407, + [SMALL_STATE(411)] = 8415, + [SMALL_STATE(412)] = 8423, + [SMALL_STATE(413)] = 8431, + [SMALL_STATE(414)] = 8439, + [SMALL_STATE(415)] = 8447, + [SMALL_STATE(416)] = 8455, + [SMALL_STATE(417)] = 8463, + [SMALL_STATE(418)] = 8471, + [SMALL_STATE(419)] = 8479, + [SMALL_STATE(420)] = 8487, + [SMALL_STATE(421)] = 8495, + [SMALL_STATE(422)] = 8503, + [SMALL_STATE(423)] = 8511, + [SMALL_STATE(424)] = 8519, + [SMALL_STATE(425)] = 8527, + [SMALL_STATE(426)] = 8535, + [SMALL_STATE(427)] = 8543, + [SMALL_STATE(428)] = 8551, + [SMALL_STATE(429)] = 8559, + [SMALL_STATE(430)] = 8567, + [SMALL_STATE(431)] = 8575, + [SMALL_STATE(432)] = 8583, + [SMALL_STATE(433)] = 8591, + [SMALL_STATE(434)] = 8599, + [SMALL_STATE(435)] = 8607, + [SMALL_STATE(436)] = 8615, + [SMALL_STATE(437)] = 8623, + [SMALL_STATE(438)] = 8631, + [SMALL_STATE(439)] = 8639, + [SMALL_STATE(440)] = 8647, + [SMALL_STATE(441)] = 8655, + [SMALL_STATE(442)] = 8663, + [SMALL_STATE(443)] = 8671, + [SMALL_STATE(444)] = 8679, + [SMALL_STATE(445)] = 8687, + [SMALL_STATE(446)] = 8695, + [SMALL_STATE(447)] = 8703, + [SMALL_STATE(448)] = 8711, + [SMALL_STATE(449)] = 8719, + [SMALL_STATE(450)] = 8727, + [SMALL_STATE(451)] = 8735, + [SMALL_STATE(452)] = 8743, + [SMALL_STATE(453)] = 8751, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -11266,7 +11215,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(395), - [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(397), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(397), [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431), [35] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2, 0, 0), @@ -11297,7 +11246,7 @@ static const TSParseActionEntry ts_parse_actions[] = { [94] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(375), [97] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(392), [100] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(395), - [103] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(397), + [103] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(397), [106] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(413), [109] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(431), [112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), @@ -11377,541 +11326,493 @@ static const TSParseActionEntry ts_parse_actions[] = { [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(307), [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(63), [274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1, 0, 0), - [276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_declaration, 1, 0, 0), - [278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_relationship_body, 3, 0, 0), - [280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_relationship_body, 3, 0, 0), - [282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_body, 3, 0, 0), - [284] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_species_body, 3, 0, 0), - [286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 5, 0, 1), - [288] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 5, 0, 1), - [290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_concept_comparison, 5, 0, 1), - [292] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_concept_comparison, 5, 0, 1), - [294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 3, 0, 0), - [296] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_use_declaration, 3, 0, 0), - [298] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_body, 2, 0, 0), - [300] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_character_body, 2, 0, 0), - [302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_declaration, 3, 0, 2), - [304] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_character_declaration, 3, 0, 2), - [306] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_declaration, 4, 0, 3), - [308] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_character_declaration, 4, 0, 3), - [310] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_body, 2, 0, 0), - [312] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_template_body, 2, 0, 0), - [314] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_declaration, 6, 0, 10), - [316] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_character_declaration, 6, 0, 10), - [318] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_declaration, 6, 0, 11), - [320] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_template_declaration, 6, 0, 11), - [322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 6, 0, 1), - [324] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_life_arc_declaration, 6, 0, 1), - [326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 6, 0, 7), - [328] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_life_arc_declaration, 6, 0, 7), - [330] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 1, 0, 0), - [332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 1, 0, 0), - [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_declaration, 4, 0, 4), - [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_template_declaration, 4, 0, 4), - [340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_body, 2, 0, 0), - [342] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_schedule_body, 2, 0, 0), - [344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 4, 0, 1), - [346] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_life_arc_declaration, 4, 0, 1), - [348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_behavior_body, 4, 0, 12), - [350] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_behavior_body, 4, 0, 12), - [352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_relationship_body, 4, 0, 0), - [354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_relationship_body, 4, 0, 0), - [356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_body, 4, 0, 0), - [358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_species_body, 4, 0, 0), - [360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 6, 0, 1), - [362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 6, 0, 1), - [364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_concept_comparison, 6, 0, 1), - [366] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_concept_comparison, 6, 0, 1), - [368] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 7, 0, 0), - [370] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_use_declaration, 7, 0, 0), - [372] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_declaration, 3, 0, 2), - [374] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_species_declaration, 3, 0, 2), - [376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_declaration, 3, 0, 2), - [378] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_template_declaration, 3, 0, 2), - [380] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_condition_node, 4, 0, 15), - [382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_condition_node, 4, 0, 15), - [386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_body, 2, 0, 0), - [388] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_species_body, 2, 0, 0), - [390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 5, 0, 0), - [392] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_use_declaration, 5, 0, 0), - [394] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 7, 0, 1), - [396] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_declaration, 7, 0, 1), - [398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept, 7, 0, 18), - [400] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sub_concept, 7, 0, 18), - [402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_concept_comparison, 7, 0, 1), - [404] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_concept_comparison, 7, 0, 1), - [406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 8, 0, 0), - [408] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_use_declaration, 8, 0, 0), - [410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_declaration, 3, 0, 2), - [412] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_schedule_declaration, 3, 0, 2), - [414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_body, 3, 0, 0), - [416] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_character_body, 3, 0, 0), - [418] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_declaration, 5, 0, 5), - [420] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_character_declaration, 5, 0, 5), - [422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_body, 3, 0, 0), - [424] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_template_body, 3, 0, 0), - [426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_declaration, 5, 0, 5), - [428] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_template_declaration, 5, 0, 5), - [430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_body, 3, 0, 0), - [432] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_schedule_body, 3, 0, 0), - [434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 9, 0, 0), - [436] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_use_declaration, 9, 0, 0), - [438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_declaration, 5, 0, 6), - [440] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_schedule_declaration, 5, 0, 6), - [442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 5, 0, 1), - [444] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_life_arc_declaration, 5, 0, 1), - [446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 5, 0, 7), - [448] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_life_arc_declaration, 5, 0, 7), - [450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_concept_declaration, 2, 0, 1), - [452] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_concept_declaration, 2, 0, 1), - [454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_behavior_declaration, 3, 0, 2), - [456] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_behavior_declaration, 3, 0, 2), - [458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_institution_declaration, 3, 0, 2), - [460] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_institution_declaration, 3, 0, 2), - [462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_relationship_declaration, 3, 0, 2), - [464] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_relationship_declaration, 3, 0, 2), - [466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_location_declaration, 3, 0, 2), - [468] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_location_declaration, 3, 0, 2), - [470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_behavior_body, 3, 0, 8), - [472] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_behavior_body, 3, 0, 8), - [474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 7, 0, 7), - [476] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_life_arc_declaration, 7, 0, 7), - [478] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decorator_node, 4, 0, 17), - [480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_node, 4, 0, 17), - [482] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_node, 4, 0, 16), - [484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_node, 4, 0, 16), - [486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_selector_node, 4, 0, 0), - [488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_selector_node, 4, 0, 0), - [490] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sequence_node, 4, 0, 0), - [492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sequence_node, 4, 0, 0), - [494] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 4, 0, 0), - [496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 4, 0, 0), - [498] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 3, 0, 0), - [500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 3, 0, 0), - [502] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_selector_node, 5, 0, 21), - [504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_selector_node, 5, 0, 21), - [506] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sequence_node, 5, 0, 21), - [508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sequence_node, 5, 0, 21), - [510] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decorator_node, 5, 0, 23), - [512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_node, 5, 0, 23), - [514] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 5, 0, 0), - [516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 5, 0, 0), - [518] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_subtree_node, 2, 0, 0), - [520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_subtree_node, 2, 0, 0), - [522] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_decorator_node, 7, 0, 29), - [524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_decorator_node, 7, 0, 29), - [526] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 6, 0, 0), - [528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 6, 0, 0), - [530] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_behavior_node, 1, 0, 0), - [532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_behavior_node, 1, 0, 0), - [534] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_node, 7, 0, 30), - [536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_node, 7, 0, 30), - [538] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_node, 9, 0, 32), - [540] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_node, 9, 0, 32), - [542] = {.entry = {.count = 1, .reusable = false}}, SHIFT(269), - [544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [546] = {.entry = {.count = 1, .reusable = false}}, SHIFT(419), - [548] = {.entry = {.count = 1, .reusable = false}}, SHIFT(420), - [550] = {.entry = {.count = 1, .reusable = false}}, SHIFT(422), - [552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [554] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(269), - [557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), - [559] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(359), - [562] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(419), - [565] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(420), - [568] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(422), - [571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [573] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), - [575] = {.entry = {.count = 1, .reusable = false}}, SHIFT(398), - [577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [579] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), SHIFT_REPEAT(269), - [582] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), - [584] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), SHIFT_REPEAT(273), - [587] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), SHIFT_REPEAT(398), - [590] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), SHIFT_REPEAT(359), - [593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), - [597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350), - [599] = {.entry = {.count = 1, .reusable = false}}, SHIFT(56), - [601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), - [603] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison, 3, 0, 22), - [605] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison, 3, 0, 22), - [607] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_access, 3, 0, 0), - [609] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_access, 3, 0, 0), - [611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [613] = {.entry = {.count = 1, .reusable = false}}, SHIFT(386), - [615] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), - [617] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_not_expression, 2, 0, 0), - [619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [621] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), - [623] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_or_expression, 3, 0, 0), - [625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), - [629] = {.entry = {.count = 1, .reusable = false}}, SHIFT(61), - [631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), - [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_and_expression, 3, 0, 0), - [635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), - [637] = {.entry = {.count = 1, .reusable = false}}, SHIFT(446), - [639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), - [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), - [645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), - [647] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), SHIFT_REPEAT(269), - [650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), - [652] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), SHIFT_REPEAT(386), - [655] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), SHIFT_REPEAT(191), - [658] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), SHIFT_REPEAT(359), - [661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [663] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), - [665] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), - [667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(401), - [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [673] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dotted_path, 1, 0, 0), - [675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(430), - [677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [679] = {.entry = {.count = 1, .reusable = false}}, SHIFT(393), - [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [685] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_use_declaration_repeat1, 2, 0, 0), - [687] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_use_declaration_repeat1, 2, 0, 0), - [689] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_use_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(441), - [692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [694] = {.entry = {.count = 1, .reusable = false}}, SHIFT(216), - [696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), - [698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), - [700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [702] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_relationship_body_repeat1, 2, 0, 0), SHIFT_REPEAT(6), - [705] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_relationship_body_repeat1, 2, 0, 0), - [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), - [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), - [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [717] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_behaviors, 5, 0, 0), - [719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), - [721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_behaviors, 5, 0, 0), - [723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [725] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_behaviors, 4, 0, 0), - [727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [729] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_behaviors, 4, 0, 0), - [731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), - [733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [735] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_species_body_repeat1, 2, 0, 0), - [737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_species_body_repeat1, 2, 0, 0), - [739] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_species_body_repeat1, 2, 0, 0), SHIFT_REPEAT(398), - [742] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_schedule_block, 6, 0, 20), - [744] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_block, 6, 0, 20), - [746] = {.entry = {.count = 1, .reusable = false}}, SHIFT(317), - [748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), - [750] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_species_body_repeat2, 2, 0, 0), SHIFT_REPEAT(393), - [753] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_species_body_repeat2, 2, 0, 0), - [755] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_species_body_repeat2, 2, 0, 0), SHIFT_REPEAT(359), - [758] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_override_block, 6, 0, 20), - [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_override_block, 6, 0, 20), - [762] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recurrence_block, 7, 0, 27), - [764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recurrence_block, 7, 0, 27), - [766] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_override_block, 5, 0, 20), - [768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_override_block, 5, 0, 20), - [770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), - [772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [774] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_schedule_block, 5, 0, 20), - [776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_block, 5, 0, 20), - [778] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_schedule, 6, 0, 0), - [780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_schedule, 6, 0, 0), - [782] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include, 2, 0, 0), - [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include, 2, 0, 0), - [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dotted_path, 1, 0, 0), - [788] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_uses_behaviors, 5, 0, 0), SHIFT(163), - [791] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_schedule, 4, 0, 0), - [793] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_schedule, 4, 0, 0), - [795] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_override_op, 1, 0, 0), - [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_override_op, 1, 0, 0), - [799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), - [801] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399), - [803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), - [805] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_override_op, 2, 0, 0), - [807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_override_op, 2, 0, 0), - [809] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_schedule, 7, 0, 0), - [811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_schedule, 7, 0, 0), - [813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), - [815] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_schedule, 8, 0, 0), - [817] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_schedule, 8, 0, 0), - [819] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_uses_behaviors, 6, 0, 0), SHIFT(163), - [822] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_behaviors, 6, 0, 0), - [824] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_behaviors, 6, 0, 0), - [826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(446), - [828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(424), - [830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), - [832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), - [834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), - [840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [842] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_life_arc_declaration_repeat1, 2, 0, 0), - [844] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_life_arc_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(446), - [847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), - [849] = {.entry = {.count = 1, .reusable = false}}, SHIFT(341), - [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [853] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_schedule_block_repeat1, 2, 0, 0), SHIFT_REPEAT(424), - [856] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_schedule_block_repeat1, 2, 0, 0), - [858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), - [860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(419), - [862] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_enter, 3, 0, 0), - [864] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_enter, 3, 0, 0), - [866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), - [868] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_is_condition, 1, 0, 0), - [870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(344), - [872] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_field, 3, 0, 9), - [874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_recurrence_block_repeat1, 2, 0, 0), - [876] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_recurrence_block_repeat1, 2, 0, 0), SHIFT_REPEAT(419), - [879] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_state_body_repeat1, 2, 0, 0), - [881] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_state_body_repeat1, 2, 0, 0), SHIFT_REPEAT(61), - [884] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_is_condition, 2, 0, 0), - [886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), - [888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(444), - [892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351), - [894] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_is_condition_repeat1, 2, 0, 0), - [896] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_is_condition_repeat1, 2, 0, 0), SHIFT_REPEAT(344), - [899] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), - [901] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_enum_body, 1, 0, 0), - [903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [905] = {.entry = {.count = 1, .reusable = false}}, SHIFT(412), - [907] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), - [909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), - [911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_record_body, 3, 0, 0), - [913] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_sub_concept_record_body_repeat1, 2, 0, 0), SHIFT_REPEAT(331), - [916] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_sub_concept_record_body_repeat1, 2, 0, 0), - [918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_participant, 2, 0, 0), - [920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(381), - [922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(333), - [924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), - [926] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_dotted_path_repeat1, 2, 0, 0), - [928] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dotted_path_repeat1, 2, 0, 0), SHIFT_REPEAT(430), - [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [933] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_clause, 2, 0, 0), - [935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), - [937] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2, 0, 0), SHIFT_REPEAT(52), - [940] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2, 0, 0), - [942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), - [946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), - [948] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_enum_body, 2, 0, 0), - [950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), - [954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396), - [956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), - [958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), - [960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429), - [964] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dotted_path, 2, 0, 0), - [966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(339), - [968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), - [970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_time_range, 3, 0, 25), - [972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), - [974] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_path_segments, 1, 0, 0), SHIFT(377), - [977] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_record_body, 2, 0, 0), - [979] = {.entry = {.count = 1, .reusable = true}}, SHIFT(400), - [981] = {.entry = {.count = 1, .reusable = true}}, SHIFT(450), - [983] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), - [985] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [987] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_requires_clause_repeat1, 2, 0, 0), SHIFT_REPEAT(312), - [990] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_requires_clause_repeat1, 2, 0, 0), - [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), - [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(357), - [996] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_participant, 4, 0, 0), - [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(345), - [1000] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(346), - [1003] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variant_pattern_repeat1, 2, 0, 0), - [1005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), - [1007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [1009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352), - [1011] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_clause, 3, 0, 0), - [1013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304), - [1015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [1017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), - [1019] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_path_segments, 2, 0, 0), SHIFT(377), - [1022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), - [1024] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_record_body, 1, 0, 0), - [1026] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_field, 1, 0, 0), - [1028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), - [1030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [1032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [1034] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_concept_comparison_repeat1, 2, 0, 0), SHIFT_REPEAT(298), - [1037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_concept_comparison_repeat1, 2, 0, 0), - [1039] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_is_value, 3, 0, 31), - [1041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), - [1043] = {.entry = {.count = 1, .reusable = false}}, SHIFT(367), - [1045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367), - [1047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), - [1049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), - [1051] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [1053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), - [1055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [1057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), - [1059] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338), - [1061] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), - [1063] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_action_node_repeat1, 2, 0, 0), SHIFT_REPEAT(35), - [1066] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_action_node_repeat1, 2, 0, 0), - [1068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), - [1070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), - [1072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371), - [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [1076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [1078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), - [1080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), - [1082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [1084] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_required_field, 3, 0, 14), - [1086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), - [1088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428), - [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(432), - [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), - [1096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [1098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(349), - [1100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_keyword, 1, 0, 0), - [1102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), - [1104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [1106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), - [1108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), - [1110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), - [1112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_clause, 4, 0, 0), - [1114] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), - [1116] = {.entry = {.count = 1, .reusable = false}}, SHIFT(376), - [1118] = {.entry = {.count = 1, .reusable = false}}, SHIFT(378), - [1120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), - [1122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(443), - [1124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(445), - [1126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_body, 3, 0, 0), - [1128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_block, 3, 0, 2), - [1130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_param, 3, 0, 0), - [1132] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_field, 3, 0, 9), - [1134] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_enum_body, 3, 0, 0), - [1136] = {.entry = {.count = 1, .reusable = false}}, SHIFT(325), - [1138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), - [1140] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant_pattern, 5, 0, 24), - [1142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), - [1144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), - [1146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_param, 1, 0, 0), - [1148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449), - [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), - [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), - [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(356), - [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [1158] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_body, 4, 0, 0), - [1160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [1162] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_condition, 3, 0, 26), - [1164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant_pattern, 6, 0, 24), - [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(394), - [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), - [1170] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_time_range, 4, 0, 25), - [1172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_field, 3, 0, 9), - [1174] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_transition, 4, 0, 28), - [1176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_body, 5, 0, 0), - [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), - [1180] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant_pattern, 7, 0, 24), - [1182] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322), - [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), - [1186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_body, 2, 0, 0), - [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), - [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), - [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [1196] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_requires_clause, 4, 0, 0), - [1198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), - [1200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), - [1202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [1204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(453), - [1206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), - [1208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), - [1210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), - [1212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [1214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(426), - [1216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), - [1218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), - [1220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [1222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [1224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [1226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), - [1228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), - [1230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301), - [1232] = {.entry = {.count = 1, .reusable = false}}, SHIFT(427), - [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [1236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [1238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), - [1240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [1242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), - [1244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), - [1246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), - [1248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), - [1250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), - [1252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [1254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(442), - [1256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [1258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_requires_clause, 5, 0, 0), - [1260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), - [1262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), - [1264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [1266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(447), - [1268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), - [1270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [1272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), - [1274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), - [1276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), - [1278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), - [1280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [1282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [1284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [1286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_params, 3, 0, 0), - [1288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [1290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), - [1292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [1294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_params, 5, 0, 0), - [1296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), - [1298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [1300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434), - [1302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), - [1304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(438), - [1306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(411), - [1308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [1310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), - [1312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), - [1314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), - [1316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(384), - [1318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [1320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), - [1322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), - [1324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [1326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [1328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [1330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), - [1332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [1334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), - [1336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), - [1338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), - [1340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [1342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), - [1344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), - [1346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [1348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [1350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335), - [1352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), - [1354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), - [1358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), - [1360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), - [1362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), - [1364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), - [1366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), - [1368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), - [1370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368), - [1372] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_requires_clause, 6, 0, 0), - [1374] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [1376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [276] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_relationship_body, 3, 0, 0), + [278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_body, 3, 0, 0), + [280] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 5, 0, 1), + [282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_definition, 5, 0, 1), + [284] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 3, 0, 0), + [286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_body, 2, 0, 0), + [288] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_declaration, 3, 0, 2), + [290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_declaration, 4, 0, 3), + [292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_body, 2, 0, 0), + [294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_declaration, 6, 0, 10), + [296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_declaration, 6, 0, 11), + [298] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 6, 0, 1), + [300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 6, 0, 7), + [302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 1, 0, 0), + [304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 1, 0, 0), + [306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_declaration, 4, 0, 4), + [310] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_body, 2, 0, 0), + [312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 4, 0, 1), + [314] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_behavior_body, 4, 0, 12), + [316] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_relationship_body, 4, 0, 0), + [318] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_body, 4, 0, 0), + [320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 6, 0, 1), + [322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_definition, 6, 0, 1), + [324] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 7, 0, 0), + [326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_declaration, 3, 0, 2), + [328] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_declaration, 3, 0, 2), + [330] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_condition_node, 4, 0, 15), + [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_condition_node, 4, 0, 15), + [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_body, 2, 0, 0), + [338] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 5, 0, 0), + [340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_declaration, 7, 0, 1), + [342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept, 7, 0, 18), + [344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_definition, 7, 0, 1), + [346] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 8, 0, 0), + [348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_declaration, 3, 0, 2), + [350] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_body, 3, 0, 0), + [352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_character_declaration, 5, 0, 5), + [354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_body, 3, 0, 0), + [356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_declaration, 5, 0, 5), + [358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_body, 3, 0, 0), + [360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_declaration, 9, 0, 0), + [362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_declaration, 5, 0, 6), + [364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 5, 0, 1), + [366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 5, 0, 7), + [368] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_concept_declaration, 2, 0, 1), + [370] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_behavior_declaration, 3, 0, 2), + [372] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_institution_declaration, 3, 0, 2), + [374] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_relationship_declaration, 3, 0, 2), + [376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_location_declaration, 3, 0, 2), + [378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_behavior_body, 3, 0, 8), + [380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_life_arc_declaration, 7, 0, 7), + [382] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decorator_node, 4, 0, 17), + [384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_node, 4, 0, 17), + [386] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_node, 4, 0, 16), + [388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_node, 4, 0, 16), + [390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_selector_node, 4, 0, 0), + [392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_selector_node, 4, 0, 0), + [394] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sequence_node, 4, 0, 0), + [396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sequence_node, 4, 0, 0), + [398] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 4, 0, 0), + [400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 4, 0, 0), + [402] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 3, 0, 0), + [404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 3, 0, 0), + [406] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_selector_node, 5, 0, 21), + [408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_selector_node, 5, 0, 21), + [410] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sequence_node, 5, 0, 21), + [412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sequence_node, 5, 0, 21), + [414] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decorator_node, 5, 0, 23), + [416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_node, 5, 0, 23), + [418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 5, 0, 0), + [420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 5, 0, 0), + [422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_subtree_node, 2, 0, 0), + [424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_subtree_node, 2, 0, 0), + [426] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_decorator_node, 7, 0, 29), + [428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_decorator_node, 7, 0, 29), + [430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_action_node, 6, 0, 0), + [432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_node, 6, 0, 0), + [434] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_behavior_node, 1, 0, 0), + [436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_behavior_node, 1, 0, 0), + [438] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_node, 7, 0, 30), + [440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_node, 7, 0, 30), + [442] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_node, 9, 0, 32), + [444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_node, 9, 0, 32), + [446] = {.entry = {.count = 1, .reusable = false}}, SHIFT(269), + [448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [450] = {.entry = {.count = 1, .reusable = false}}, SHIFT(419), + [452] = {.entry = {.count = 1, .reusable = false}}, SHIFT(420), + [454] = {.entry = {.count = 1, .reusable = false}}, SHIFT(422), + [456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [458] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(269), + [461] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), + [463] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(359), + [466] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(419), + [469] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(420), + [472] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_schedule_body_repeat1, 2, 0, 0), SHIFT_REPEAT(422), + [475] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [477] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), + [479] = {.entry = {.count = 1, .reusable = false}}, SHIFT(398), + [481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [483] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), SHIFT_REPEAT(269), + [486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), + [488] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), SHIFT_REPEAT(273), + [491] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), SHIFT_REPEAT(398), + [494] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_template_body_repeat1, 2, 0, 0), SHIFT_REPEAT(359), + [497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350), + [503] = {.entry = {.count = 1, .reusable = false}}, SHIFT(56), + [505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), + [507] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison, 3, 0, 22), + [509] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison, 3, 0, 22), + [511] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_access, 3, 0, 0), + [513] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_access, 3, 0, 0), + [515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [517] = {.entry = {.count = 1, .reusable = false}}, SHIFT(386), + [519] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), + [521] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_not_expression, 2, 0, 0), + [523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [525] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), + [527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_or_expression, 3, 0, 0), + [529] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), + [533] = {.entry = {.count = 1, .reusable = false}}, SHIFT(61), + [535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_and_expression, 3, 0, 0), + [539] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [541] = {.entry = {.count = 1, .reusable = false}}, SHIFT(446), + [543] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primary_expression, 1, 0, 0), + [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primary_expression, 1, 0, 0), + [549] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [551] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), SHIFT_REPEAT(269), + [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), + [556] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), SHIFT_REPEAT(386), + [559] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), SHIFT_REPEAT(191), + [562] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_override_repeat1, 2, 0, 0), SHIFT_REPEAT(359), + [565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [567] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), + [569] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), + [571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(401), + [575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [577] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dotted_path, 1, 0, 0), + [579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(430), + [581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [583] = {.entry = {.count = 1, .reusable = false}}, SHIFT(393), + [585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [589] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_use_declaration_repeat1, 2, 0, 0), + [591] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_use_declaration_repeat1, 2, 0, 0), + [593] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_use_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(441), + [596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [598] = {.entry = {.count = 1, .reusable = false}}, SHIFT(216), + [600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [606] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_relationship_body_repeat1, 2, 0, 0), SHIFT_REPEAT(6), + [609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_relationship_body_repeat1, 2, 0, 0), + [611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [613] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [617] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [621] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_behaviors, 5, 0, 0), + [623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), + [625] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_behaviors, 5, 0, 0), + [627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [629] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_behaviors, 4, 0, 0), + [631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_behaviors, 4, 0, 0), + [635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), + [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_species_body_repeat1, 2, 0, 0), + [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_species_body_repeat1, 2, 0, 0), + [643] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_species_body_repeat1, 2, 0, 0), SHIFT_REPEAT(398), + [646] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_schedule_block, 6, 0, 20), + [648] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_block, 6, 0, 20), + [650] = {.entry = {.count = 1, .reusable = false}}, SHIFT(317), + [652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), + [654] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_species_body_repeat2, 2, 0, 0), SHIFT_REPEAT(393), + [657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_species_body_repeat2, 2, 0, 0), + [659] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_species_body_repeat2, 2, 0, 0), SHIFT_REPEAT(359), + [662] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_override_block, 6, 0, 20), + [664] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_override_block, 6, 0, 20), + [666] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_recurrence_block, 7, 0, 27), + [668] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_recurrence_block, 7, 0, 27), + [670] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_override_block, 5, 0, 20), + [672] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_override_block, 5, 0, 20), + [674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), + [676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [678] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_schedule_block, 5, 0, 20), + [680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_schedule_block, 5, 0, 20), + [682] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_schedule, 6, 0, 0), + [684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_schedule, 6, 0, 0), + [686] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include, 2, 0, 0), + [688] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include, 2, 0, 0), + [690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dotted_path, 1, 0, 0), + [692] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_uses_behaviors, 5, 0, 0), SHIFT(163), + [695] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_schedule, 4, 0, 0), + [697] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_schedule, 4, 0, 0), + [699] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_override_op, 1, 0, 0), + [701] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_override_op, 1, 0, 0), + [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399), + [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), + [709] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_override_op, 2, 0, 0), + [711] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_override_op, 2, 0, 0), + [713] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_schedule, 7, 0, 0), + [715] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_schedule, 7, 0, 0), + [717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [719] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_schedule, 8, 0, 0), + [721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_schedule, 8, 0, 0), + [723] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_uses_behaviors, 6, 0, 0), SHIFT(163), + [726] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_uses_behaviors, 6, 0, 0), + [728] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_uses_behaviors, 6, 0, 0), + [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(446), + [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(424), + [734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), + [744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_life_arc_declaration_repeat1, 2, 0, 0), + [748] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_life_arc_declaration_repeat1, 2, 0, 0), SHIFT_REPEAT(446), + [751] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), + [753] = {.entry = {.count = 1, .reusable = false}}, SHIFT(341), + [755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [757] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_schedule_block_repeat1, 2, 0, 0), SHIFT_REPEAT(424), + [760] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_schedule_block_repeat1, 2, 0, 0), + [762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(419), + [766] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_enter, 3, 0, 0), + [768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_enter, 3, 0, 0), + [770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), + [772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_is_condition, 1, 0, 0), + [774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(344), + [776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_field, 3, 0, 9), + [778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_recurrence_block_repeat1, 2, 0, 0), + [780] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_recurrence_block_repeat1, 2, 0, 0), SHIFT_REPEAT(419), + [783] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_state_body_repeat1, 2, 0, 0), + [785] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_state_body_repeat1, 2, 0, 0), SHIFT_REPEAT(61), + [788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_is_condition, 2, 0, 0), + [790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(444), + [796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351), + [798] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_is_condition_repeat1, 2, 0, 0), + [800] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_is_condition_repeat1, 2, 0, 0), SHIFT_REPEAT(344), + [803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_enum_body, 1, 0, 0), + [807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [809] = {.entry = {.count = 1, .reusable = false}}, SHIFT(412), + [811] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), + [813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), + [815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_record_body, 3, 0, 0), + [817] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_sub_concept_record_body_repeat1, 2, 0, 0), SHIFT_REPEAT(331), + [820] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_sub_concept_record_body_repeat1, 2, 0, 0), + [822] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_participant, 2, 0, 0), + [824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(381), + [826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(333), + [828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [830] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_dotted_path_repeat1, 2, 0, 0), + [832] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dotted_path_repeat1, 2, 0, 0), SHIFT_REPEAT(430), + [835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_clause, 2, 0, 0), + [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [841] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2, 0, 0), SHIFT_REPEAT(52), + [844] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2, 0, 0), + [846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), + [852] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_enum_body, 2, 0, 0), + [854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), + [858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396), + [860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429), + [868] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dotted_path, 2, 0, 0), + [870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(339), + [872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_time_range, 3, 0, 25), + [876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), + [878] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_path_segments, 1, 0, 0), SHIFT(377), + [881] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_record_body, 2, 0, 0), + [883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(400), + [885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(450), + [887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [891] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_requires_clause_repeat1, 2, 0, 0), SHIFT_REPEAT(312), + [894] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_requires_clause_repeat1, 2, 0, 0), + [896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(357), + [900] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_participant, 4, 0, 0), + [902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(345), + [904] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variant_pattern_repeat1, 2, 0, 0), SHIFT_REPEAT(346), + [907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variant_pattern_repeat1, 2, 0, 0), + [909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), + [911] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352), + [915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_clause, 3, 0, 0), + [917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304), + [919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), + [923] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_path_segments, 2, 0, 0), SHIFT(377), + [926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [928] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_record_body, 1, 0, 0), + [930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_species_field, 1, 0, 0), + [932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), + [934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [938] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_definition_repeat1, 2, 0, 0), SHIFT_REPEAT(298), + [941] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_definition_repeat1, 2, 0, 0), + [943] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_is_value, 3, 0, 31), + [945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), + [947] = {.entry = {.count = 1, .reusable = false}}, SHIFT(367), + [949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367), + [951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [953] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [955] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), + [959] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [961] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), + [963] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338), + [965] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), + [967] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_action_node_repeat1, 2, 0, 0), SHIFT_REPEAT(35), + [970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_action_node_repeat1, 2, 0, 0), + [972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), + [976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371), + [978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), + [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [988] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_required_field, 3, 0, 14), + [990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428), + [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(432), + [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), + [1000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [1002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(349), + [1004] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_keyword, 1, 0, 0), + [1006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [1008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [1010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [1012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [1014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [1016] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_template_clause, 4, 0, 0), + [1018] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), + [1020] = {.entry = {.count = 1, .reusable = false}}, SHIFT(376), + [1022] = {.entry = {.count = 1, .reusable = false}}, SHIFT(378), + [1024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [1026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(443), + [1028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(445), + [1030] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_body, 3, 0, 0), + [1032] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_block, 3, 0, 2), + [1034] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_param, 3, 0, 0), + [1036] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_field, 3, 0, 9), + [1038] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_sub_concept_enum_body, 3, 0, 0), + [1040] = {.entry = {.count = 1, .reusable = false}}, SHIFT(325), + [1042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), + [1044] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant_pattern, 5, 0, 24), + [1046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), + [1048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), + [1050] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_action_param, 1, 0, 0), + [1052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449), + [1054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), + [1056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354), + [1058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(356), + [1060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [1062] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_body, 4, 0, 0), + [1064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [1066] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_condition, 3, 0, 26), + [1068] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant_pattern, 6, 0, 24), + [1070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(394), + [1072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), + [1074] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_time_range, 4, 0, 25), + [1076] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block_field, 3, 0, 9), + [1078] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_transition, 4, 0, 28), + [1080] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_body, 5, 0, 0), + [1082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), + [1084] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variant_pattern, 7, 0, 24), + [1086] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322), + [1088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [1090] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_state_body, 2, 0, 0), + [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), + [1096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [1098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [1100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_requires_clause, 4, 0, 0), + [1102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), + [1104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), + [1106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [1108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(453), + [1110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [1112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), + [1114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), + [1116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [1118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(426), + [1120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), + [1122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), + [1124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [1126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [1128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [1130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), + [1132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), + [1134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301), + [1136] = {.entry = {.count = 1, .reusable = false}}, SHIFT(427), + [1138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [1140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [1142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), + [1144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [1146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), + [1148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), + [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [1158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(442), + [1160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [1162] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_requires_clause, 5, 0, 0), + [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), + [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(447), + [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), + [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), + [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355), + [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342), + [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [1190] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_params, 3, 0, 0), + [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [1198] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decorator_params, 5, 0, 0), + [1200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [1202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [1204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434), + [1206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364), + [1208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(438), + [1210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(411), + [1212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [1214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), + [1216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [1218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), + [1220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(384), + [1222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [1224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), + [1226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), + [1228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [1230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [1232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [1236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [1238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), + [1240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), + [1242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), + [1244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [1246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [1248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [1250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [1252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [1254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335), + [1256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [1258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [1260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), + [1262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [1264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [1266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), + [1268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), + [1270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), + [1272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), + [1274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368), + [1276] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_requires_clause, 6, 0, 0), + [1278] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [1280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [1282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), }; #ifdef __cplusplus diff --git a/tree-sitter-storybook/test/corpus/type_system.txt b/tree-sitter-storybook/test/corpus/type_system.txt index f39fd7c..cccfb13 100644 --- a/tree-sitter-storybook/test/corpus/type_system.txt +++ b/tree-sitter-storybook/test/corpus/type_system.txt @@ -58,10 +58,10 @@ sub_concept BakedGood.Quality { value: (float)))))) ================== -Concept comparison +Definition ================== -concept_comparison SkillLevel { +definition SkillLevel { Apprentice: { freshness: any }, Master: { freshness: Tier is Master } } @@ -70,7 +70,7 @@ concept_comparison SkillLevel { (source_file (declaration - (concept_comparison + (definition name: (identifier) (variant_pattern name: (identifier) diff --git a/zed-storybook/languages/storybook/highlights.scm b/zed-storybook/languages/storybook/highlights.scm index cc23da7..b6d2d7a 100644 --- a/zed-storybook/languages/storybook/highlights.scm +++ b/zed-storybook/languages/storybook/highlights.scm @@ -20,7 +20,7 @@ "state" "concept" "sub_concept" - "concept_comparison" + "definition" ] @keyword.declaration ; Keywords - Control flow and modifiers @@ -83,7 +83,7 @@ (concept_declaration name: (identifier) @type.concept) (sub_concept parent: (identifier) @type.concept) (sub_concept name: (identifier) @type.sub_concept) -(concept_comparison name: (identifier) @type.concept_comparison) +(definition name: (identifier) @type.definition) (variant_pattern name: (identifier) @type.variant) (template_declaration species: (identifier) @type.builtin)