From bc2615a1edd4bd9e908d51f16fb8154d17e2acb3 Mon Sep 17 00:00:00 2001
From: Jeff <dev@jeffa.io>
Date: Wed, 29 Nov 2023 19:23:42 -0500
Subject: [PATCH] Begin changes for new type definitions

---
 grammar.js                                    |   407 +
 src/abstract_tree/assignment.rs               |    16 +-
 src/abstract_tree/block.rs                    |     8 +-
 src/abstract_tree/expression.rs               |    17 +-
 src/abstract_tree/filter.rs                   |    77 -
 src/abstract_tree/for.rs                      |    10 +-
 src/abstract_tree/function_call.rs            |    12 +-
 src/abstract_tree/identifier.rs               |    12 +-
 src/abstract_tree/if_else.rs                  |     8 +-
 src/abstract_tree/index.rs                    |     8 +-
 src/abstract_tree/index_assignment.rs         |     8 +-
 src/abstract_tree/logic.rs                    |     8 +-
 src/abstract_tree/match.rs                    |     8 +-
 src/abstract_tree/math.rs                     |     8 +-
 src/abstract_tree/mod.rs                      |    57 +-
 src/abstract_tree/statement.rs                |    51 +-
 src/abstract_tree/type.rs                     |   117 -
 src/abstract_tree/type_defintion.rs           |   170 +
 src/abstract_tree/use.rs                      |     8 +-
 src/abstract_tree/value_node.rs               |    31 +-
 src/abstract_tree/while.rs                    |     8 +-
 src/abstract_tree/yield.rs                    |     8 +-
 src/error.rs                                  |     4 +-
 src/{evaluator.rs => evaluate.rs}             |    33 +-
 src/lib.rs                                    |     4 +-
 src/main.rs                                   |    24 +-
 src/value/function.rs                         |    67 +-
 src/value/mod.rs                              |    49 +-
 tree-sitter-dust/.prettierignore              |     1 +
 tree-sitter-dust/.prettierrc                  |     5 +
 tree-sitter-dust/corpus/assignment.txt        |     3 +-
 tree-sitter-dust/corpus/async.txt             |     9 +-
 tree-sitter-dust/corpus/built_in_function.txt |    23 +-
 tree-sitter-dust/corpus/for.txt               |    14 +-
 tree-sitter-dust/corpus/functions.txt         |    35 +-
 tree-sitter-dust/corpus/tables.txt            |   105 -
 tree-sitter-dust/corpus/while.txt             |     9 +-
 tree-sitter-dust/corpus/yield.txt             |     3 +-
 tree-sitter-dust/grammar.js                   |   648 +-
 tree-sitter-dust/grammar.js.new               |   407 +
 tree-sitter-dust/package-lock.json            |    18 +-
 tree-sitter-dust/package.json                 |     1 +
 tree-sitter-dust/src/grammar.json             |   252 +-
 tree-sitter-dust/src/node-types.json          |   120 +-
 tree-sitter-dust/src/parser.c                 | 20659 ++++++++--------
 tree-sitter-dust/test_output.md               |    14 -
 46 files changed, 11666 insertions(+), 11898 deletions(-)
 create mode 100644 grammar.js
 delete mode 100644 src/abstract_tree/filter.rs
 delete mode 100644 src/abstract_tree/type.rs
 create mode 100644 src/abstract_tree/type_defintion.rs
 rename src/{evaluator.rs => evaluate.rs} (89%)
 create mode 100644 tree-sitter-dust/.prettierignore
 create mode 100644 tree-sitter-dust/.prettierrc
 delete mode 100644 tree-sitter-dust/corpus/tables.txt
 create mode 100644 tree-sitter-dust/grammar.js.new
 delete mode 100644 tree-sitter-dust/test_output.md

diff --git a/grammar.js b/grammar.js
new file mode 100644
index 0000000..3858355
--- /dev/null
+++ b/grammar.js
@@ -0,0 +1,407 @@
+module.exports = grammar({
+  name: "dust",
+
+  word: $ => $.identifier,
+
+  extras: $ => [/\s/, $._comment],
+
+  rules: {
+    root: $ =>
+      prec(1, repeat1($.statement)),
+
+    _comment: $ => /[#][^#\n]*[#|\n]/,
+
+    block: $ =>
+      seq(
+        optional("async"),
+        "{",
+        repeat1($.statement),
+        "}",
+      ),
+
+    statement: $ =>
+      prec.left(
+        seq(
+          choice(
+            $.assignment,
+            $.block,
+            $.expression,
+            $.for,
+            $.if_else,
+            $.index_assignment,
+            $.match,
+            $.return,
+            $.use,
+            $.while,
+          ),
+          optional(";"),
+        ),
+      ),
+
+    expression: $ =>
+      prec.right(
+        choice(
+          $._expression_kind,
+          seq(
+            "(",
+            $._expression_kind,
+            ")",
+          ),
+        ),
+      ),
+
+    _expression_kind: $ =>
+      prec.right(
+        choice(
+          $.function_call,
+          $.identifier,
+          $.index,
+          $.logic,
+          $.math,
+          $.value,
+          $.yield,
+        ),
+      ),
+
+    _expression_list: $ =>
+      repeat1(
+        prec.right(
+          seq(
+            $.expression,
+            optional(","),
+          ),
+        ),
+      ),
+
+    identifier: $ =>
+      /[_a-zA-Z]+[_a-zA-Z0-9]?/,
+
+    value: $ =>
+      choice(
+        $.integer,
+        $.float,
+        $.string,
+        $.boolean,
+        $.list,
+        $.function,
+        $.table,
+        $.map,
+      ),
+
+    integer: $ =>
+      token(
+        prec.left(
+          seq(
+            optional("-"),
+            repeat1(
+              choice(
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                "0",
+              ),
+            ),
+          ),
+        ),
+      ),
+
+    float: $ =>
+      token(
+        prec.left(
+          seq(
+            optional("-"),
+            repeat1(
+              choice(
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                "0",
+              ),
+            ),
+            ".",
+            repeat1(
+              choice(
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                "0",
+              ),
+            ),
+          ),
+        ),
+      ),
+
+    string: $ =>
+      /("[^"]*?")|('[^']*?')|(`[^`]*?`)/,
+
+    boolean: $ =>
+      choice("true", "false"),
+
+    list: $ =>
+      seq(
+        "[",
+        repeat(
+          prec.left(
+            seq(
+              $.expression,
+              optional(","),
+            ),
+          ),
+        ),
+        "]",
+      ),
+
+    map: $ =>
+      seq(
+        "{",
+        repeat(
+          seq(
+            $.identifier,
+            "=",
+            $.statement,
+            optional(","),
+          ),
+        ),
+        "}",
+      ),
+
+    index: $ =>
+      prec.left(
+        1,
+        seq(
+          $.expression,
+          ":",
+          $.expression,
+          optional(
+            seq("..", $.expression),
+          ),
+        ),
+      ),
+
+    math: $ =>
+      prec.left(
+        seq(
+          $.expression,
+          $.math_operator,
+          $.expression,
+        ),
+      ),
+
+    math_operator: $ =>
+      choice("+", "-", "*", "/", "%"),
+
+    logic: $ =>
+      prec.right(
+        seq(
+          $.expression,
+          $.logic_operator,
+          $.expression,
+        ),
+      ),
+
+    logic_operator: $ =>
+      choice(
+        "==",
+        "!=",
+        "&&",
+        "||",
+        ">",
+        "<",
+        ">=",
+        "<=",
+      ),
+
+    assignment: $ =>
+      seq(
+        field(
+          "identifier",
+          $.identifier,
+        ),
+        optional(
+          field(
+            "type",
+            $.type_definition,
+          ),
+        ),
+        field(
+          "assignment_operator",
+          $.assignment_operator,
+        ),
+        field("statement", $.statement),
+      ),
+
+    index_assignment: $ =>
+      seq(
+        $.index,
+        $.assignment_operator,
+        $.statement,
+      ),
+
+    assignment_operator: $ =>
+      prec.right(
+        choice("=", "+=", "-="),
+      ),
+
+    if_else: $ =>
+      prec.right(
+        seq(
+          $.if,
+          repeat($.else_if),
+          optional($.else),
+        ),
+      ),
+
+    if: $ =>
+      seq("if", $.expression, $.block),
+
+    else_if: $ =>
+      seq(
+        "else if",
+        $.expression,
+        $.block,
+      ),
+
+    else: $ => seq("else", $.block),
+
+    match: $ =>
+      prec.right(
+        seq(
+          "match",
+          $.expression,
+          repeat1(
+            seq(
+              $.expression,
+              "=>",
+              $.block,
+            ),
+          ),
+        ),
+      ),
+
+    while: $ =>
+      seq(
+        "while",
+        $.expression,
+        $.block,
+      ),
+
+    for: $ =>
+      seq(
+        choice("for", "async for"),
+        $.identifier,
+        "in",
+        $.expression,
+        $.block,
+      ),
+
+    identifier_list: $ =>
+      prec.right(
+        choice(
+          seq(
+            "|",
+            repeat(
+              seq(
+                $.identifier,
+                optional(","),
+              ),
+            ),
+            "|",
+          ),
+        ),
+      ),
+
+    table: $ =>
+      prec.right(
+        seq(
+          "table",
+          $.identifier_list,
+          $.expression,
+        ),
+      ),
+
+    return: $ =>
+      seq("return", $.expression),
+
+    use: $ => seq("use", $.string),
+
+    type_definition: $ =>
+      seq("<", $.type, ">"),
+
+    type: $ =>
+      prec.right(
+        choice(
+          "any",
+          "bool",
+          seq(
+            "fn",
+            repeat(
+              seq(
+                $.type,
+                optional(","),
+              ),
+            ),
+            optional(seq("->", $.type)),
+          ),
+          "int",
+          seq("list", $.type),
+          "map",
+          "num",
+          "str",
+        ),
+      ),
+
+    function: $ =>
+      seq(
+        "|",
+        repeat(
+          seq(
+            $.identifier,
+            optional(","),
+          ),
+        ),
+        "|",
+        $.block,
+      ),
+
+    function_call: $ =>
+      prec.right(
+        1,
+        seq(
+          "(",
+          $.expression,
+          optional($._expression_list),
+          ")",
+        ),
+      ),
+
+    yield: $ =>
+      prec.left(
+        seq(
+          $.expression,
+          "->",
+          "(",
+          $.expression,
+          optional($._expression_list),
+          ")",
+        ),
+      ),
+  },
+});
diff --git a/src/abstract_tree/assignment.rs b/src/abstract_tree/assignment.rs
index 4bd2699..fd3b676 100644
--- a/src/abstract_tree/assignment.rs
+++ b/src/abstract_tree/assignment.rs
@@ -1,12 +1,12 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Identifier, Map, Result, Statement, Type, Value};
+use crate::{AbstractTree, Error, Identifier, Map, Result, Statement, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Assignment {
     identifier: Identifier,
-    r#type: Option<Type>,
+    r#type: Option<TypeDefinition>,
     operator: AssignmentOperator,
     statement: Statement,
 }
@@ -27,7 +27,7 @@ impl AbstractTree for Assignment {
 
         let type_node = node.child_by_field_name("type");
         let r#type = if let Some(type_node) = type_node {
-            Some(Type::from_syntax_node(source, type_node)?)
+            Some(TypeDefinition::from_syntax_node(source, type_node)?)
         } else {
             None
         };
@@ -62,7 +62,7 @@ impl AbstractTree for Assignment {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let key = self.identifier.inner();
         let value = self.statement.run(source, context)?;
 
@@ -86,12 +86,12 @@ impl AbstractTree for Assignment {
             AssignmentOperator::Equal => value,
         };
 
-        if let Some(r#type) = &self.r#type {
-            r#type.check(&new_value)?;
-        }
-
         context.variables_mut()?.insert(key.clone(), new_value);
 
         Ok(Value::Empty)
     }
+
+    fn expected_type(&self, _context: &Map) -> Result<TypeDefinition> {
+        Ok(TypeDefinition::Empty)
+    }
 }
diff --git a/src/abstract_tree/block.rs b/src/abstract_tree/block.rs
index d050e05..65b17e5 100644
--- a/src/abstract_tree/block.rs
+++ b/src/abstract_tree/block.rs
@@ -4,7 +4,7 @@ use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Map, Result, Statement, Value};
+use crate::{AbstractTree, Error, Map, Result, Statement, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Block {
@@ -41,7 +41,7 @@ impl AbstractTree for Block {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         if self.is_async {
             let statements = &self.statements;
             let final_result = RwLock::new(Ok(Value::Empty));
@@ -81,4 +81,8 @@ impl AbstractTree for Block {
             prev_result.unwrap_or(Ok(Value::Empty))
         }
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        self.statements.last().unwrap().expected_type(context)
+    }
 }
diff --git a/src/abstract_tree/expression.rs b/src/abstract_tree/expression.rs
index 011fe32..ed635b8 100644
--- a/src/abstract_tree/expression.rs
+++ b/src/abstract_tree/expression.rs
@@ -2,7 +2,8 @@ use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
 use crate::{
-    value_node::ValueNode, AbstractTree, Error, Identifier, Index, Map, Result, Value, Yield,
+    value_node::ValueNode, AbstractTree, Error, Identifier, Index, Map, Result, TypeDefinition,
+    Value, Yield,
 };
 
 use super::{function_call::FunctionCall, logic::Logic, math::Math};
@@ -51,7 +52,7 @@ impl AbstractTree for Expression {
         Ok(expression)
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         match self {
             Expression::Value(value_node) => value_node.run(source, context),
             Expression::Identifier(identifier) => identifier.run(source, context),
@@ -62,4 +63,16 @@ impl AbstractTree for Expression {
             Expression::Yield(r#yield) => r#yield.run(source, context),
         }
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        match self {
+            Expression::Value(value_node) => value_node.expected_type(context),
+            Expression::Identifier(identifier) => identifier.expected_type(context),
+            Expression::Math(math) => math.expected_type(context),
+            Expression::Logic(logic) => logic.expected_type(context),
+            Expression::FunctionCall(function_call) => function_call.expected_type(context),
+            Expression::Index(index) => index.expected_type(context),
+            Expression::Yield(r#yield) => r#yield.expected_type(context),
+        }
+    }
 }
diff --git a/src/abstract_tree/filter.rs b/src/abstract_tree/filter.rs
deleted file mode 100644
index d34eb9d..0000000
--- a/src/abstract_tree/filter.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use rayon::prelude::*;
-use serde::{Deserialize, Serialize};
-use tree_sitter::Node;
-
-use crate::{AbstractTree, Block, Error, Expression, Identifier, List, Map, Result, Value};
-
-#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
-pub struct Filter {
-    count: Option<Expression>,
-    item_id: Identifier,
-    collection: Expression,
-    predicate: Block,
-}
-
-impl AbstractTree for Filter {
-    fn from_syntax_node(source: &str, node: Node) -> Result<Self> {
-        let count = match node.child_by_field_name("count") {
-            Some(node) => Some(Expression::from_syntax_node(source, node)?),
-            None => None,
-        };
-
-        let item_id_node = node.child_by_field_name("item_id").unwrap();
-        let item_id = Identifier::from_syntax_node(source, item_id_node)?;
-
-        let collection_node = node.child_by_field_name("collection").unwrap();
-        let collection = Expression::from_syntax_node(source, collection_node)?;
-
-        let predicate_node = node.child_by_field_name("predicate").unwrap();
-        let predicate = Block::from_syntax_node(source, predicate_node)?;
-
-        Ok(Filter {
-            count,
-            item_id,
-            collection,
-            predicate,
-        })
-    }
-
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
-        let value = self.collection.run(source, context)?;
-        let values = value.as_list()?.items();
-        let key = self.item_id.inner();
-        let new_values = List::new();
-        let count = match &self.count {
-            Some(expression) => Some(expression.run(source, context)?.as_integer()? as usize),
-            None => None,
-        };
-        let loop_context = Map::clone_from(context)?;
-
-        values.par_iter().try_for_each(|value| {
-            if let Some(max) = count {
-                if new_values.items().len() == max {
-                    return Ok(());
-                }
-            }
-
-            let mut iter_context = loop_context.clone();
-
-            iter_context
-                .variables_mut()?
-                .insert(key.clone(), value.clone());
-
-            let should_include = self
-                .predicate
-                .run(source, &mut iter_context)?
-                .as_boolean()?;
-
-            if should_include {
-                new_values.items_mut().push(value.clone());
-            }
-
-            Ok::<(), Error>(())
-        })?;
-
-        Ok(Value::List(new_values))
-    }
-}
diff --git a/src/abstract_tree/for.rs b/src/abstract_tree/for.rs
index 7ca36f6..e01e5eb 100644
--- a/src/abstract_tree/for.rs
+++ b/src/abstract_tree/for.rs
@@ -2,7 +2,9 @@ use rayon::prelude::*;
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Block, Error, Expression, Identifier, Map, Result, Value};
+use crate::{
+    AbstractTree, Block, Error, Expression, Identifier, Map, Result, TypeDefinition, Value,
+};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct For {
@@ -47,7 +49,7 @@ impl AbstractTree for For {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let expression_run = self.collection.run(source, context)?;
         let values = expression_run.as_list()?.items();
         let key = self.item_id.inner();
@@ -76,4 +78,8 @@ impl AbstractTree for For {
 
         Ok(Value::Empty)
     }
+
+    fn expected_type(&self, _context: &Map) -> Result<TypeDefinition> {
+        Ok(TypeDefinition::Empty)
+    }
 }
diff --git a/src/abstract_tree/function_call.rs b/src/abstract_tree/function_call.rs
index b5d7f02..5c83527 100644
--- a/src/abstract_tree/function_call.rs
+++ b/src/abstract_tree/function_call.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Map, Result, Value, BUILT_IN_FUNCTIONS};
+use crate::{AbstractTree, Error, Map, Result, TypeDefinition, Value, BUILT_IN_FUNCTIONS};
 
 use super::expression::Expression;
 
@@ -45,7 +45,7 @@ impl AbstractTree for FunctionCall {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let function = if let Expression::Identifier(identifier) = &self.function {
             let key = identifier.inner();
 
@@ -77,15 +77,17 @@ impl AbstractTree for FunctionCall {
         let mut function_context = Map::clone_from(context)?;
         let parameter_expression_pairs = function.parameters().iter().zip(self.arguments.iter());
 
-        for ((identifier, r#type), expression) in parameter_expression_pairs {
+        for (identifier, expression) in parameter_expression_pairs {
             let key = identifier.clone().take_inner();
             let value = expression.run(source, context)?;
 
-            r#type.check(&value)?;
-
             function_context.variables_mut()?.insert(key, value);
         }
 
         function.run(source, &mut function_context)
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        self.function.expected_type(context)
+    }
 }
diff --git a/src/abstract_tree/identifier.rs b/src/abstract_tree/identifier.rs
index 15689da..d4fc9ef 100644
--- a/src/abstract_tree/identifier.rs
+++ b/src/abstract_tree/identifier.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Map, Result, Value};
+use crate::{AbstractTree, Error, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Identifier(String);
@@ -29,11 +29,19 @@ impl AbstractTree for Identifier {
         Ok(Identifier(identifier.to_string()))
     }
 
-    fn run(&self, _source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, _source: &str, context: &Map) -> Result<Value> {
         if let Some(value) = context.variables()?.get(&self.0) {
             Ok(value.clone())
         } else {
             Err(Error::VariableIdentifierNotFound(self.inner().clone()))
         }
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        if let Some(value) = context.variables()?.get(&self.0) {
+            Ok(value.r#type(context)?)
+        } else {
+            Ok(TypeDefinition::Empty)
+        }
+    }
 }
diff --git a/src/abstract_tree/if_else.rs b/src/abstract_tree/if_else.rs
index 3e42770..1df79e2 100644
--- a/src/abstract_tree/if_else.rs
+++ b/src/abstract_tree/if_else.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Block, Expression, Map, Result, Value};
+use crate::{AbstractTree, Block, Expression, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct IfElse {
@@ -55,7 +55,7 @@ impl AbstractTree for IfElse {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let if_boolean = self.if_expression.run(source, context)?.as_boolean()?;
 
         if if_boolean {
@@ -80,4 +80,8 @@ impl AbstractTree for IfElse {
             }
         }
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        self.if_block.expected_type(context)
+    }
 }
diff --git a/src/abstract_tree/index.rs b/src/abstract_tree/index.rs
index 4de72ad..ac72c02 100644
--- a/src/abstract_tree/index.rs
+++ b/src/abstract_tree/index.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Expression, List, Map, Result, Value};
+use crate::{AbstractTree, Error, Expression, List, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Index {
@@ -32,7 +32,7 @@ impl AbstractTree for Index {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let collection = self.collection.run(source, context)?;
 
         match collection {
@@ -73,6 +73,10 @@ impl AbstractTree for Index {
             _ => Err(Error::ExpectedCollection { actual: collection }),
         }
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        self.collection.expected_type(context)
+    }
 }
 
 #[cfg(test)]
diff --git a/src/abstract_tree/index_assignment.rs b/src/abstract_tree/index_assignment.rs
index af71763..4d16c26 100644
--- a/src/abstract_tree/index_assignment.rs
+++ b/src/abstract_tree/index_assignment.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Index, Map, Result, Statement, Value};
+use crate::{AbstractTree, Error, Index, Map, Result, Statement, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct IndexAssignment {
@@ -49,7 +49,7 @@ impl AbstractTree for IndexAssignment {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let index_collection = self.index.collection.run(source, context)?;
         let index_context = index_collection.as_map().unwrap_or(&context);
         let index_key = if let crate::Expression::Identifier(identifier) = &self.index.index {
@@ -90,4 +90,8 @@ impl AbstractTree for IndexAssignment {
 
         Ok(Value::Empty)
     }
+
+    fn expected_type(&self, _context: &Map) -> Result<TypeDefinition> {
+        Ok(TypeDefinition::Empty)
+    }
 }
diff --git a/src/abstract_tree/logic.rs b/src/abstract_tree/logic.rs
index 2ee4d3a..aac26b8 100644
--- a/src/abstract_tree/logic.rs
+++ b/src/abstract_tree/logic.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Expression, Map, Result, Value};
+use crate::{AbstractTree, Error, Expression, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Logic {
@@ -45,7 +45,7 @@ impl AbstractTree for Logic {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let left = self.left.run(source, context)?;
         let right = self.right.run(source, context)?;
         let result = match self.operator {
@@ -73,6 +73,10 @@ impl AbstractTree for Logic {
 
         Ok(Value::Boolean(result))
     }
+
+    fn expected_type(&self, _context: &Map) -> Result<TypeDefinition> {
+        Ok(TypeDefinition::Boolean)
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
diff --git a/src/abstract_tree/match.rs b/src/abstract_tree/match.rs
index 5c95eef..2c668c4 100644
--- a/src/abstract_tree/match.rs
+++ b/src/abstract_tree/match.rs
@@ -6,7 +6,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Map, Result, Value};
+use crate::{AbstractTree, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Match {}
@@ -16,7 +16,11 @@ impl AbstractTree for Match {
         todo!()
     }
 
-    fn run(&self, _source: &str, _context: &mut Map) -> Result<Value> {
+    fn run(&self, _source: &str, _context: &Map) -> Result<Value> {
+        todo!()
+    }
+
+    fn expected_type(&self, _context: &Map) -> Result<TypeDefinition> {
         todo!()
     }
 }
diff --git a/src/abstract_tree/math.rs b/src/abstract_tree/math.rs
index cbb93b6..8b5472b 100644
--- a/src/abstract_tree/math.rs
+++ b/src/abstract_tree/math.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Error, Expression, Map, Result, Value};
+use crate::{AbstractTree, Error, Expression, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Math {
@@ -42,7 +42,7 @@ impl AbstractTree for Math {
         })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let left = self.left.run(source, context)?;
         let right = self.right.run(source, context)?;
         let value = match self.operator {
@@ -55,6 +55,10 @@ impl AbstractTree for Math {
 
         Ok(value)
     }
+
+    fn expected_type(&self, _context: &Map) -> Result<TypeDefinition> {
+        Ok(TypeDefinition::Number)
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
diff --git a/src/abstract_tree/mod.rs b/src/abstract_tree/mod.rs
index 79035ad..35136de 100644
--- a/src/abstract_tree/mod.rs
+++ b/src/abstract_tree/mod.rs
@@ -9,38 +9,67 @@
 pub mod assignment;
 pub mod block;
 pub mod expression;
-pub mod filter;
-pub mod find;
 pub mod r#for;
 pub mod function_call;
 pub mod identifier;
 pub mod if_else;
 pub mod index;
 pub mod index_assignment;
-pub mod insert;
 pub mod logic;
 pub mod r#match;
 pub mod math;
-pub mod remove;
-pub mod select;
 pub mod statement;
-pub mod transform;
-pub mod r#type;
+pub mod type_defintion;
 pub mod r#use;
 pub mod value_node;
 pub mod r#while;
 pub mod r#yield;
 
 pub use {
-    assignment::*, block::*, expression::*, filter::*, find::*, function_call::*, identifier::*,
-    if_else::*, index::*, index_assignment::IndexAssignment, insert::*, logic::*, math::*,
-    r#for::*, r#match::*, r#type::*, r#use::*, r#while::*, r#yield::*, remove::*, select::*,
-    statement::*, transform::*, value_node::*,
+    assignment::*, block::*, expression::*, function_call::*, identifier::*, if_else::*, index::*,
+    index_assignment::IndexAssignment, logic::*, math::*, r#for::*, r#match::*, r#use::*,
+    r#while::*, r#yield::*, statement::*, type_defintion::*, value_node::*,
 };
 
 use tree_sitter::Node;
 
-use crate::{Map, Result, Value};
+use crate::{Error, Map, Result, Value};
+
+pub struct Root {
+    statements: Vec<Statement>,
+}
+
+impl AbstractTree for Root {
+    fn from_syntax_node(source: &str, node: Node) -> Result<Self> {
+        Error::expect_syntax_node(source, "root", node)?;
+
+        let statement_count = node.child_count();
+        let mut statements = Vec::with_capacity(statement_count);
+
+        for index in 0..statement_count {
+            let statement_node = node.child(index).unwrap();
+            let statement = Statement::from_syntax_node(source, statement_node)?;
+
+            statements.push(statement);
+        }
+
+        Ok(Root { statements })
+    }
+
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
+        let mut value = Value::Empty;
+
+        for statement in &self.statements {
+            value = statement.run(source, context)?;
+        }
+
+        Ok(value)
+    }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        self.statements.last().unwrap().expected_type(context)
+    }
+}
 
 /// This trait is implemented by the Evaluator's internal types to form an
 /// executable tree that resolves to a single value.
@@ -57,5 +86,7 @@ pub trait AbstractTree: Sized {
     fn from_syntax_node(source: &str, node: Node) -> Result<Self>;
 
     /// Execute dust code by traversing the tree.
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value>;
+    fn run(&self, source: &str, context: &Map) -> Result<Value>;
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition>;
 }
diff --git a/src/abstract_tree/statement.rs b/src/abstract_tree/statement.rs
index 4ed98c5..8c51d1b 100644
--- a/src/abstract_tree/statement.rs
+++ b/src/abstract_tree/statement.rs
@@ -2,8 +2,8 @@ use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
 use crate::{
-    AbstractTree, Assignment, Block, Error, Expression, Filter, Find, For, IfElse, IndexAssignment,
-    Insert, Map, Match, Remove, Result, Select, Transform, Use, Value, While,
+    AbstractTree, Assignment, Block, Error, Expression, For, IfElse, IndexAssignment, Map, Match,
+    Result, TypeDefinition, Use, Value, While,
 };
 
 /// Abstract representation of a statement.
@@ -17,13 +17,7 @@ pub enum Statement {
     While(Box<While>),
     Block(Box<Block>),
     For(Box<For>),
-    Transform(Box<Transform>),
-    Filter(Box<Filter>),
-    Find(Box<Find>),
-    Remove(Box<Remove>),
     Use(Use),
-    Select(Box<Select>),
-    Insert(Box<Insert>),
     IndexAssignment(Box<IndexAssignment>),
 }
 
@@ -60,25 +54,7 @@ impl AbstractTree for Statement {
             "for" => Ok(Statement::For(Box::new(For::from_syntax_node(
                 source, child,
             )?))),
-            "transform" => Ok(Statement::Transform(Box::new(Transform::from_syntax_node(
-                source, child,
-            )?))),
-            "filter" => Ok(Statement::Filter(Box::new(Filter::from_syntax_node(
-                source, child,
-            )?))),
-            "find" => Ok(Statement::Find(Box::new(Find::from_syntax_node(
-                source, child,
-            )?))),
-            "remove" => Ok(Statement::Remove(Box::new(Remove::from_syntax_node(
-                source, child,
-            )?))),
-            "select" => Ok(Statement::Select(Box::new(Select::from_syntax_node(
-                source, child,
-            )?))),
             "use" => Ok(Statement::Use(Use::from_syntax_node(source, child)?)),
-            "insert" => Ok(Statement::Insert(Box::new(Insert::from_syntax_node(
-                source, child,
-            )?))),
             "index_assignment" => Ok(Statement::IndexAssignment(Box::new(IndexAssignment::from_syntax_node(
                 source, child,
             )?))),
@@ -91,7 +67,7 @@ impl AbstractTree for Statement {
         }
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         match self {
             Statement::Assignment(assignment) => assignment.run(source, context),
             Statement::Return(expression) => expression.run(source, context),
@@ -101,14 +77,23 @@ impl AbstractTree for Statement {
             Statement::While(r#while) => r#while.run(source, context),
             Statement::Block(block) => block.run(source, context),
             Statement::For(r#for) => r#for.run(source, context),
-            Statement::Transform(transform) => transform.run(source, context),
-            Statement::Filter(filter) => filter.run(source, context),
-            Statement::Find(find) => find.run(source, context),
-            Statement::Remove(remove) => remove.run(source, context),
             Statement::Use(run) => run.run(source, context),
-            Statement::Select(select) => select.run(source, context),
-            Statement::Insert(insert) => insert.run(source, context),
             Statement::IndexAssignment(index_assignment) => index_assignment.run(source, context),
         }
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        match self {
+            Statement::Assignment(assignment) => assignment.expected_type(context),
+            Statement::Return(expression) => expression.expected_type(context),
+            Statement::Expression(expression) => expression.expected_type(context),
+            Statement::IfElse(if_else) => if_else.expected_type(context),
+            Statement::Match(r#match) => r#match.expected_type(context),
+            Statement::While(r#while) => r#while.expected_type(context),
+            Statement::Block(block) => block.expected_type(context),
+            Statement::For(r#for) => r#for.expected_type(context),
+            Statement::Use(r#use) => r#use.expected_type(context),
+            Statement::IndexAssignment(index_assignment) => index_assignment.expected_type(context),
+        }
+    }
 }
diff --git a/src/abstract_tree/type.rs b/src/abstract_tree/type.rs
deleted file mode 100644
index 578174a..0000000
--- a/src/abstract_tree/type.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use std::fmt::{self, Display, Formatter};
-
-use serde::{Deserialize, Serialize};
-use tree_sitter::Node;
-
-use crate::{AbstractTree, Error, Map, Result, Value};
-
-#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
-pub enum Type {
-    Any,
-    Boolean,
-    Float,
-    Function,
-    Integer,
-    List,
-    Map,
-    String,
-    Table,
-}
-
-impl Type {
-    pub fn check(&self, value: &Value) -> Result<()> {
-        match (self, value.r#type()) {
-            (Type::Any, _)
-            | (Type::Boolean, Type::Boolean)
-            | (Type::Float, Type::Float)
-            | (Type::Function, Type::Function)
-            | (Type::Integer, Type::Integer)
-            | (Type::List, Type::List)
-            | (Type::Map, Type::Map)
-            | (Type::String, Type::String)
-            | (Type::Table, Type::Table) => Ok(()),
-            (Type::Boolean, _) => Err(Error::TypeCheck {
-                expected: Type::Boolean,
-                actual: value.clone(),
-            }),
-            (Type::Float, _) => Err(Error::TypeCheck {
-                expected: Type::Float,
-                actual: value.clone(),
-            }),
-            (Type::Function, _) => Err(Error::TypeCheck {
-                expected: Type::Function,
-                actual: value.clone(),
-            }),
-            (Type::Integer, _) => Err(Error::TypeCheck {
-                expected: Type::Integer,
-                actual: value.clone(),
-            }),
-            (Type::List, _) => Err(Error::TypeCheck {
-                expected: Type::List,
-                actual: value.clone(),
-            }),
-            (Type::Map, _) => Err(Error::TypeCheck {
-                expected: Type::Map,
-                actual: value.clone(),
-            }),
-            (Type::String, _) => Err(Error::TypeCheck {
-                expected: Type::String,
-                actual: value.clone(),
-            }),
-            (Type::Table, _) => Err(Error::TypeCheck {
-                expected: Type::Table,
-                actual: value.clone(),
-            }),
-        }
-    }
-}
-
-impl AbstractTree for Type {
-    fn from_syntax_node(source: &str, node: Node) -> Result<Self> {
-        Error::expect_syntax_node(source, "type", node)?;
-
-        let range_without_punctuation = node.start_byte() + 1..node.end_byte() - 1;
-
-        let r#type = match &source[range_without_punctuation] {
-            "any" => Type::Any,
-            "bool" => Type::Boolean,
-            "float" => Type::Float,
-            "fn" => Type::Function,
-            "int" => Type::Integer,
-            "list" => Type::List,
-            "map" => Type::Map,
-            "str" => Type::String,
-            "table" => Type::Table,
-            _ => {
-                return Err(Error::UnexpectedSyntaxNode {
-                    expected: "any, bool, float, fn, int, list, map, str or table",
-                    actual: node.kind(),
-                    location: node.start_position(),
-                    relevant_source: source[node.byte_range()].to_string(),
-                })
-            }
-        };
-
-        Ok(r#type)
-    }
-
-    fn run(&self, _source: &str, _context: &mut Map) -> Result<Value> {
-        Ok(Value::Empty)
-    }
-}
-
-impl Display for Type {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            Type::Any => write!(f, "any"),
-            Type::Boolean => write!(f, "bool"),
-            Type::Float => write!(f, "float"),
-            Type::Function => write!(f, "function"),
-            Type::Integer => write!(f, "integer"),
-            Type::List => write!(f, "list"),
-            Type::Map => write!(f, "map"),
-            Type::String => write!(f, "string"),
-            Type::Table => write!(f, "table"),
-        }
-    }
-}
diff --git a/src/abstract_tree/type_defintion.rs b/src/abstract_tree/type_defintion.rs
new file mode 100644
index 0000000..d307627
--- /dev/null
+++ b/src/abstract_tree/type_defintion.rs
@@ -0,0 +1,170 @@
+use std::fmt::{self, Display, Formatter};
+
+use serde::{Deserialize, Serialize};
+use tree_sitter::Node;
+
+use crate::{AbstractTree, Error, Map, Result, Value};
+
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
+pub enum TypeDefinition {
+    Any,
+    Boolean,
+    Empty,
+    Float,
+    Function {
+        parameter_types: Vec<TypeDefinition>,
+        return_type: Box<TypeDefinition>,
+    },
+    Integer,
+    List(Box<TypeDefinition>),
+    Map,
+    Number,
+    String,
+    Table,
+}
+
+impl TypeDefinition {
+    //     pub fn check(&self, value: &Value) -> Result<()> {
+    //         match (self, value.r#type()?) {
+    //             (Type::Any, _)
+    //             | (Type::Boolean, Type::Boolean)
+    //             | (Type::Empty, Type::Empty)
+    //             | (Type::Float, Type::Float)
+    //             | (Type::Integer, Type::Integer)
+    //             | (Type::Map, Type::Map)
+    //             | (Type::Number, Type::Number)
+    //             | (Type::Number, Type::Integer)
+    //             | (Type::Number, Type::Float)
+    //             | (Type::Integer, Type::Number)
+    //             | (Type::Float, Type::Number)
+    //             | (Type::String, Type::String)
+    //             | (Type::Table, Type::Table) => Ok(()),
+    //             (Type::List(expected), Type::List(actual)) => {
+    //                 if expected != &actual {
+    //                     Err(Error::TypeCheck {
+    //                         expected: Type::List(expected.clone()),
+    //                         actual: value.clone(),
+    //                     })
+    //                 } else {
+    //                     Ok(())
+    //                 }
+    //             }
+    //             (
+    //                 Type::Function {
+    //                     parameter_types: left_parameters,
+    //                     return_type: left_return,
+    //                 },
+    //                 Type::Function {
+    //                     parameter_types: right_parameters,
+    //                     return_type: right_return,
+    //                 },
+    //             ) => {
+    //                 if left_parameters != &right_parameters || left_return != &right_return {
+    //                     Err(Error::TypeCheck {
+    //                         expected: Type::Function {
+    //                             parameter_types: left_parameters.clone(),
+    //                             return_type: left_return.clone(),
+    //                         },
+    //                         actual: value.clone(),
+    //                     })
+    //                 } else {
+    //                     Ok(())
+    //                 }
+    //             }
+    //             (Type::Boolean, _) => Err(Error::TypeCheck {
+    //                 expected: Type::Boolean,
+    //                 actual: value.clone(),
+    //             }),
+    //             (Type::Empty, _) => Err(Error::TypeCheck {
+    //                 expected: Type::Empty,
+    //                 actual: value.clone(),
+    //             }),
+    //             (Type::Float, _) => Err(Error::TypeCheck {
+    //                 expected: Type::Float,
+    //                 actual: value.clone(),
+    //             }),
+    //             (expected, _) => Err(Error::TypeCheck {
+    //                 expected: expected.clone(),
+    //                 actual: value.clone(),
+    //             }),
+    //             (Type::Integer, _) => Err(Error::TypeCheck {
+    //                 expected: Type::Integer,
+    //                 actual: value.clone(),
+    //             }),
+    //             (expected, _) => Err(Error::TypeCheck {
+    //                 expected: expected.clone(),
+    //                 actual: value.clone(),
+    //             }),
+    //             (Type::Map, _) => Err(Error::TypeCheck {
+    //                 expected: Type::Map,
+    //                 actual: value.clone(),
+    //             }),
+    //             (Type::String, _) => Err(Error::TypeCheck {
+    //                 expected: Type::String,
+    //                 actual: value.clone(),
+    //             }),
+    //             (Type::Table, _) => Err(Error::TypeCheck {
+    //                 expected: Type::Table,
+    //                 actual: value.clone(),
+    //             }),
+    //         }
+    //     }
+}
+
+impl AbstractTree for TypeDefinition {
+    fn from_syntax_node(source: &str, node: Node) -> Result<Self> {
+        Error::expect_syntax_node(source, "type_definition", node)?;
+
+        let type_node = node.child(1).unwrap();
+        let type_symbol = &source[type_node.byte_range()];
+
+        let r#type = match type_symbol {
+            "any" => TypeDefinition::Any,
+            "bool" => TypeDefinition::Boolean,
+            "float" => TypeDefinition::Float,
+            "fn" => {
+                todo!()
+            }
+            "int" => TypeDefinition::Integer,
+            "map" => TypeDefinition::Map,
+            "str" => TypeDefinition::String,
+            "table" => TypeDefinition::Table,
+            _ => {
+                return Err(Error::UnexpectedSyntaxNode {
+                    expected: "any, bool, float, fn, int, list, map, str or table",
+                    actual: type_node.kind(),
+                    location: type_node.start_position(),
+                    relevant_source: source[type_node.byte_range()].to_string(),
+                })
+            }
+        };
+
+        Ok(r#type)
+    }
+
+    fn run(&self, _source: &str, _context: &Map) -> Result<Value> {
+        Ok(Value::Empty)
+    }
+
+    fn expected_type(&self, _context: &Map) -> Result<TypeDefinition> {
+        Ok(TypeDefinition::Empty)
+    }
+}
+
+impl Display for TypeDefinition {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            TypeDefinition::Any => write!(f, "any"),
+            TypeDefinition::Boolean => write!(f, "bool"),
+            TypeDefinition::Empty => write!(f, "empty"),
+            TypeDefinition::Float => write!(f, "float"),
+            TypeDefinition::Function { .. } => write!(f, "function"),
+            TypeDefinition::Integer => write!(f, "integer"),
+            TypeDefinition::List(_) => write!(f, "list"),
+            TypeDefinition::Map => write!(f, "map"),
+            TypeDefinition::Number => write!(f, "number"),
+            TypeDefinition::String => write!(f, "string"),
+            TypeDefinition::Table => write!(f, "table"),
+        }
+    }
+}
diff --git a/src/abstract_tree/use.rs b/src/abstract_tree/use.rs
index 81bac25..5c8d8c4 100644
--- a/src/abstract_tree/use.rs
+++ b/src/abstract_tree/use.rs
@@ -2,7 +2,7 @@ use std::fs::read_to_string;
 
 use serde::{Deserialize, Serialize};
 
-use crate::{evaluate_with_context, AbstractTree, Error, Map, Result, Value};
+use crate::{evaluate_with_context, AbstractTree, Error, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Use {
@@ -21,7 +21,7 @@ impl AbstractTree for Use {
         Ok(Use { path })
     }
 
-    fn run(&self, _source: &str, _context: &mut Map) -> Result<Value> {
+    fn run(&self, _source: &str, _context: &Map) -> Result<Value> {
         let file_contents = read_to_string(&self.path)?;
         let mut file_context = Map::new();
 
@@ -29,4 +29,8 @@ impl AbstractTree for Use {
 
         Ok(Value::Map(file_context))
     }
+
+    fn expected_type(&self, _context: &Map) -> Result<TypeDefinition> {
+        Ok(TypeDefinition::Map)
+    }
 }
diff --git a/src/abstract_tree/value_node.rs b/src/abstract_tree/value_node.rs
index c001781..74519f9 100644
--- a/src/abstract_tree/value_node.rs
+++ b/src/abstract_tree/value_node.rs
@@ -5,7 +5,7 @@ use tree_sitter::Node;
 
 use crate::{
     AbstractTree, Error, Expression, Function, Identifier, List, Map, Result, Statement, Table,
-    Value,
+    TypeDefinition, Value,
 };
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
@@ -112,7 +112,7 @@ impl AbstractTree for ValueNode {
         Ok(value_node)
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let value = match self {
             ValueNode::Boolean(value_source) => Value::Boolean(value_source.parse().unwrap()),
             ValueNode::Float(value_source) => Value::Float(value_source.parse().unwrap()),
@@ -176,4 +176,31 @@ impl AbstractTree for ValueNode {
 
         Ok(value)
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        let r#type = match self {
+            ValueNode::Boolean(_) => TypeDefinition::Boolean,
+            ValueNode::Float(_) => TypeDefinition::Float,
+            ValueNode::Integer(_) => TypeDefinition::Integer,
+            ValueNode::String(_) => TypeDefinition::String,
+            ValueNode::List(expressions) => {
+                let first_expression_type = if let Some(first) = expressions.first() {
+                    first.expected_type(context)?
+                } else {
+                    TypeDefinition::Empty
+                };
+
+                TypeDefinition::List(Box::new(first_expression_type))
+            }
+            ValueNode::Empty => TypeDefinition::Any,
+            ValueNode::Map(_) => TypeDefinition::Map,
+            ValueNode::Table {
+                column_names: _,
+                rows: _,
+            } => TypeDefinition::Table,
+            ValueNode::Function(function) => function.expected_type(context)?,
+        };
+
+        Ok(r#type)
+    }
 }
diff --git a/src/abstract_tree/while.rs b/src/abstract_tree/while.rs
index 4bf2ea0..829824d 100644
--- a/src/abstract_tree/while.rs
+++ b/src/abstract_tree/while.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Block, Expression, Map, Result, Value};
+use crate::{AbstractTree, Block, Expression, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct While {
@@ -22,13 +22,17 @@ impl AbstractTree for While {
         Ok(While { expression, block })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         while self.expression.run(source, context)?.as_boolean()? {
             self.block.run(source, context)?;
         }
 
         Ok(Value::Empty)
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        self.block.expected_type(context)
+    }
 }
 
 #[cfg(test)]
diff --git a/src/abstract_tree/yield.rs b/src/abstract_tree/yield.rs
index 073a2be..1c6637d 100644
--- a/src/abstract_tree/yield.rs
+++ b/src/abstract_tree/yield.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Expression, FunctionCall, Result, Value};
+use crate::{AbstractTree, Expression, FunctionCall, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Yield {
@@ -35,7 +35,11 @@ impl AbstractTree for Yield {
         Ok(Yield { call })
     }
 
-    fn run(&self, source: &str, context: &mut crate::Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         self.call.run(source, context)
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        self.call.expected_type(context)
+    }
 }
diff --git a/src/error.rs b/src/error.rs
index a18fe85..c8d7c79 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -5,7 +5,7 @@
 
 use tree_sitter::{Node, Point};
 
-use crate::{value::Value, Identifier, Type};
+use crate::{value::Value, Identifier, TypeDefinition};
 
 use std::{fmt, io, num::ParseFloatError, string::FromUtf8Error, sync::PoisonError, time};
 
@@ -21,7 +21,7 @@ pub enum Error {
     },
 
     TypeCheck {
-        expected: Type,
+        expected: TypeDefinition,
         actual: Value,
     },
 
diff --git a/src/evaluator.rs b/src/evaluate.rs
similarity index 89%
rename from src/evaluator.rs
rename to src/evaluate.rs
index e2e0164..7b04c9a 100644
--- a/src/evaluator.rs
+++ b/src/evaluate.rs
@@ -4,7 +4,7 @@
 //! functions or by constructing your own Evaluator.
 use tree_sitter::{Parser, Tree as TSTree};
 
-use crate::{language, AbstractTree, Map, Result, Statement, Value};
+use crate::{language, AbstractTree, Map, Result, Root, Value};
 
 /// Evaluate the given source code.
 ///
@@ -50,41 +50,34 @@ pub fn evaluate_with_context(source: &str, context: &mut Map) -> Result<Value> {
     let mut parser = Parser::new();
     parser.set_language(language()).unwrap();
 
-    Evaluator::new(parser, context, source).run()
+    Interpreter::parse(parser, context, source)?.run()
 }
 
 /// A source code interpreter for the Dust language.
-pub struct Evaluator<'c, 's> {
+pub struct Interpreter<'c, 's> {
     _parser: Parser,
     context: &'c mut Map,
     source: &'s str,
     syntax_tree: TSTree,
+    abstract_tree: Root,
 }
 
-impl<'c, 's> Evaluator<'c, 's> {
-    pub fn new(mut parser: Parser, context: &'c mut Map, source: &'s str) -> Self {
+impl<'c, 's> Interpreter<'c, 's> {
+    pub fn parse(mut parser: Parser, context: &'c mut Map, source: &'s str) -> Result<Self> {
         let syntax_tree = parser.parse(source, None).unwrap();
+        let abstract_tree = Root::from_syntax_node(source, syntax_tree.root_node())?;
 
-        Evaluator {
+        Ok(Interpreter {
             _parser: parser,
             context,
             source,
             syntax_tree,
-        }
+            abstract_tree,
+        })
     }
 
-    pub fn run(self) -> Result<Value> {
-        let root_node = self.syntax_tree.root_node();
-        let mut value = Value::Empty;
-
-        for index in 0..root_node.child_count() {
-            let statement_node = root_node.child(index).unwrap();
-            let statement = Statement::from_syntax_node(self.source, statement_node)?;
-
-            value = statement.run(self.source, self.context)?;
-        }
-
-        Ok(value)
+    pub fn run(&mut self) -> Result<Value> {
+        self.abstract_tree.run(self.source, self.context)
     }
 
     pub fn syntax_tree(&self) -> String {
@@ -247,7 +240,7 @@ mod tests {
         assert_eq!(
             evaluate(
                 "
-                foobar = |message <str>| <str> { message }
+                foobar <fn str -> str> = |message| { message }
                 (foobar 'Hiya')
                 ",
             ),
diff --git a/src/lib.rs b/src/lib.rs
index 4db9f6f..b9b3a9f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -8,14 +8,14 @@ pub use crate::{
     abstract_tree::*,
     built_in_functions::{BuiltInFunction, BUILT_IN_FUNCTIONS},
     error::*,
-    evaluator::*,
+    evaluate::*,
     value::{function::Function, list::List, map::Map, table::Table, Value},
 };
 
 mod abstract_tree;
 pub mod built_in_functions;
 mod error;
-mod evaluator;
+mod evaluate;
 mod value;
 
 use tree_sitter::Language;
diff --git a/src/main.rs b/src/main.rs
index e3df3be..bddda7b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,7 +12,7 @@ use tree_sitter::Parser as TSParser;
 
 use std::{borrow::Cow, fs::read_to_string};
 
-use dust_lang::{evaluate_with_context, language, Evaluator, Map, Value};
+use dust_lang::{evaluate_with_context, language, Interpreter, Map, Value};
 
 /// Command-line arguments to be parsed.
 #[derive(Parser, Debug)]
@@ -30,10 +30,14 @@ struct Args {
     #[arg(short = 'p', long)]
     input_path: Option<String>,
 
-    /// A path to file whose contents will be assigned to the "input" variable.
+    /// Show the syntax tree.
     #[arg(short = 't', long = "tree")]
     show_syntax_tree: bool,
 
+    /// Launch in interactive mode.
+    #[arg(short, long)]
+    interactive: bool,
+
     /// Location of the file to run.
     path: Option<String>,
 }
@@ -74,13 +78,21 @@ fn main() {
     let mut parser = TSParser::new();
     parser.set_language(language()).unwrap();
 
-    let evaluator = Evaluator::new(parser, &mut context, &source);
+    let mut interpreter = Interpreter::parse(parser, &mut context, &source).unwrap();
 
-    if args.show_syntax_tree {
-        println!("{}", evaluator.syntax_tree());
+    if args.interactive {
+        loop {
+            let result = interpreter.run();
+
+            println!("{result:?}")
+        }
     }
 
-    let eval_result = evaluator.run();
+    if args.show_syntax_tree {
+        println!("{}", interpreter.syntax_tree());
+    }
+
+    let eval_result = interpreter.run();
 
     match eval_result {
         Ok(value) => {
diff --git a/src/value/function.rs b/src/value/function.rs
index 1943675..3fe2230 100644
--- a/src/value/function.rs
+++ b/src/value/function.rs
@@ -3,19 +3,22 @@ use std::fmt::{self, Display, Formatter};
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{AbstractTree, Block, Error, Identifier, Map, Result, Type, Value};
+use crate::{AbstractTree, Block, Error, Identifier, Map, Result, TypeDefinition, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct Function {
-    parameters: Vec<(Identifier, Type)>,
-    return_type: Option<Type>,
+    parameters: Vec<Identifier>,
     body: Block,
 }
 
 impl Function {
-    pub fn parameters(&self) -> &Vec<(Identifier, Type)> {
+    pub fn parameters(&self) -> &Vec<Identifier> {
         &self.parameters
     }
+
+    pub fn body(&self) -> &Block {
+        &self.body
+    }
 }
 
 impl AbstractTree for Function {
@@ -25,66 +28,38 @@ impl AbstractTree for Function {
         let child_count = node.child_count();
         let mut parameters = Vec::new();
 
-        for index in 1..child_count - 2 {
-            let parameter_node = {
-                let child = node.child(index).unwrap();
+        for index in 0..child_count {
+            let child = node.child(index).unwrap();
 
-                if child.is_named() {
-                    child
-                } else {
-                    continue;
-                }
-            };
-
-            Error::expect_syntax_node(source, "parameter", parameter_node)?;
-
-            let identifier_node = parameter_node.child(0).unwrap();
-            let identifier = Identifier::from_syntax_node(source, identifier_node)?;
-
-            let type_node = parameter_node.child(1).unwrap();
-            let r#type = Type::from_syntax_node(source, type_node)?;
-
-            parameters.push((identifier, r#type))
+            if child.is_named() {
+                let identifier = Identifier::from_syntax_node(source, child)?;
+                parameters.push(identifier);
+            }
         }
 
-        let return_type_node = node.child(child_count - 2).unwrap();
-        let return_type = if return_type_node.is_named() {
-            Some(Type::from_syntax_node(source, return_type_node)?)
-        } else {
-            None
-        };
-
         let body_node = node.child(child_count - 1).unwrap();
         let body = Block::from_syntax_node(source, body_node)?;
 
-        Ok(Function {
-            parameters,
-            return_type,
-            body,
-        })
+        Ok(Function { parameters, body })
     }
 
-    fn run(&self, source: &str, context: &mut Map) -> Result<Value> {
+    fn run(&self, source: &str, context: &Map) -> Result<Value> {
         let return_value = self.body.run(source, context)?;
 
-        if let Some(r#type) = &self.return_type {
-            r#type.check(&return_value)?;
-        } else if !return_value.is_empty() {
-            return Err(Error::ExpectedEmpty {
-                actual: return_value.clone(),
-            });
-        }
-
         Ok(return_value)
     }
+
+    fn expected_type(&self, context: &Map) -> Result<TypeDefinition> {
+        self.body.expected_type(context)
+    }
 }
 
 impl Display for Function {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "Function {{ parameters: {:?}, return_type: {:?}, body: {:?} }}",
-            self.parameters, self.return_type, self.body
+            "Function {{ parameters: {:?}, body: {:?} }}",
+            self.parameters, self.body
         )
     }
 }
diff --git a/src/value/mod.rs b/src/value/mod.rs
index eafa212..a878b21 100644
--- a/src/value/mod.rs
+++ b/src/value/mod.rs
@@ -1,7 +1,7 @@
 //! Types that represent runtime values.
 use crate::{
     error::{Error, Result},
-    Function, List, Map, Table, Type,
+    AbstractTree, Function, List, Map, Table, TypeDefinition,
 };
 
 use serde::{
@@ -43,18 +43,41 @@ pub enum Value {
 }
 
 impl Value {
-    pub fn r#type(&self) -> Type {
-        match self {
-            Value::List(_) => Type::List,
-            Value::Map(_) => Type::Map,
-            Value::Table(_) => Type::Table,
-            Value::Function(_) => Type::Function,
-            Value::String(_) => Type::String,
-            Value::Float(_) => Type::Float,
-            Value::Integer(_) => Type::Integer,
-            Value::Boolean(_) => Type::Boolean,
-            Value::Empty => Type::Any,
-        }
+    pub fn r#type(&self, context: &Map) -> Result<TypeDefinition> {
+        let r#type = match self {
+            Value::List(list) => {
+                let first_item_type = if let Some(first) = list.items().first() {
+                    first.r#type(context)?
+                } else {
+                    TypeDefinition::Empty
+                };
+
+                TypeDefinition::List(Box::new(first_item_type))
+            }
+            Value::Map(_) => TypeDefinition::Map,
+            Value::Table(_) => TypeDefinition::Table,
+            Value::Function(function) => {
+                let parameter_types = Vec::new();
+
+                for identifier in function.parameters() {
+                    let _type = identifier.expected_type(context)?;
+                }
+
+                let return_type = function.body().expected_type(context)?;
+
+                TypeDefinition::Function {
+                    parameter_types,
+                    return_type: Box::new(return_type),
+                }
+            }
+            Value::String(_) => TypeDefinition::String,
+            Value::Float(_) => TypeDefinition::Float,
+            Value::Integer(_) => TypeDefinition::Integer,
+            Value::Boolean(_) => TypeDefinition::Boolean,
+            Value::Empty => TypeDefinition::Empty,
+        };
+
+        Ok(r#type)
     }
 
     pub fn is_table(&self) -> bool {
diff --git a/tree-sitter-dust/.prettierignore b/tree-sitter-dust/.prettierignore
new file mode 100644
index 0000000..8eba6c8
--- /dev/null
+++ b/tree-sitter-dust/.prettierignore
@@ -0,0 +1 @@
+src/
diff --git a/tree-sitter-dust/.prettierrc b/tree-sitter-dust/.prettierrc
new file mode 100644
index 0000000..7573f24
--- /dev/null
+++ b/tree-sitter-dust/.prettierrc
@@ -0,0 +1,5 @@
+{
+  "arrowParens": "avoid",
+  "printWidth": 40,
+  "singleQuote": true
+}
diff --git a/tree-sitter-dust/corpus/assignment.txt b/tree-sitter-dust/corpus/assignment.txt
index c63a135..d7d1524 100644
--- a/tree-sitter-dust/corpus/assignment.txt
+++ b/tree-sitter-dust/corpus/assignment.txt
@@ -27,7 +27,8 @@ x <int> = y
   (statement
     (assignment
       (identifier)
-      (type)
+      (type_definition
+        (type))
       (assignment_operator)
       (statement
         (expression
diff --git a/tree-sitter-dust/corpus/async.txt b/tree-sitter-dust/corpus/async.txt
index 6f3ecd8..46da4a9 100644
--- a/tree-sitter-dust/corpus/async.txt
+++ b/tree-sitter-dust/corpus/async.txt
@@ -12,10 +12,11 @@ async { (output 'Whaddup') }
       (statement
         (expression
           (function_call
-            (built_in_function
-              (expression
-                (value
-                  (string))))))))))
+            (expression
+              (identifier))
+            (expression
+              (value
+                (string)))))))))
 
 ================================================================================
 Complex Async Statements
diff --git a/tree-sitter-dust/corpus/built_in_function.txt b/tree-sitter-dust/corpus/built_in_function.txt
index 0990736..aeefccc 100644
--- a/tree-sitter-dust/corpus/built_in_function.txt
+++ b/tree-sitter-dust/corpus/built_in_function.txt
@@ -10,10 +10,11 @@ Simple Function Call
   (statement
     (expression
       (function_call
-        (built_in_function
-          (expression
-            (value
-              (string))))))))
+        (expression
+          (identifier))
+        (expression
+          (value
+            (string)))))))
 
 ================================================================================
 Nested Function Call
@@ -27,10 +28,10 @@ Nested Function Call
   (statement
     (expression
       (function_call
-        (built_in_function
-          (expression
-            (function_call
-              (built_in_function)))
-          (expression
-            (value
-              (integer))))))))
+        (expression
+          (identifier))
+        (expression
+          (identifier))
+        (expression
+          (value
+            (integer)))))))
diff --git a/tree-sitter-dust/corpus/for.txt b/tree-sitter-dust/corpus/for.txt
index 03c6e66..db5fdab 100644
--- a/tree-sitter-dust/corpus/for.txt
+++ b/tree-sitter-dust/corpus/for.txt
@@ -28,9 +28,10 @@ for i in [1, 2, 3] {
         (statement
           (expression
             (function_call
-              (built_in_function
-                (expression
-                  (identifier))))))))))
+              (expression
+                (identifier))
+              (expression
+                (identifier)))))))))
 
 ================================================================================
 Nested For Loop
@@ -60,6 +61,7 @@ for list in list_of_lists {
               (statement
                 (expression
                   (function_call
-                    (built_in_function
-                      (expression
-                        (identifier)))))))))))))
+                    (expression
+                      (identifier))
+                    (expression
+                      (identifier))))))))))))
diff --git a/tree-sitter-dust/corpus/functions.txt b/tree-sitter-dust/corpus/functions.txt
index ab030a7..078d846 100644
--- a/tree-sitter-dust/corpus/functions.txt
+++ b/tree-sitter-dust/corpus/functions.txt
@@ -2,7 +2,7 @@
 Simple Function
 ================================================================================
 
-|| <str> { "Hiya" }
+|| { "Hiya" }
 
 --------------------------------------------------------------------------------
 
@@ -11,7 +11,6 @@ Simple Function
     (expression
       (value
         (function
-          (type)
           (block
             (statement
               (expression
@@ -22,7 +21,7 @@ Simple Function
 Function Assignment
 ================================================================================
 
-x = || <str> { "Hiya" }
+x <fn num -> str> = |number| { "Hiya" }
 
 --------------------------------------------------------------------------------
 
@@ -30,12 +29,16 @@ x = || <str> { "Hiya" }
   (statement
     (assignment
       (identifier)
+      (type_definition
+        (type
+          (type)
+          (type)))
       (assignment_operator)
       (statement
         (expression
           (value
             (function
-              (type)
+              (identifier)
               (block
                 (statement
                   (expression
@@ -64,7 +67,7 @@ Function Call
 Complex Function
 ================================================================================
 
-|message <str> number <int>| {
+|message number| {
   (output message)
   (output number)
 }
@@ -76,25 +79,23 @@ Complex Function
     (expression
       (value
         (function
-          (parameter
-            (identifier)
-            (type))
-          (parameter
-            (identifier)
-            (type))
+          (identifier)
+          (identifier)
           (block
             (statement
               (expression
                 (function_call
-                  (built_in_function
-                    (expression
-                      (identifier))))))
+                  (expression
+                    (identifier))
+                  (expression
+                    (identifier)))))
             (statement
               (expression
                 (function_call
-                  (built_in_function
-                    (expression
-                      (identifier))))))))))))
+                  (expression
+                    (identifier))
+                  (expression
+                    (identifier)))))))))))
 
 ================================================================================
 Complex Function Call
diff --git a/tree-sitter-dust/corpus/tables.txt b/tree-sitter-dust/corpus/tables.txt
deleted file mode 100644
index 0e7b301..0000000
--- a/tree-sitter-dust/corpus/tables.txt
+++ /dev/null
@@ -1,105 +0,0 @@
-================================================================================
-Table Declaration
-================================================================================
-
-table |messages numbers| [
-    ['hiya' 42]
-    ['foo'  57]
-    ['bar'  99.99]
-]
-
---------------------------------------------------------------------------------
-
-(root
-  (statement
-    (expression
-      (value
-        (table
-          (identifier_list
-            (identifier)
-            (identifier))
-          (expression
-            (value
-              (list
-                (expression
-                  (value
-                    (list
-                      (expression
-                        (value
-                          (string)))
-                      (expression
-                        (value
-                          (integer))))))
-                (expression
-                  (value
-                    (list
-                      (expression
-                        (value
-                          (string)))
-                      (expression
-                        (value
-                          (integer))))))
-                (expression
-                  (value
-                    (list
-                      (expression
-                        (value
-                          (string)))
-                      (expression
-                        (value
-                          (float))))))))))))))
-
-================================================================================
-Table Access
-================================================================================
-
-select |number| from foobar {
-  text == 'answer'
-}
-
---------------------------------------------------------------------------------
-
-(root
-  (statement
-    (select
-      (identifier_list
-        (identifier))
-      (expression
-        (identifier))
-      (block
-        (statement
-          (expression
-            (logic
-              (expression
-                (identifier))
-              (logic_operator)
-              (expression
-                (value
-                  (string))))))))))
-
-================================================================================
-Table Insert
-================================================================================
-
-insert into foobar [
-  ['bob was here', 0]
-]
-
---------------------------------------------------------------------------------
-
-(root
-  (statement
-    (insert
-      (identifier)
-      (expression
-        (value
-          (list
-            (expression
-              (value
-                (list
-                  (expression
-                    (value
-                      (string)))
-                  (expression
-                    (value
-                      (integer))))))))))))
diff --git a/tree-sitter-dust/corpus/while.txt b/tree-sitter-dust/corpus/while.txt
index 4733771..5232b7c 100644
--- a/tree-sitter-dust/corpus/while.txt
+++ b/tree-sitter-dust/corpus/while.txt
@@ -18,10 +18,11 @@ while true {
         (statement
           (expression
             (function_call
-              (built_in_function
-                (expression
-                  (value
-                    (string)))))))))))
+              (expression
+                (identifier))
+              (expression
+                (value
+                  (string))))))))))
 
 ================================================================================
 Nested While Loop
diff --git a/tree-sitter-dust/corpus/yield.txt b/tree-sitter-dust/corpus/yield.txt
index 1883d2f..7889ccd 100644
--- a/tree-sitter-dust/corpus/yield.txt
+++ b/tree-sitter-dust/corpus/yield.txt
@@ -13,7 +13,8 @@ Simple Yield
         (expression
           (value
             (integer)))
-        (built_in_function)))))
+        (expression
+          (identifier))))))
 
 ================================================================================
 Yield Chain
diff --git a/tree-sitter-dust/grammar.js b/tree-sitter-dust/grammar.js
index eb7632a..b17bba0 100644
--- a/tree-sitter-dust/grammar.js
+++ b/tree-sitter-dust/grammar.js
@@ -3,301 +3,405 @@ module.exports = grammar({
 
   word: $ => $.identifier,
 
-  extras: $ => [ /\s/, $._comment ],
+  extras: $ => [/\s/, $._comment],
 
   rules: {
-    root: $ => prec(1, repeat1($.statement)),
+    root: $ =>
+      prec(1, repeat1($.statement)),
 
     _comment: $ => /[#][^#\n]*[#|\n]/,
 
-    block: $ => seq(
-      optional('async'),
-      '{',
-      repeat1($.statement),
-      '}',
-    ),
-
-    statement: $ => prec.left(seq(
-      choice(
-        $.assignment,
-        $.block,
-        $.expression,
-        $.for,
-        $.if_else,
-        $.index_assignment,
-        $.insert,
-        $.match,
-        $.return,
-        $.select,
-        $.use,
-        $.while,
+    block: $ =>
+      seq(
+        optional('async'),
+        '{',
+        repeat1($.statement),
+        '}',
       ),
-      optional(';'),
-    )),
 
-    expression: $ => prec.right(choice(
-      $._expression_kind,
-      seq('(', $._expression_kind, ')'),
-    )),
+    statement: $ =>
+      prec.left(
+        seq(
+          choice(
+            $.assignment,
+            $.block,
+            $.expression,
+            $.for,
+            $.if_else,
+            $.index_assignment,
+            $.match,
+            $.return,
+            $.use,
+            $.while,
+          ),
+          optional(';'),
+        ),
+      ),
 
-    _expression_kind: $ => prec.right(choice(
-      $.function_call,
-      $.identifier,
-      $.index,
-      $.logic,
-      $.math,
-      $.value,
-      $.yield,
-    )),
+    expression: $ =>
+      prec.right(
+        choice(
+          $._expression_kind,
+          seq(
+            '(',
+            $._expression_kind,
+            ')',
+          ),
+        ),
+      ),
 
-    _expression_list: $ => repeat1(prec.right(seq(
-      $.expression,
-      optional(','),
-    ))),
+    _expression_kind: $ =>
+      prec.right(
+        choice(
+          $.function_call,
+          $.identifier,
+          $.index,
+          $.logic,
+          $.math,
+          $.value,
+          $.yield,
+        ),
+      ),
 
-    identifier: $ => /[_a-zA-Z]+[_a-zA-Z0-9]?/,
-
-    value: $ => choice(
-      $.integer,
-      $.float,
-      $.string,
-      $.boolean,
-      $.list,
-      $.function,
-      $.table,
-      $.map,
-    ),
-
-    integer: $ => token(prec.left(seq(
-      optional('-'),
+    _expression_list: $ =>
       repeat1(
-        choice('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')
+        prec.right(
+          seq(
+            $.expression,
+            optional(','),
+          ),
+        ),
       ),
-    ))),
 
-    float: $ => token(prec.left(seq(
-      optional('-'),
-      repeat1(choice('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')),
-      '.',
-      repeat1(choice('1', '2', '3', '4', '5', '6', '7', '8', '9', '0')),
-    ))),
+    identifier: $ =>
+      /[_a-zA-Z]+[_a-zA-Z0-9]?/,
 
-    string: $ => /("[^"]*?")|('[^']*?')|(`[^`]*?`)/,
-
-    boolean: $ => choice(
-      'true',
-      'false',
-    ),
-
-    list: $ => seq(
-      '[',
-      repeat(prec.left(seq($.expression, optional(',')))),
-      ']',
-    ),
-
-    map: $ => seq(
-      '{',
-      repeat(seq(
-        $.identifier,
-        "=",
-        $.statement,
-        optional(',')
-      )),
-      '}',
-    ),
- 
-    index: $ => prec.left(1, seq(
-      $.expression,
-      ':',
-      $.expression,
-      optional(seq(
-        '..',
-        $.expression,
-      )),
-    )),
-
-    math: $ => prec.left(seq(
-      $.expression,
-      $.math_operator,      
-      $.expression,
-    )),
-
-    math_operator: $ => choice(
-      '+',
-      '-',
-      '*',
-      '/',
-      '%',
-    ),
-
-    logic: $ => prec.right(seq(
-      $.expression,
-      $.logic_operator,
-      $.expression,
-    )),
-
-    logic_operator: $ => choice(
-      '==',
-      '!=',
-      '&&',
-      '||',
-      '>',
-      '<',
-      ">=",
-      "<=",
-    ),
-
-    assignment: $ => seq(
-      field('identifier', $.identifier),
-      optional(field('type', $.type)),
-      field('assignment_operator', $.assignment_operator),
-      field('statement', $.statement),
-    ),
-
-    index_assignment: $ => seq(
-      $.index,
-      $.assignment_operator,
-      $.statement,
-    ),
-
-    assignment_operator: $ => prec.right(choice(
-      "=",
-      "+=",
-      "-=",
-    )),
-
-    if_else: $ => prec.right(seq(
-      $.if,
-      repeat($.else_if),
-      optional($.else),
-    )),
-
-    if: $ => seq(
-      'if',
-      $.expression,
-      $.block,
-    ),
-
-    else_if: $ => seq(
-      'else if',
-      $.expression,
-      $.block,
-    ),
-
-    else: $ => seq(
-      'else',
-      $.block,
-    ),
-
-    match: $ => prec.right(seq(
-      'match',
-      $.expression,
-      repeat1(seq(
-        $.expression,
-        '=>',
-        $.block,
-      )),
-    )),
-
-    while: $ => seq(
-      'while',
-      $.expression,
-      $.block,
-    ),
-
-    for: $ => seq(
+    value: $ =>
       choice(
-        'for',
-        'async for',
+        $.integer,
+        $.float,
+        $.string,
+        $.boolean,
+        $.list,
+        $.function,
+        $.table,
+        $.map,
       ),
-      $.identifier,
-      'in',
-      $.expression,
-      $.block,
-    ),
 
-    select: $ => prec.right(seq(
-      'select',
-      $.identifier_list,
-      'from',
-      $.expression,
-      optional($.block),
-    )),
+    integer: $ =>
+      token(
+        prec.left(
+          seq(
+            optional('-'),
+            repeat1(
+              choice(
+                '1',
+                '2',
+                '3',
+                '4',
+                '5',
+                '6',
+                '7',
+                '8',
+                '9',
+                '0',
+              ),
+            ),
+          ),
+        ),
+      ),
 
-    insert: $ => prec.right(seq(
-      'insert',
-      'into',
-      $.identifier,
-      $.expression,
-    )),
- 
-    identifier_list: $ => prec.right(choice(
+    float: $ =>
+      token(
+        prec.left(
+          seq(
+            optional('-'),
+            repeat1(
+              choice(
+                '1',
+                '2',
+                '3',
+                '4',
+                '5',
+                '6',
+                '7',
+                '8',
+                '9',
+                '0',
+              ),
+            ),
+            '.',
+            repeat1(
+              choice(
+                '1',
+                '2',
+                '3',
+                '4',
+                '5',
+                '6',
+                '7',
+                '8',
+                '9',
+                '0',
+              ),
+            ),
+          ),
+        ),
+      ),
+
+    string: $ =>
+      /("[^"]*?")|('[^']*?')|(`[^`]*?`)/,
+
+    boolean: $ =>
+      choice('true', 'false'),
+
+    list: $ =>
+      seq(
+        '[',
+        repeat(
+          prec.left(
+            seq(
+              $.expression,
+              optional(','),
+            ),
+          ),
+        ),
+        ']',
+      ),
+
+    map: $ =>
+      seq(
+        '{',
+        repeat(
+          seq(
+            $.identifier,
+            '=',
+            $.statement,
+            optional(','),
+          ),
+        ),
+        '}',
+      ),
+
+    index: $ =>
+      prec.left(
+        1,
+        seq(
+          $.expression,
+          ':',
+          $.expression,
+          optional(
+            seq('..', $.expression),
+          ),
+        ),
+      ),
+
+    math: $ =>
+      prec.left(
+        seq(
+          $.expression,
+          $.math_operator,
+          $.expression,
+        ),
+      ),
+
+    math_operator: $ =>
+      choice('+', '-', '*', '/', '%'),
+
+    logic: $ =>
+      prec.right(
+        seq(
+          $.expression,
+          $.logic_operator,
+          $.expression,
+        ),
+      ),
+
+    logic_operator: $ =>
+      choice(
+        '==',
+        '!=',
+        '&&',
+        '||',
+        '>',
+        '<',
+        '>=',
+        '<=',
+      ),
+
+    assignment: $ =>
+      seq(
+        field(
+          'identifier',
+          $.identifier,
+        ),
+        optional(
+          field(
+            'type',
+            $.type_definition,
+          ),
+        ),
+        field(
+          'assignment_operator',
+          $.assignment_operator,
+        ),
+        field('statement', $.statement),
+      ),
+
+    index_assignment: $ =>
+      seq(
+        $.index,
+        $.assignment_operator,
+        $.statement,
+      ),
+
+    assignment_operator: $ =>
+      prec.right(
+        choice('=', '+=', '-='),
+      ),
+
+    if_else: $ =>
+      prec.right(
+        seq(
+          $.if,
+          repeat($.else_if),
+          optional($.else),
+        ),
+      ),
+
+    if: $ =>
+      seq('if', $.expression, $.block),
+
+    else_if: $ =>
+      seq(
+        'else if',
+        $.expression,
+        $.block,
+      ),
+
+    else: $ => seq('else', $.block),
+
+    match: $ =>
+      prec.right(
+        seq(
+          'match',
+          $.expression,
+          repeat1(
+            seq(
+              $.expression,
+              '=>',
+              $.block,
+            ),
+          ),
+        ),
+      ),
+
+    while: $ =>
+      seq(
+        'while',
+        $.expression,
+        $.block,
+      ),
+
+    for: $ =>
+      seq(
+        choice('for', 'async for'),
+        $.identifier,
+        'in',
+        $.expression,
+        $.block,
+      ),
+
+    identifier_list: $ =>
+      prec.right(
+        choice(
+          seq(
+            '|',
+            repeat(
+              seq(
+                $.identifier,
+                optional(','),
+              ),
+            ),
+            '|',
+          ),
+        ),
+      ),
+
+    table: $ =>
+      prec.right(
+        seq(
+          'table',
+          $.identifier_list,
+          $.expression,
+        ),
+      ),
+
+    return: $ =>
+      seq('return', $.expression),
+
+    use: $ => seq('use', $.string),
+
+    type_definition: $ =>
+      seq('<', $.type, '>'),
+
+    type: $ =>
+      prec.right(
+        choice(
+          'any',
+          'bool',
+          seq(
+            'fn',
+            repeat(
+              seq(
+                $.type,
+                optional(','),
+              ),
+            ),
+            optional(seq('->', $.type)),
+          ),
+          'int',
+          seq('list', $.type),
+          'map',
+          'num',
+          'str',
+        ),
+      ),
+
+    function: $ =>
       seq(
         '|',
-        repeat(seq($.identifier, optional(','))),
+        repeat(
+          seq(
+            $.identifier,
+            optional(','),
+          ),
+        ),
         '|',
+        $.block,
       ),
-    )),
 
-    table: $ => prec.right(seq(
-      'table',
-      $.identifier_list,
-      $.expression,
-    )),
-
-    return: $ => seq(
-      'return',
-      $.expression,
-    ),
-
-    use: $ => seq(
-      'use',
-      $.string,
-    ),
-
-    type: $ => seq(
-      '<',
-      choice(
-        'any',
-        'bool',
-        'fn',
-        'int',
-        'list',
-        'map',
-        'str',
-        'table',
+    function_call: $ =>
+      prec.right(
+        1,
+        seq(
+          '(',
+          $.expression,
+          optional($._expression_list),
+          ')',
+        ),
       ),
-      '>',
-    ),
-  
-    function: $ => seq(
-      '|',
-      repeat($.parameter),
-      '|',
-      optional($.type),
-      $.block,
-    ),
 
-    parameter: $ => seq(
-      $.identifier,
-      $.type,
-      optional(','),
-    ),
-
-    function_call: $ => prec.right(1, seq(
-      '(',
-      $.expression,
-      optional($._expression_list),
-      ')',
-    )),
-
-    yield: $ => prec.left(seq(
-      $.expression,
-      '->',
-      '(',
-      $.expression,
-      optional($._expression_list),
-      ')',
-    )),
-  }
+    yield: $ =>
+      prec.left(
+        seq(
+          $.expression,
+          '->',
+          '(',
+          $.expression,
+          optional($._expression_list),
+          ')',
+        ),
+      ),
+  },
 });
diff --git a/tree-sitter-dust/grammar.js.new b/tree-sitter-dust/grammar.js.new
new file mode 100644
index 0000000..3858355
--- /dev/null
+++ b/tree-sitter-dust/grammar.js.new
@@ -0,0 +1,407 @@
+module.exports = grammar({
+  name: "dust",
+
+  word: $ => $.identifier,
+
+  extras: $ => [/\s/, $._comment],
+
+  rules: {
+    root: $ =>
+      prec(1, repeat1($.statement)),
+
+    _comment: $ => /[#][^#\n]*[#|\n]/,
+
+    block: $ =>
+      seq(
+        optional("async"),
+        "{",
+        repeat1($.statement),
+        "}",
+      ),
+
+    statement: $ =>
+      prec.left(
+        seq(
+          choice(
+            $.assignment,
+            $.block,
+            $.expression,
+            $.for,
+            $.if_else,
+            $.index_assignment,
+            $.match,
+            $.return,
+            $.use,
+            $.while,
+          ),
+          optional(";"),
+        ),
+      ),
+
+    expression: $ =>
+      prec.right(
+        choice(
+          $._expression_kind,
+          seq(
+            "(",
+            $._expression_kind,
+            ")",
+          ),
+        ),
+      ),
+
+    _expression_kind: $ =>
+      prec.right(
+        choice(
+          $.function_call,
+          $.identifier,
+          $.index,
+          $.logic,
+          $.math,
+          $.value,
+          $.yield,
+        ),
+      ),
+
+    _expression_list: $ =>
+      repeat1(
+        prec.right(
+          seq(
+            $.expression,
+            optional(","),
+          ),
+        ),
+      ),
+
+    identifier: $ =>
+      /[_a-zA-Z]+[_a-zA-Z0-9]?/,
+
+    value: $ =>
+      choice(
+        $.integer,
+        $.float,
+        $.string,
+        $.boolean,
+        $.list,
+        $.function,
+        $.table,
+        $.map,
+      ),
+
+    integer: $ =>
+      token(
+        prec.left(
+          seq(
+            optional("-"),
+            repeat1(
+              choice(
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                "0",
+              ),
+            ),
+          ),
+        ),
+      ),
+
+    float: $ =>
+      token(
+        prec.left(
+          seq(
+            optional("-"),
+            repeat1(
+              choice(
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                "0",
+              ),
+            ),
+            ".",
+            repeat1(
+              choice(
+                "1",
+                "2",
+                "3",
+                "4",
+                "5",
+                "6",
+                "7",
+                "8",
+                "9",
+                "0",
+              ),
+            ),
+          ),
+        ),
+      ),
+
+    string: $ =>
+      /("[^"]*?")|('[^']*?')|(`[^`]*?`)/,
+
+    boolean: $ =>
+      choice("true", "false"),
+
+    list: $ =>
+      seq(
+        "[",
+        repeat(
+          prec.left(
+            seq(
+              $.expression,
+              optional(","),
+            ),
+          ),
+        ),
+        "]",
+      ),
+
+    map: $ =>
+      seq(
+        "{",
+        repeat(
+          seq(
+            $.identifier,
+            "=",
+            $.statement,
+            optional(","),
+          ),
+        ),
+        "}",
+      ),
+
+    index: $ =>
+      prec.left(
+        1,
+        seq(
+          $.expression,
+          ":",
+          $.expression,
+          optional(
+            seq("..", $.expression),
+          ),
+        ),
+      ),
+
+    math: $ =>
+      prec.left(
+        seq(
+          $.expression,
+          $.math_operator,
+          $.expression,
+        ),
+      ),
+
+    math_operator: $ =>
+      choice("+", "-", "*", "/", "%"),
+
+    logic: $ =>
+      prec.right(
+        seq(
+          $.expression,
+          $.logic_operator,
+          $.expression,
+        ),
+      ),
+
+    logic_operator: $ =>
+      choice(
+        "==",
+        "!=",
+        "&&",
+        "||",
+        ">",
+        "<",
+        ">=",
+        "<=",
+      ),
+
+    assignment: $ =>
+      seq(
+        field(
+          "identifier",
+          $.identifier,
+        ),
+        optional(
+          field(
+            "type",
+            $.type_definition,
+          ),
+        ),
+        field(
+          "assignment_operator",
+          $.assignment_operator,
+        ),
+        field("statement", $.statement),
+      ),
+
+    index_assignment: $ =>
+      seq(
+        $.index,
+        $.assignment_operator,
+        $.statement,
+      ),
+
+    assignment_operator: $ =>
+      prec.right(
+        choice("=", "+=", "-="),
+      ),
+
+    if_else: $ =>
+      prec.right(
+        seq(
+          $.if,
+          repeat($.else_if),
+          optional($.else),
+        ),
+      ),
+
+    if: $ =>
+      seq("if", $.expression, $.block),
+
+    else_if: $ =>
+      seq(
+        "else if",
+        $.expression,
+        $.block,
+      ),
+
+    else: $ => seq("else", $.block),
+
+    match: $ =>
+      prec.right(
+        seq(
+          "match",
+          $.expression,
+          repeat1(
+            seq(
+              $.expression,
+              "=>",
+              $.block,
+            ),
+          ),
+        ),
+      ),
+
+    while: $ =>
+      seq(
+        "while",
+        $.expression,
+        $.block,
+      ),
+
+    for: $ =>
+      seq(
+        choice("for", "async for"),
+        $.identifier,
+        "in",
+        $.expression,
+        $.block,
+      ),
+
+    identifier_list: $ =>
+      prec.right(
+        choice(
+          seq(
+            "|",
+            repeat(
+              seq(
+                $.identifier,
+                optional(","),
+              ),
+            ),
+            "|",
+          ),
+        ),
+      ),
+
+    table: $ =>
+      prec.right(
+        seq(
+          "table",
+          $.identifier_list,
+          $.expression,
+        ),
+      ),
+
+    return: $ =>
+      seq("return", $.expression),
+
+    use: $ => seq("use", $.string),
+
+    type_definition: $ =>
+      seq("<", $.type, ">"),
+
+    type: $ =>
+      prec.right(
+        choice(
+          "any",
+          "bool",
+          seq(
+            "fn",
+            repeat(
+              seq(
+                $.type,
+                optional(","),
+              ),
+            ),
+            optional(seq("->", $.type)),
+          ),
+          "int",
+          seq("list", $.type),
+          "map",
+          "num",
+          "str",
+        ),
+      ),
+
+    function: $ =>
+      seq(
+        "|",
+        repeat(
+          seq(
+            $.identifier,
+            optional(","),
+          ),
+        ),
+        "|",
+        $.block,
+      ),
+
+    function_call: $ =>
+      prec.right(
+        1,
+        seq(
+          "(",
+          $.expression,
+          optional($._expression_list),
+          ")",
+        ),
+      ),
+
+    yield: $ =>
+      prec.left(
+        seq(
+          $.expression,
+          "->",
+          "(",
+          $.expression,
+          optional($._expression_list),
+          ")",
+        ),
+      ),
+  },
+});
diff --git a/tree-sitter-dust/package-lock.json b/tree-sitter-dust/package-lock.json
index dfb2b16..0d60385 100644
--- a/tree-sitter-dust/package-lock.json
+++ b/tree-sitter-dust/package-lock.json
@@ -7,11 +7,12 @@
     "": {
       "name": "tree-sitter-dust",
       "version": "1.0.0",
-      "license": "ISC",
+      "license": "MIT",
       "dependencies": {
         "nan": "^2.18.0"
       },
       "devDependencies": {
+        "prettier": "3.1.0",
         "tree-sitter-cli": "^0.20.8"
       }
     },
@@ -20,6 +21,21 @@
       "resolved": "https://registry.npmjs.org/nan/-/nan-2.18.0.tgz",
       "integrity": "sha512-W7tfG7vMOGtD30sHoZSSc/JVYiyDPEyQVso/Zz+/uQd0B0L46gtC+pHha5FFMRpil6fm/AoEcRWyOVi4+E/f8w=="
     },
+    "node_modules/prettier": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.1.0.tgz",
+      "integrity": "sha512-TQLvXjq5IAibjh8EpBIkNKxO749UEWABoiIZehEPiY4GNpVdhaFKqSTu+QrlU6D2dPAfubRmtJTi4K4YkQ5eXw==",
+      "dev": true,
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
     "node_modules/tree-sitter-cli": {
       "version": "0.20.8",
       "resolved": "https://registry.npmjs.org/tree-sitter-cli/-/tree-sitter-cli-0.20.8.tgz",
diff --git a/tree-sitter-dust/package.json b/tree-sitter-dust/package.json
index a4c22a1..7c319c0 100644
--- a/tree-sitter-dust/package.json
+++ b/tree-sitter-dust/package.json
@@ -18,6 +18,7 @@
     "nan": "^2.18.0"
   },
   "devDependencies": {
+    "prettier": "3.1.0",
     "tree-sitter-cli": "^0.20.8"
   },
   "main": "bindings/node"
diff --git a/tree-sitter-dust/src/grammar.json b/tree-sitter-dust/src/grammar.json
index f26cc0e..97cba82 100644
--- a/tree-sitter-dust/src/grammar.json
+++ b/tree-sitter-dust/src/grammar.json
@@ -82,10 +82,6 @@
                 "type": "SYMBOL",
                 "name": "index_assignment"
               },
-              {
-                "type": "SYMBOL",
-                "name": "insert"
-              },
               {
                 "type": "SYMBOL",
                 "name": "match"
@@ -94,10 +90,6 @@
                 "type": "SYMBOL",
                 "name": "return"
               },
-              {
-                "type": "SYMBOL",
-                "name": "select"
-              },
               {
                 "type": "SYMBOL",
                 "name": "use"
@@ -723,7 +715,7 @@
               "name": "type",
               "content": {
                 "type": "SYMBOL",
-                "name": "type"
+                "name": "type_definition"
               }
             },
             {
@@ -954,68 +946,6 @@
         }
       ]
     },
-    "select": {
-      "type": "PREC_RIGHT",
-      "value": 0,
-      "content": {
-        "type": "SEQ",
-        "members": [
-          {
-            "type": "STRING",
-            "value": "select"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "identifier_list"
-          },
-          {
-            "type": "STRING",
-            "value": "from"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "expression"
-          },
-          {
-            "type": "CHOICE",
-            "members": [
-              {
-                "type": "SYMBOL",
-                "name": "block"
-              },
-              {
-                "type": "BLANK"
-              }
-            ]
-          }
-        ]
-      }
-    },
-    "insert": {
-      "type": "PREC_RIGHT",
-      "value": 0,
-      "content": {
-        "type": "SEQ",
-        "members": [
-          {
-            "type": "STRING",
-            "value": "insert"
-          },
-          {
-            "type": "STRING",
-            "value": "into"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "identifier"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "expression"
-          }
-        ]
-      }
-    },
     "identifier_list": {
       "type": "PREC_RIGHT",
       "value": 0,
@@ -1109,7 +1039,7 @@
         }
       ]
     },
-    "type": {
+    "type_definition": {
       "type": "SEQ",
       "members": [
         {
@@ -1117,41 +1047,8 @@
           "value": "<"
         },
         {
-          "type": "CHOICE",
-          "members": [
-            {
-              "type": "STRING",
-              "value": "any"
-            },
-            {
-              "type": "STRING",
-              "value": "bool"
-            },
-            {
-              "type": "STRING",
-              "value": "fn"
-            },
-            {
-              "type": "STRING",
-              "value": "int"
-            },
-            {
-              "type": "STRING",
-              "value": "list"
-            },
-            {
-              "type": "STRING",
-              "value": "map"
-            },
-            {
-              "type": "STRING",
-              "value": "str"
-            },
-            {
-              "type": "STRING",
-              "value": "table"
-            }
-          ]
+          "type": "SYMBOL",
+          "name": "type"
         },
         {
           "type": "STRING",
@@ -1159,6 +1056,89 @@
         }
       ]
     },
+    "type": {
+      "type": "PREC_RIGHT",
+      "value": 0,
+      "content": {
+        "type": "CHOICE",
+        "members": [
+          {
+            "type": "STRING",
+            "value": "any"
+          },
+          {
+            "type": "STRING",
+            "value": "bool"
+          },
+          {
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "STRING",
+                "value": "fn"
+              },
+              {
+                "type": "REPEAT",
+                "content": {
+                  "type": "SYMBOL",
+                  "name": "type"
+                }
+              },
+              {
+                "type": "CHOICE",
+                "members": [
+                  {
+                    "type": "SEQ",
+                    "members": [
+                      {
+                        "type": "STRING",
+                        "value": "->"
+                      },
+                      {
+                        "type": "SYMBOL",
+                        "name": "type"
+                      }
+                    ]
+                  },
+                  {
+                    "type": "BLANK"
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            "type": "STRING",
+            "value": "int"
+          },
+          {
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "STRING",
+                "value": "list"
+              },
+              {
+                "type": "SYMBOL",
+                "name": "type"
+              }
+            ]
+          },
+          {
+            "type": "STRING",
+            "value": "map"
+          },
+          {
+            "type": "STRING",
+            "value": "num"
+          },
+          {
+            "type": "STRING",
+            "value": "str"
+          }
+        ]
+      }
+    },
     "function": {
       "type": "SEQ",
       "members": [
@@ -1169,57 +1149,37 @@
         {
           "type": "REPEAT",
           "content": {
-            "type": "SYMBOL",
-            "name": "parameter"
+            "type": "SEQ",
+            "members": [
+              {
+                "type": "SYMBOL",
+                "name": "identifier"
+              },
+              {
+                "type": "CHOICE",
+                "members": [
+                  {
+                    "type": "STRING",
+                    "value": ","
+                  },
+                  {
+                    "type": "BLANK"
+                  }
+                ]
+              }
+            ]
           }
         },
         {
           "type": "STRING",
           "value": "|"
         },
-        {
-          "type": "CHOICE",
-          "members": [
-            {
-              "type": "SYMBOL",
-              "name": "type"
-            },
-            {
-              "type": "BLANK"
-            }
-          ]
-        },
         {
           "type": "SYMBOL",
           "name": "block"
         }
       ]
     },
-    "parameter": {
-      "type": "SEQ",
-      "members": [
-        {
-          "type": "SYMBOL",
-          "name": "identifier"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "type"
-        },
-        {
-          "type": "CHOICE",
-          "members": [
-            {
-              "type": "STRING",
-              "value": ","
-            },
-            {
-              "type": "BLANK"
-            }
-          ]
-        }
-      ]
-    },
     "function_call": {
       "type": "PREC_RIGHT",
       "value": 1,
diff --git a/tree-sitter-dust/src/node-types.json b/tree-sitter-dust/src/node-types.json
index c6cdfef..7b957e1 100644
--- a/tree-sitter-dust/src/node-types.json
+++ b/tree-sitter-dust/src/node-types.json
@@ -38,7 +38,7 @@
         "required": false,
         "types": [
           {
-            "type": "type",
+            "type": "type_definition",
             "named": true
           }
         ]
@@ -179,11 +179,7 @@
           "named": true
         },
         {
-          "type": "parameter",
-          "named": true
-        },
-        {
-          "type": "type",
+          "type": "identifier",
           "named": true
         }
       ]
@@ -299,25 +295,6 @@
       ]
     }
   },
-  {
-    "type": "insert",
-    "named": true,
-    "fields": {},
-    "children": {
-      "multiple": true,
-      "required": true,
-      "types": [
-        {
-          "type": "expression",
-          "named": true
-        },
-        {
-          "type": "identifier",
-          "named": true
-        }
-      ]
-    }
-  },
   {
     "type": "list",
     "named": true,
@@ -419,25 +396,6 @@
     "named": true,
     "fields": {}
   },
-  {
-    "type": "parameter",
-    "named": true,
-    "fields": {},
-    "children": {
-      "multiple": true,
-      "required": true,
-      "types": [
-        {
-          "type": "identifier",
-          "named": true
-        },
-        {
-          "type": "type",
-          "named": true
-        }
-      ]
-    }
-  },
   {
     "type": "return",
     "named": true,
@@ -468,29 +426,6 @@
       ]
     }
   },
-  {
-    "type": "select",
-    "named": true,
-    "fields": {},
-    "children": {
-      "multiple": true,
-      "required": true,
-      "types": [
-        {
-          "type": "block",
-          "named": true
-        },
-        {
-          "type": "expression",
-          "named": true
-        },
-        {
-          "type": "identifier_list",
-          "named": true
-        }
-      ]
-    }
-  },
   {
     "type": "statement",
     "named": true,
@@ -523,10 +458,6 @@
           "type": "index_assignment",
           "named": true
         },
-        {
-          "type": "insert",
-          "named": true
-        },
         {
           "type": "match",
           "named": true
@@ -535,10 +466,6 @@
           "type": "return",
           "named": true
         },
-        {
-          "type": "select",
-          "named": true
-        },
         {
           "type": "use",
           "named": true
@@ -572,7 +499,32 @@
   {
     "type": "type",
     "named": true,
-    "fields": {}
+    "fields": {},
+    "children": {
+      "multiple": true,
+      "required": false,
+      "types": [
+        {
+          "type": "type",
+          "named": true
+        }
+      ]
+    }
+  },
+  {
+    "type": "type_definition",
+    "named": true,
+    "fields": {},
+    "children": {
+      "multiple": false,
+      "required": true,
+      "types": [
+        {
+          "type": "type",
+          "named": true
+        }
+      ]
+    }
   },
   {
     "type": "use",
@@ -806,10 +758,6 @@
     "type": "for",
     "named": false
   },
-  {
-    "type": "from",
-    "named": false
-  },
   {
     "type": "identifier",
     "named": true
@@ -822,10 +770,6 @@
     "type": "in",
     "named": false
   },
-  {
-    "type": "insert",
-    "named": false
-  },
   {
     "type": "int",
     "named": false
@@ -834,10 +778,6 @@
     "type": "integer",
     "named": true
   },
-  {
-    "type": "into",
-    "named": false
-  },
   {
     "type": "list",
     "named": false
@@ -851,11 +791,11 @@
     "named": false
   },
   {
-    "type": "return",
+    "type": "num",
     "named": false
   },
   {
-    "type": "select",
+    "type": "return",
     "named": false
   },
   {
diff --git a/tree-sitter-dust/src/parser.c b/tree-sitter-dust/src/parser.c
index bd9139b..8c92d1b 100644
--- a/tree-sitter-dust/src/parser.c
+++ b/tree-sitter-dust/src/parser.c
@@ -6,11 +6,11 @@
 #endif
 
 #define LANGUAGE_VERSION 14
-#define STATE_COUNT 385
+#define STATE_COUNT 362
 #define LARGE_STATE_COUNT 2
-#define SYMBOL_COUNT 103
+#define SYMBOL_COUNT 98
 #define ALIAS_COUNT 0
-#define TOKEN_COUNT 60
+#define TOKEN_COUNT 57
 #define EXTERNAL_TOKEN_COUNT 0
 #define FIELD_COUNT 4
 #define MAX_ALIAS_SEQUENCE_LENGTH 6
@@ -60,65 +60,60 @@ enum {
   anon_sym_for = 41,
   anon_sym_asyncfor = 42,
   anon_sym_in = 43,
-  anon_sym_select = 44,
-  anon_sym_from = 45,
-  anon_sym_insert = 46,
-  anon_sym_into = 47,
-  anon_sym_PIPE = 48,
-  anon_sym_table = 49,
-  anon_sym_return = 50,
-  anon_sym_use = 51,
-  anon_sym_any = 52,
-  anon_sym_bool = 53,
-  anon_sym_fn = 54,
-  anon_sym_int = 55,
-  anon_sym_list = 56,
-  anon_sym_map = 57,
-  anon_sym_str = 58,
-  anon_sym_DASH_GT = 59,
-  sym_root = 60,
-  sym_block = 61,
-  sym_statement = 62,
-  sym_expression = 63,
-  sym__expression_kind = 64,
-  aux_sym__expression_list = 65,
-  sym_value = 66,
-  sym_boolean = 67,
-  sym_list = 68,
-  sym_map = 69,
-  sym_index = 70,
-  sym_math = 71,
-  sym_math_operator = 72,
-  sym_logic = 73,
-  sym_logic_operator = 74,
-  sym_assignment = 75,
-  sym_index_assignment = 76,
-  sym_assignment_operator = 77,
-  sym_if_else = 78,
-  sym_if = 79,
-  sym_else_if = 80,
-  sym_else = 81,
-  sym_match = 82,
-  sym_while = 83,
-  sym_for = 84,
-  sym_select = 85,
-  sym_insert = 86,
-  sym_identifier_list = 87,
-  sym_table = 88,
-  sym_return = 89,
-  sym_use = 90,
-  sym_type = 91,
-  sym_function = 92,
-  sym_parameter = 93,
-  sym_function_call = 94,
-  sym_yield = 95,
-  aux_sym_root_repeat1 = 96,
-  aux_sym_list_repeat1 = 97,
-  aux_sym_map_repeat1 = 98,
-  aux_sym_if_else_repeat1 = 99,
-  aux_sym_match_repeat1 = 100,
-  aux_sym_identifier_list_repeat1 = 101,
-  aux_sym_function_repeat1 = 102,
+  anon_sym_PIPE = 44,
+  anon_sym_table = 45,
+  anon_sym_return = 46,
+  anon_sym_use = 47,
+  anon_sym_any = 48,
+  anon_sym_bool = 49,
+  anon_sym_fn = 50,
+  anon_sym_DASH_GT = 51,
+  anon_sym_int = 52,
+  anon_sym_list = 53,
+  anon_sym_map = 54,
+  anon_sym_num = 55,
+  anon_sym_str = 56,
+  sym_root = 57,
+  sym_block = 58,
+  sym_statement = 59,
+  sym_expression = 60,
+  sym__expression_kind = 61,
+  aux_sym__expression_list = 62,
+  sym_value = 63,
+  sym_boolean = 64,
+  sym_list = 65,
+  sym_map = 66,
+  sym_index = 67,
+  sym_math = 68,
+  sym_math_operator = 69,
+  sym_logic = 70,
+  sym_logic_operator = 71,
+  sym_assignment = 72,
+  sym_index_assignment = 73,
+  sym_assignment_operator = 74,
+  sym_if_else = 75,
+  sym_if = 76,
+  sym_else_if = 77,
+  sym_else = 78,
+  sym_match = 79,
+  sym_while = 80,
+  sym_for = 81,
+  sym_identifier_list = 82,
+  sym_table = 83,
+  sym_return = 84,
+  sym_use = 85,
+  sym_type_definition = 86,
+  sym_type = 87,
+  sym_function = 88,
+  sym_function_call = 89,
+  sym_yield = 90,
+  aux_sym_root_repeat1 = 91,
+  aux_sym_list_repeat1 = 92,
+  aux_sym_map_repeat1 = 93,
+  aux_sym_if_else_repeat1 = 94,
+  aux_sym_match_repeat1 = 95,
+  aux_sym_identifier_list_repeat1 = 96,
+  aux_sym_type_repeat1 = 97,
 };
 
 static const char * const ts_symbol_names[] = {
@@ -166,10 +161,6 @@ static const char * const ts_symbol_names[] = {
   [anon_sym_for] = "for",
   [anon_sym_asyncfor] = "async for",
   [anon_sym_in] = "in",
-  [anon_sym_select] = "select",
-  [anon_sym_from] = "from",
-  [anon_sym_insert] = "insert",
-  [anon_sym_into] = "into",
   [anon_sym_PIPE] = "|",
   [anon_sym_table] = "table",
   [anon_sym_return] = "return",
@@ -177,11 +168,12 @@ static const char * const ts_symbol_names[] = {
   [anon_sym_any] = "any",
   [anon_sym_bool] = "bool",
   [anon_sym_fn] = "fn",
+  [anon_sym_DASH_GT] = "->",
   [anon_sym_int] = "int",
   [anon_sym_list] = "list",
   [anon_sym_map] = "map",
+  [anon_sym_num] = "num",
   [anon_sym_str] = "str",
-  [anon_sym_DASH_GT] = "->",
   [sym_root] = "root",
   [sym_block] = "block",
   [sym_statement] = "statement",
@@ -207,15 +199,13 @@ static const char * const ts_symbol_names[] = {
   [sym_match] = "match",
   [sym_while] = "while",
   [sym_for] = "for",
-  [sym_select] = "select",
-  [sym_insert] = "insert",
   [sym_identifier_list] = "identifier_list",
   [sym_table] = "table",
   [sym_return] = "return",
   [sym_use] = "use",
+  [sym_type_definition] = "type_definition",
   [sym_type] = "type",
   [sym_function] = "function",
-  [sym_parameter] = "parameter",
   [sym_function_call] = "function_call",
   [sym_yield] = "yield",
   [aux_sym_root_repeat1] = "root_repeat1",
@@ -224,7 +214,7 @@ static const char * const ts_symbol_names[] = {
   [aux_sym_if_else_repeat1] = "if_else_repeat1",
   [aux_sym_match_repeat1] = "match_repeat1",
   [aux_sym_identifier_list_repeat1] = "identifier_list_repeat1",
-  [aux_sym_function_repeat1] = "function_repeat1",
+  [aux_sym_type_repeat1] = "type_repeat1",
 };
 
 static const TSSymbol ts_symbol_map[] = {
@@ -272,10 +262,6 @@ static const TSSymbol ts_symbol_map[] = {
   [anon_sym_for] = anon_sym_for,
   [anon_sym_asyncfor] = anon_sym_asyncfor,
   [anon_sym_in] = anon_sym_in,
-  [anon_sym_select] = anon_sym_select,
-  [anon_sym_from] = anon_sym_from,
-  [anon_sym_insert] = anon_sym_insert,
-  [anon_sym_into] = anon_sym_into,
   [anon_sym_PIPE] = anon_sym_PIPE,
   [anon_sym_table] = anon_sym_table,
   [anon_sym_return] = anon_sym_return,
@@ -283,11 +269,12 @@ static const TSSymbol ts_symbol_map[] = {
   [anon_sym_any] = anon_sym_any,
   [anon_sym_bool] = anon_sym_bool,
   [anon_sym_fn] = anon_sym_fn,
+  [anon_sym_DASH_GT] = anon_sym_DASH_GT,
   [anon_sym_int] = anon_sym_int,
   [anon_sym_list] = anon_sym_list,
   [anon_sym_map] = anon_sym_map,
+  [anon_sym_num] = anon_sym_num,
   [anon_sym_str] = anon_sym_str,
-  [anon_sym_DASH_GT] = anon_sym_DASH_GT,
   [sym_root] = sym_root,
   [sym_block] = sym_block,
   [sym_statement] = sym_statement,
@@ -313,15 +300,13 @@ static const TSSymbol ts_symbol_map[] = {
   [sym_match] = sym_match,
   [sym_while] = sym_while,
   [sym_for] = sym_for,
-  [sym_select] = sym_select,
-  [sym_insert] = sym_insert,
   [sym_identifier_list] = sym_identifier_list,
   [sym_table] = sym_table,
   [sym_return] = sym_return,
   [sym_use] = sym_use,
+  [sym_type_definition] = sym_type_definition,
   [sym_type] = sym_type,
   [sym_function] = sym_function,
-  [sym_parameter] = sym_parameter,
   [sym_function_call] = sym_function_call,
   [sym_yield] = sym_yield,
   [aux_sym_root_repeat1] = aux_sym_root_repeat1,
@@ -330,7 +315,7 @@ static const TSSymbol ts_symbol_map[] = {
   [aux_sym_if_else_repeat1] = aux_sym_if_else_repeat1,
   [aux_sym_match_repeat1] = aux_sym_match_repeat1,
   [aux_sym_identifier_list_repeat1] = aux_sym_identifier_list_repeat1,
-  [aux_sym_function_repeat1] = aux_sym_function_repeat1,
+  [aux_sym_type_repeat1] = aux_sym_type_repeat1,
 };
 
 static const TSSymbolMetadata ts_symbol_metadata[] = {
@@ -510,22 +495,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = false,
   },
-  [anon_sym_select] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_from] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_insert] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_into] = {
-    .visible = true,
-    .named = false,
-  },
   [anon_sym_PIPE] = {
     .visible = true,
     .named = false,
@@ -554,6 +523,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = false,
   },
+  [anon_sym_DASH_GT] = {
+    .visible = true,
+    .named = false,
+  },
   [anon_sym_int] = {
     .visible = true,
     .named = false,
@@ -566,11 +539,11 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = false,
   },
-  [anon_sym_str] = {
+  [anon_sym_num] = {
     .visible = true,
     .named = false,
   },
-  [anon_sym_DASH_GT] = {
+  [anon_sym_str] = {
     .visible = true,
     .named = false,
   },
@@ -674,14 +647,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = true,
   },
-  [sym_select] = {
-    .visible = true,
-    .named = true,
-  },
-  [sym_insert] = {
-    .visible = true,
-    .named = true,
-  },
   [sym_identifier_list] = {
     .visible = true,
     .named = true,
@@ -698,6 +663,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = true,
   },
+  [sym_type_definition] = {
+    .visible = true,
+    .named = true,
+  },
   [sym_type] = {
     .visible = true,
     .named = true,
@@ -706,10 +675,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = true,
   },
-  [sym_parameter] = {
-    .visible = true,
-    .named = true,
-  },
   [sym_function_call] = {
     .visible = true,
     .named = true,
@@ -742,7 +707,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = false,
     .named = false,
   },
-  [aux_sym_function_repeat1] = {
+  [aux_sym_type_repeat1] = {
     .visible = false,
     .named = false,
   },
@@ -795,385 +760,362 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = {
   [3] = 3,
   [4] = 2,
   [5] = 5,
-  [6] = 5,
-  [7] = 7,
-  [8] = 8,
-  [9] = 7,
-  [10] = 5,
-  [11] = 7,
-  [12] = 7,
-  [13] = 5,
+  [6] = 6,
+  [7] = 5,
+  [8] = 6,
+  [9] = 5,
+  [10] = 6,
+  [11] = 5,
+  [12] = 6,
+  [13] = 6,
   [14] = 5,
-  [15] = 7,
-  [16] = 5,
-  [17] = 7,
+  [15] = 5,
+  [16] = 6,
+  [17] = 17,
   [18] = 5,
-  [19] = 7,
+  [19] = 6,
   [20] = 20,
-  [21] = 21,
-  [22] = 21,
-  [23] = 21,
+  [21] = 20,
+  [22] = 22,
+  [23] = 20,
   [24] = 20,
-  [25] = 20,
-  [26] = 21,
-  [27] = 20,
-  [28] = 21,
-  [29] = 21,
+  [25] = 22,
+  [26] = 20,
+  [27] = 22,
+  [28] = 20,
+  [29] = 22,
   [30] = 20,
-  [31] = 21,
-  [32] = 20,
-  [33] = 20,
+  [31] = 22,
+  [32] = 22,
+  [33] = 22,
   [34] = 34,
   [35] = 35,
   [36] = 36,
-  [37] = 36,
+  [37] = 37,
   [38] = 38,
-  [39] = 39,
-  [40] = 39,
-  [41] = 38,
-  [42] = 42,
-  [43] = 43,
+  [39] = 38,
+  [40] = 34,
+  [41] = 41,
+  [42] = 35,
+  [43] = 37,
   [44] = 44,
   [45] = 44,
-  [46] = 46,
+  [46] = 41,
   [47] = 47,
-  [48] = 42,
-  [49] = 49,
-  [50] = 47,
-  [51] = 46,
-  [52] = 43,
-  [53] = 53,
+  [48] = 48,
+  [49] = 41,
+  [50] = 50,
+  [51] = 51,
+  [52] = 52,
+  [53] = 37,
   [54] = 54,
-  [55] = 55,
-  [56] = 56,
+  [55] = 54,
+  [56] = 52,
   [57] = 57,
-  [58] = 58,
-  [59] = 59,
-  [60] = 60,
+  [58] = 51,
+  [59] = 50,
+  [60] = 48,
   [61] = 61,
-  [62] = 61,
+  [62] = 62,
   [63] = 63,
   [64] = 64,
   [65] = 65,
   [66] = 66,
   [67] = 67,
   [68] = 68,
-  [69] = 61,
+  [69] = 69,
   [70] = 70,
   [71] = 71,
   [72] = 72,
   [73] = 73,
-  [74] = 55,
+  [74] = 74,
   [75] = 75,
-  [76] = 55,
+  [76] = 76,
   [77] = 77,
   [78] = 78,
   [79] = 79,
-  [80] = 79,
-  [81] = 81,
+  [80] = 80,
+  [81] = 80,
   [82] = 82,
-  [83] = 82,
-  [84] = 84,
-  [85] = 85,
-  [86] = 86,
-  [87] = 68,
-  [88] = 47,
-  [89] = 43,
-  [90] = 46,
-  [91] = 44,
-  [92] = 42,
-  [93] = 44,
-  [94] = 58,
-  [95] = 42,
-  [96] = 47,
-  [97] = 46,
-  [98] = 43,
-  [99] = 70,
-  [100] = 63,
-  [101] = 54,
-  [102] = 53,
-  [103] = 71,
-  [104] = 59,
-  [105] = 64,
-  [106] = 65,
+  [83] = 83,
+  [84] = 51,
+  [85] = 35,
+  [86] = 35,
+  [87] = 50,
+  [88] = 71,
+  [89] = 52,
+  [90] = 48,
+  [91] = 68,
+  [92] = 51,
+  [93] = 50,
+  [94] = 52,
+  [95] = 48,
+  [96] = 66,
+  [97] = 72,
+  [98] = 78,
+  [99] = 65,
+  [100] = 62,
+  [101] = 73,
+  [102] = 74,
+  [103] = 69,
+  [104] = 64,
+  [105] = 70,
+  [106] = 77,
   [107] = 67,
   [108] = 108,
-  [109] = 73,
-  [110] = 66,
-  [111] = 77,
-  [112] = 72,
-  [113] = 57,
+  [109] = 63,
+  [110] = 76,
+  [111] = 111,
+  [112] = 83,
+  [113] = 82,
   [114] = 114,
-  [115] = 60,
+  [115] = 115,
   [116] = 116,
-  [117] = 117,
-  [118] = 86,
+  [117] = 114,
+  [118] = 114,
   [119] = 119,
-  [120] = 85,
-  [121] = 44,
-  [122] = 122,
-  [123] = 122,
-  [124] = 43,
-  [125] = 42,
-  [126] = 122,
-  [127] = 44,
-  [128] = 46,
-  [129] = 47,
-  [130] = 130,
-  [131] = 131,
-  [132] = 71,
-  [133] = 70,
-  [134] = 53,
-  [135] = 64,
-  [136] = 65,
-  [137] = 137,
-  [138] = 130,
-  [139] = 47,
-  [140] = 73,
-  [141] = 141,
+  [120] = 69,
+  [121] = 121,
+  [122] = 63,
+  [123] = 72,
+  [124] = 62,
+  [125] = 125,
+  [126] = 126,
+  [127] = 127,
+  [128] = 119,
+  [129] = 121,
+  [130] = 126,
+  [131] = 126,
+  [132] = 127,
+  [133] = 119,
+  [134] = 65,
+  [135] = 135,
+  [136] = 76,
+  [137] = 73,
+  [138] = 67,
+  [139] = 121,
+  [140] = 78,
+  [141] = 70,
   [142] = 66,
-  [143] = 67,
-  [144] = 54,
-  [145] = 145,
-  [146] = 146,
-  [147] = 59,
-  [148] = 57,
-  [149] = 141,
-  [150] = 77,
-  [151] = 63,
-  [152] = 137,
-  [153] = 58,
-  [154] = 72,
-  [155] = 131,
-  [156] = 60,
-  [157] = 131,
+  [143] = 143,
+  [144] = 74,
+  [145] = 127,
+  [146] = 77,
+  [147] = 64,
+  [148] = 68,
+  [149] = 35,
+  [150] = 71,
+  [151] = 48,
+  [152] = 35,
+  [153] = 52,
+  [154] = 51,
+  [155] = 50,
+  [156] = 156,
+  [157] = 68,
   [158] = 158,
-  [159] = 141,
-  [160] = 137,
+  [159] = 159,
+  [160] = 160,
   [161] = 161,
-  [162] = 42,
-  [163] = 68,
-  [164] = 43,
-  [165] = 46,
-  [166] = 130,
-  [167] = 58,
-  [168] = 68,
-  [169] = 58,
-  [170] = 68,
-  [171] = 171,
-  [172] = 172,
-  [173] = 173,
-  [174] = 174,
-  [175] = 175,
-  [176] = 176,
-  [177] = 177,
-  [178] = 178,
+  [162] = 158,
+  [163] = 159,
+  [164] = 161,
+  [165] = 161,
+  [166] = 160,
+  [167] = 161,
+  [168] = 160,
+  [169] = 169,
+  [170] = 161,
+  [171] = 48,
+  [172] = 161,
+  [173] = 159,
+  [174] = 158,
+  [175] = 169,
+  [176] = 50,
+  [177] = 51,
+  [178] = 71,
   [179] = 179,
   [180] = 180,
-  [181] = 180,
-  [182] = 182,
-  [183] = 183,
-  [184] = 184,
-  [185] = 183,
+  [181] = 52,
+  [182] = 158,
+  [183] = 159,
+  [184] = 161,
+  [185] = 160,
   [186] = 179,
-  [187] = 178,
-  [188] = 78,
-  [189] = 180,
-  [190] = 178,
-  [191] = 184,
+  [187] = 187,
+  [188] = 188,
+  [189] = 189,
+  [190] = 188,
+  [191] = 191,
   [192] = 192,
-  [193] = 183,
-  [194] = 179,
-  [195] = 182,
-  [196] = 192,
-  [197] = 49,
-  [198] = 179,
-  [199] = 199,
-  [200] = 200,
-  [201] = 201,
-  [202] = 202,
-  [203] = 203,
-  [204] = 184,
-  [205] = 180,
-  [206] = 206,
-  [207] = 183,
-  [208] = 180,
-  [209] = 179,
-  [210] = 178,
-  [211] = 211,
-  [212] = 183,
-  [213] = 183,
-  [214] = 214,
-  [215] = 179,
-  [216] = 178,
-  [217] = 183,
-  [218] = 218,
-  [219] = 175,
-  [220] = 180,
-  [221] = 58,
-  [222] = 203,
-  [223] = 180,
-  [224] = 184,
+  [193] = 193,
+  [194] = 180,
+  [195] = 195,
+  [196] = 179,
+  [197] = 195,
+  [198] = 57,
+  [199] = 158,
+  [200] = 191,
+  [201] = 169,
+  [202] = 159,
+  [203] = 160,
+  [204] = 158,
+  [205] = 159,
+  [206] = 160,
+  [207] = 180,
+  [208] = 189,
+  [209] = 169,
+  [210] = 160,
+  [211] = 161,
+  [212] = 159,
+  [213] = 158,
+  [214] = 156,
+  [215] = 158,
+  [216] = 159,
+  [217] = 160,
+  [218] = 193,
+  [219] = 71,
+  [220] = 68,
+  [221] = 75,
+  [222] = 222,
+  [223] = 223,
+  [224] = 224,
   [225] = 225,
-  [226] = 180,
+  [226] = 226,
   [227] = 227,
-  [228] = 211,
-  [229] = 183,
-  [230] = 179,
-  [231] = 179,
-  [232] = 178,
-  [233] = 178,
-  [234] = 178,
-  [235] = 174,
-  [236] = 173,
-  [237] = 203,
-  [238] = 202,
-  [239] = 206,
-  [240] = 240,
-  [241] = 176,
-  [242] = 211,
-  [243] = 243,
-  [244] = 68,
-  [245] = 245,
-  [246] = 177,
-  [247] = 56,
-  [248] = 44,
-  [249] = 44,
-  [250] = 47,
-  [251] = 82,
-  [252] = 46,
-  [253] = 253,
-  [254] = 81,
-  [255] = 84,
-  [256] = 43,
-  [257] = 42,
-  [258] = 82,
+  [228] = 71,
+  [229] = 229,
+  [230] = 230,
+  [231] = 231,
+  [232] = 232,
+  [233] = 68,
+  [234] = 222,
+  [235] = 235,
+  [236] = 236,
+  [237] = 48,
+  [238] = 35,
+  [239] = 80,
+  [240] = 79,
+  [241] = 52,
+  [242] = 80,
+  [243] = 35,
+  [244] = 50,
+  [245] = 51,
+  [246] = 246,
+  [247] = 247,
+  [248] = 52,
+  [249] = 51,
+  [250] = 50,
+  [251] = 251,
+  [252] = 251,
+  [253] = 48,
+  [254] = 254,
+  [255] = 247,
+  [256] = 246,
+  [257] = 254,
+  [258] = 258,
   [259] = 259,
-  [260] = 42,
-  [261] = 261,
-  [262] = 47,
-  [263] = 263,
-  [264] = 261,
-  [265] = 43,
-  [266] = 46,
+  [260] = 259,
+  [261] = 71,
+  [262] = 68,
+  [263] = 226,
+  [264] = 264,
+  [265] = 265,
+  [266] = 266,
   [267] = 267,
-  [268] = 267,
-  [269] = 259,
-  [270] = 263,
+  [268] = 268,
+  [269] = 269,
+  [270] = 270,
   [271] = 271,
-  [272] = 271,
-  [273] = 201,
-  [274] = 68,
-  [275] = 58,
+  [272] = 272,
+  [273] = 273,
+  [274] = 274,
+  [275] = 275,
   [276] = 276,
   [277] = 277,
-  [278] = 278,
+  [278] = 116,
   [279] = 279,
   [280] = 280,
-  [281] = 281,
-  [282] = 116,
-  [283] = 117,
-  [284] = 284,
-  [285] = 285,
-  [286] = 119,
-  [287] = 145,
-  [288] = 161,
-  [289] = 289,
-  [290] = 290,
-  [291] = 289,
-  [292] = 290,
-  [293] = 289,
-  [294] = 290,
-  [295] = 289,
-  [296] = 290,
-  [297] = 297,
-  [298] = 298,
-  [299] = 299,
-  [300] = 299,
-  [301] = 298,
-  [302] = 182,
-  [303] = 182,
-  [304] = 199,
-  [305] = 200,
-  [306] = 214,
-  [307] = 172,
-  [308] = 171,
-  [309] = 227,
-  [310] = 240,
-  [311] = 243,
-  [312] = 312,
-  [313] = 299,
-  [314] = 299,
-  [315] = 245,
-  [316] = 312,
-  [317] = 225,
-  [318] = 218,
-  [319] = 312,
-  [320] = 312,
-  [321] = 321,
-  [322] = 321,
+  [281] = 115,
+  [282] = 282,
+  [283] = 143,
+  [284] = 192,
+  [285] = 187,
+  [286] = 286,
+  [287] = 222,
+  [288] = 223,
+  [289] = 222,
+  [290] = 225,
+  [291] = 227,
+  [292] = 230,
+  [293] = 224,
+  [294] = 232,
+  [295] = 229,
+  [296] = 236,
+  [297] = 231,
+  [298] = 235,
+  [299] = 286,
+  [300] = 300,
+  [301] = 301,
+  [302] = 302,
+  [303] = 303,
+  [304] = 304,
+  [305] = 305,
+  [306] = 306,
+  [307] = 307,
+  [308] = 308,
+  [309] = 309,
+  [310] = 300,
+  [311] = 300,
+  [312] = 307,
+  [313] = 307,
+  [314] = 308,
+  [315] = 301,
+  [316] = 304,
+  [317] = 317,
+  [318] = 306,
+  [319] = 308,
+  [320] = 301,
+  [321] = 305,
+  [322] = 317,
   [323] = 323,
   [324] = 324,
-  [325] = 325,
+  [325] = 317,
   [326] = 326,
-  [327] = 327,
+  [327] = 304,
   [328] = 328,
-  [329] = 325,
-  [330] = 327,
-  [331] = 331,
-  [332] = 332,
-  [333] = 331,
-  [334] = 332,
-  [335] = 321,
+  [329] = 301,
+  [330] = 317,
+  [331] = 304,
+  [332] = 308,
+  [333] = 333,
+  [334] = 333,
+  [335] = 333,
   [336] = 336,
-  [337] = 327,
-  [338] = 332,
-  [339] = 339,
-  [340] = 340,
-  [341] = 326,
-  [342] = 342,
-  [343] = 331,
-  [344] = 321,
-  [345] = 331,
+  [337] = 333,
+  [338] = 338,
+  [339] = 333,
+  [340] = 333,
+  [341] = 333,
+  [342] = 333,
+  [343] = 343,
+  [344] = 344,
+  [345] = 345,
   [346] = 346,
   [347] = 346,
   [348] = 346,
-  [349] = 349,
-  [350] = 346,
-  [351] = 349,
-  [352] = 346,
-  [353] = 353,
+  [349] = 346,
+  [350] = 344,
+  [351] = 351,
+  [352] = 343,
+  [353] = 346,
   [354] = 346,
-  [355] = 355,
-  [356] = 356,
+  [355] = 345,
+  [356] = 346,
   [357] = 357,
-  [358] = 346,
-  [359] = 346,
-  [360] = 360,
+  [358] = 358,
+  [359] = 344,
+  [360] = 357,
   [361] = 361,
-  [362] = 361,
-  [363] = 361,
-  [364] = 361,
-  [365] = 365,
-  [366] = 366,
-  [367] = 367,
-  [368] = 368,
-  [369] = 369,
-  [370] = 368,
-  [371] = 366,
-  [372] = 361,
-  [373] = 361,
-  [374] = 361,
-  [375] = 375,
-  [376] = 376,
-  [377] = 367,
-  [378] = 360,
-  [379] = 379,
-  [380] = 380,
-  [381] = 375,
-  [382] = 369,
-  [383] = 367,
-  [384] = 365,
 };
 
 static bool ts_lex(TSLexer *lexer, TSStateId state) {
@@ -1181,173 +1123,172 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
   eof = lexer->eof(lexer);
   switch (state) {
     case 0:
-      if (eof) ADVANCE(29);
+      if (eof) ADVANCE(30);
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '"') ADVANCE(7);
       if (lookahead == '#') ADVANCE(21);
-      if (lookahead == '%') ADVANCE(67);
+      if (lookahead == '%') ADVANCE(68);
       if (lookahead == '&') ADVANCE(8);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(35);
-      if (lookahead == ')') ADVANCE(36);
-      if (lookahead == '*') ADVANCE(65);
-      if (lookahead == '+') ADVANCE(60);
-      if (lookahead == ',') ADVANCE(37);
-      if (lookahead == '-') ADVANCE(63);
+      if (lookahead == '(') ADVANCE(36);
+      if (lookahead == ')') ADVANCE(37);
+      if (lookahead == '*') ADVANCE(66);
+      if (lookahead == '+') ADVANCE(61);
+      if (lookahead == ',') ADVANCE(38);
+      if (lookahead == '-') ADVANCE(64);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(66);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == ':') ADVANCE(57);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '<') ADVANCE(74);
-      if (lookahead == '=') ADVANCE(56);
-      if (lookahead == '>') ADVANCE(73);
-      if (lookahead == '[') ADVANCE(52);
-      if (lookahead == ']') ADVANCE(53);
+      if (lookahead == '/') ADVANCE(67);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == ':') ADVANCE(58);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '<') ADVANCE(75);
+      if (lookahead == '=') ADVANCE(57);
+      if (lookahead == '>') ADVANCE(74);
+      if (lookahead == '[') ADVANCE(53);
+      if (lookahead == ']') ADVANCE(54);
       if (lookahead == '`') ADVANCE(15);
-      if (lookahead == 'a') ADVANCE(45);
-      if (lookahead == 'e') ADVANCE(43);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(83);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == 'a') ADVANCE(46);
+      if (lookahead == 'e') ADVANCE(44);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(84);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(0)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 1:
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '"') ADVANCE(7);
       if (lookahead == '#') ADVANCE(21);
-      if (lookahead == '%') ADVANCE(67);
+      if (lookahead == '%') ADVANCE(68);
       if (lookahead == '&') ADVANCE(8);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(35);
-      if (lookahead == ')') ADVANCE(36);
-      if (lookahead == '*') ADVANCE(65);
-      if (lookahead == '+') ADVANCE(59);
-      if (lookahead == ',') ADVANCE(37);
-      if (lookahead == '-') ADVANCE(64);
+      if (lookahead == '(') ADVANCE(36);
+      if (lookahead == ')') ADVANCE(37);
+      if (lookahead == '*') ADVANCE(66);
+      if (lookahead == '+') ADVANCE(60);
+      if (lookahead == ',') ADVANCE(38);
+      if (lookahead == '-') ADVANCE(65);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(66);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == ':') ADVANCE(57);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '<') ADVANCE(74);
+      if (lookahead == '/') ADVANCE(67);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == ':') ADVANCE(58);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '<') ADVANCE(75);
       if (lookahead == '=') ADVANCE(13);
-      if (lookahead == '>') ADVANCE(73);
-      if (lookahead == '[') ADVANCE(52);
-      if (lookahead == ']') ADVANCE(53);
+      if (lookahead == '>') ADVANCE(74);
+      if (lookahead == '[') ADVANCE(53);
+      if (lookahead == ']') ADVANCE(54);
       if (lookahead == '`') ADVANCE(15);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(83);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(84);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(1)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 2:
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '#') ADVANCE(21);
-      if (lookahead == '%') ADVANCE(67);
+      if (lookahead == '%') ADVANCE(68);
       if (lookahead == '&') ADVANCE(8);
-      if (lookahead == '*') ADVANCE(65);
-      if (lookahead == '+') ADVANCE(60);
-      if (lookahead == ',') ADVANCE(37);
-      if (lookahead == '-') ADVANCE(61);
+      if (lookahead == '*') ADVANCE(66);
+      if (lookahead == '+') ADVANCE(61);
+      if (lookahead == ',') ADVANCE(38);
+      if (lookahead == '-') ADVANCE(62);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(66);
-      if (lookahead == ':') ADVANCE(57);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '<') ADVANCE(74);
-      if (lookahead == '=') ADVANCE(56);
-      if (lookahead == '>') ADVANCE(73);
-      if (lookahead == '{') ADVANCE(32);
+      if (lookahead == '/') ADVANCE(67);
+      if (lookahead == ':') ADVANCE(58);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '<') ADVANCE(75);
+      if (lookahead == '=') ADVANCE(57);
+      if (lookahead == '>') ADVANCE(74);
+      if (lookahead == '{') ADVANCE(33);
       if (lookahead == '|') ADVANCE(22);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(2)
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 3:
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '#') ADVANCE(21);
-      if (lookahead == '%') ADVANCE(67);
+      if (lookahead == '%') ADVANCE(68);
       if (lookahead == '&') ADVANCE(8);
-      if (lookahead == '*') ADVANCE(65);
-      if (lookahead == '+') ADVANCE(60);
-      if (lookahead == ',') ADVANCE(37);
-      if (lookahead == '-') ADVANCE(61);
+      if (lookahead == '*') ADVANCE(66);
+      if (lookahead == '+') ADVANCE(61);
+      if (lookahead == ',') ADVANCE(38);
+      if (lookahead == '-') ADVANCE(62);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(66);
-      if (lookahead == ':') ADVANCE(57);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '<') ADVANCE(74);
-      if (lookahead == '=') ADVANCE(55);
-      if (lookahead == '>') ADVANCE(73);
-      if (lookahead == '{') ADVANCE(32);
+      if (lookahead == '/') ADVANCE(67);
+      if (lookahead == ':') ADVANCE(58);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '<') ADVANCE(75);
+      if (lookahead == '=') ADVANCE(56);
+      if (lookahead == '>') ADVANCE(74);
       if (lookahead == '|') ADVANCE(22);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(3)
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 4:
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '#') ADVANCE(21);
-      if (lookahead == '%') ADVANCE(67);
+      if (lookahead == '%') ADVANCE(68);
       if (lookahead == '&') ADVANCE(8);
-      if (lookahead == '*') ADVANCE(65);
-      if (lookahead == '+') ADVANCE(59);
-      if (lookahead == ',') ADVANCE(37);
-      if (lookahead == '-') ADVANCE(62);
+      if (lookahead == '*') ADVANCE(66);
+      if (lookahead == '+') ADVANCE(60);
+      if (lookahead == ',') ADVANCE(38);
+      if (lookahead == '-') ADVANCE(63);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(66);
-      if (lookahead == ':') ADVANCE(57);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '<') ADVANCE(74);
+      if (lookahead == '/') ADVANCE(67);
+      if (lookahead == ':') ADVANCE(58);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '<') ADVANCE(75);
       if (lookahead == '=') ADVANCE(14);
-      if (lookahead == '>') ADVANCE(73);
-      if (lookahead == 'e') ADVANCE(43);
-      if (lookahead == '{') ADVANCE(32);
+      if (lookahead == '>') ADVANCE(74);
+      if (lookahead == 'e') ADVANCE(44);
+      if (lookahead == '{') ADVANCE(33);
       if (lookahead == '|') ADVANCE(22);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(4)
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 5:
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '#') ADVANCE(21);
-      if (lookahead == '%') ADVANCE(67);
+      if (lookahead == '%') ADVANCE(68);
       if (lookahead == '&') ADVANCE(8);
-      if (lookahead == '*') ADVANCE(65);
-      if (lookahead == '+') ADVANCE(59);
-      if (lookahead == '-') ADVANCE(62);
+      if (lookahead == '*') ADVANCE(66);
+      if (lookahead == '+') ADVANCE(60);
+      if (lookahead == '-') ADVANCE(63);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(66);
-      if (lookahead == ':') ADVANCE(57);
-      if (lookahead == '<') ADVANCE(74);
+      if (lookahead == '/') ADVANCE(67);
+      if (lookahead == ':') ADVANCE(58);
+      if (lookahead == '<') ADVANCE(75);
       if (lookahead == '=') ADVANCE(14);
-      if (lookahead == '>') ADVANCE(73);
-      if (lookahead == '{') ADVANCE(32);
+      if (lookahead == '>') ADVANCE(74);
+      if (lookahead == '{') ADVANCE(33);
       if (lookahead == '|') ADVANCE(22);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
@@ -1355,69 +1296,68 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
           lookahead == ' ') SKIP(5)
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 6:
       if (lookahead == '"') ADVANCE(7);
       if (lookahead == '#') ADVANCE(21);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(35);
-      if (lookahead == ')') ADVANCE(36);
-      if (lookahead == '+') ADVANCE(12);
-      if (lookahead == ',') ADVANCE(37);
-      if (lookahead == '-') ADVANCE(24);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '=') ADVANCE(54);
-      if (lookahead == '[') ADVANCE(52);
-      if (lookahead == ']') ADVANCE(53);
+      if (lookahead == '(') ADVANCE(36);
+      if (lookahead == ')') ADVANCE(37);
+      if (lookahead == ',') ADVANCE(38);
+      if (lookahead == '-') ADVANCE(25);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '>') ADVANCE(73);
+      if (lookahead == '[') ADVANCE(53);
+      if (lookahead == ']') ADVANCE(54);
       if (lookahead == '`') ADVANCE(15);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(82);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(83);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(6)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 7:
-      if (lookahead == '"') ADVANCE(51);
+      if (lookahead == '"') ADVANCE(52);
       if (lookahead != 0) ADVANCE(7);
       END_STATE();
     case 8:
-      if (lookahead == '&') ADVANCE(70);
+      if (lookahead == '&') ADVANCE(71);
       END_STATE();
     case 9:
-      if (lookahead == '\'') ADVANCE(51);
+      if (lookahead == '\'') ADVANCE(52);
       if (lookahead != 0) ADVANCE(9);
       END_STATE();
     case 10:
-      if (lookahead == '.') ADVANCE(58);
+      if (lookahead == '.') ADVANCE(59);
       END_STATE();
     case 11:
-      if (lookahead == '=') ADVANCE(69);
+      if (lookahead == '=') ADVANCE(70);
       END_STATE();
     case 12:
-      if (lookahead == '=') ADVANCE(77);
+      if (lookahead == '=') ADVANCE(78);
       END_STATE();
     case 13:
-      if (lookahead == '=') ADVANCE(68);
+      if (lookahead == '=') ADVANCE(69);
       END_STATE();
     case 14:
-      if (lookahead == '=') ADVANCE(68);
-      if (lookahead == '>') ADVANCE(80);
+      if (lookahead == '=') ADVANCE(69);
+      if (lookahead == '>') ADVANCE(81);
       END_STATE();
     case 15:
-      if (lookahead == '`') ADVANCE(51);
+      if (lookahead == '`') ADVANCE(52);
       if (lookahead != 0) ADVANCE(15);
       END_STATE();
     case 16:
       if (lookahead == 'f') ADVANCE(19);
       END_STATE();
     case 17:
-      if (lookahead == 'f') ADVANCE(79);
+      if (lookahead == 'f') ADVANCE(80);
       END_STATE();
     case 18:
       if (lookahead == 'i') ADVANCE(17);
@@ -1426,345 +1366,349 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
       if (lookahead == 'o') ADVANCE(20);
       END_STATE();
     case 20:
-      if (lookahead == 'r') ADVANCE(81);
+      if (lookahead == 'r') ADVANCE(82);
       END_STATE();
     case 21:
-      if (lookahead == '|') ADVANCE(31);
+      if (lookahead == '|') ADVANCE(32);
       if (lookahead == '\n' ||
-          lookahead == '#') ADVANCE(30);
+          lookahead == '#') ADVANCE(31);
       if (lookahead != 0) ADVANCE(21);
       END_STATE();
     case 22:
-      if (lookahead == '|') ADVANCE(71);
+      if (lookahead == '|') ADVANCE(72);
       END_STATE();
     case 23:
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
       END_STATE();
     case 24:
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == '=') ADVANCE(78);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == '=') ADVANCE(79);
       END_STATE();
     case 25:
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == '>') ADVANCE(85);
       END_STATE();
     case 26:
-      if (eof) ADVANCE(29);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(51);
+      END_STATE();
+    case 27:
+      if (eof) ADVANCE(30);
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '"') ADVANCE(7);
       if (lookahead == '#') ADVANCE(21);
-      if (lookahead == '%') ADVANCE(67);
+      if (lookahead == '%') ADVANCE(68);
       if (lookahead == '&') ADVANCE(8);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(35);
-      if (lookahead == '*') ADVANCE(65);
-      if (lookahead == '+') ADVANCE(60);
-      if (lookahead == '-') ADVANCE(63);
+      if (lookahead == '(') ADVANCE(36);
+      if (lookahead == '*') ADVANCE(66);
+      if (lookahead == '+') ADVANCE(61);
+      if (lookahead == '-') ADVANCE(64);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(66);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == ':') ADVANCE(57);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '<') ADVANCE(74);
-      if (lookahead == '=') ADVANCE(55);
-      if (lookahead == '>') ADVANCE(73);
-      if (lookahead == '[') ADVANCE(52);
+      if (lookahead == '/') ADVANCE(67);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == ':') ADVANCE(58);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '<') ADVANCE(75);
+      if (lookahead == '=') ADVANCE(56);
+      if (lookahead == '>') ADVANCE(74);
+      if (lookahead == '[') ADVANCE(53);
       if (lookahead == '`') ADVANCE(15);
-      if (lookahead == 'a') ADVANCE(45);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(83);
-      if (lookahead == '}') ADVANCE(33);
-      if (lookahead == '\t' ||
-          lookahead == '\n' ||
-          lookahead == '\r' ||
-          lookahead == ' ') SKIP(26)
-      if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(48);
-      END_STATE();
-    case 27:
-      if (eof) ADVANCE(29);
-      if (lookahead == '"') ADVANCE(7);
-      if (lookahead == '#') ADVANCE(21);
-      if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(35);
-      if (lookahead == '+') ADVANCE(12);
-      if (lookahead == '-') ADVANCE(24);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '=') ADVANCE(54);
-      if (lookahead == '>') ADVANCE(72);
-      if (lookahead == '[') ADVANCE(52);
-      if (lookahead == '`') ADVANCE(15);
-      if (lookahead == 'a') ADVANCE(45);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(82);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == 'a') ADVANCE(46);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(84);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(27)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 28:
-      if (eof) ADVANCE(29);
+      if (eof) ADVANCE(30);
       if (lookahead == '"') ADVANCE(7);
       if (lookahead == '#') ADVANCE(21);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(35);
-      if (lookahead == '-') ADVANCE(23);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == ';') ADVANCE(34);
-      if (lookahead == '[') ADVANCE(52);
+      if (lookahead == '(') ADVANCE(36);
+      if (lookahead == '+') ADVANCE(12);
+      if (lookahead == '-') ADVANCE(24);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '=') ADVANCE(55);
+      if (lookahead == '>') ADVANCE(73);
+      if (lookahead == '[') ADVANCE(53);
       if (lookahead == '`') ADVANCE(15);
-      if (lookahead == 'a') ADVANCE(45);
-      if (lookahead == 'e') ADVANCE(43);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(82);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == 'a') ADVANCE(46);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(83);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(28)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 29:
-      ACCEPT_TOKEN(ts_builtin_sym_end);
+      if (eof) ADVANCE(30);
+      if (lookahead == '"') ADVANCE(7);
+      if (lookahead == '#') ADVANCE(21);
+      if (lookahead == '\'') ADVANCE(9);
+      if (lookahead == '(') ADVANCE(36);
+      if (lookahead == '-') ADVANCE(23);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == ';') ADVANCE(35);
+      if (lookahead == '[') ADVANCE(53);
+      if (lookahead == '`') ADVANCE(15);
+      if (lookahead == 'a') ADVANCE(46);
+      if (lookahead == 'e') ADVANCE(44);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(83);
+      if (lookahead == '}') ADVANCE(34);
+      if (lookahead == '\t' ||
+          lookahead == '\n' ||
+          lookahead == '\r' ||
+          lookahead == ' ') SKIP(29)
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 30:
-      ACCEPT_TOKEN(sym__comment);
+      ACCEPT_TOKEN(ts_builtin_sym_end);
       END_STATE();
     case 31:
       ACCEPT_TOKEN(sym__comment);
-      if (lookahead == '|') ADVANCE(31);
-      if (lookahead == '\n' ||
-          lookahead == '#') ADVANCE(30);
-      if (lookahead != 0) ADVANCE(21);
       END_STATE();
     case 32:
-      ACCEPT_TOKEN(anon_sym_LBRACE);
+      ACCEPT_TOKEN(sym__comment);
+      if (lookahead == '|') ADVANCE(32);
+      if (lookahead == '\n' ||
+          lookahead == '#') ADVANCE(31);
+      if (lookahead != 0) ADVANCE(21);
       END_STATE();
     case 33:
-      ACCEPT_TOKEN(anon_sym_RBRACE);
+      ACCEPT_TOKEN(anon_sym_LBRACE);
       END_STATE();
     case 34:
-      ACCEPT_TOKEN(anon_sym_SEMI);
+      ACCEPT_TOKEN(anon_sym_RBRACE);
       END_STATE();
     case 35:
-      ACCEPT_TOKEN(anon_sym_LPAREN);
+      ACCEPT_TOKEN(anon_sym_SEMI);
       END_STATE();
     case 36:
-      ACCEPT_TOKEN(anon_sym_RPAREN);
+      ACCEPT_TOKEN(anon_sym_LPAREN);
       END_STATE();
     case 37:
-      ACCEPT_TOKEN(anon_sym_COMMA);
+      ACCEPT_TOKEN(anon_sym_RPAREN);
       END_STATE();
     case 38:
-      ACCEPT_TOKEN(sym_identifier);
+      ACCEPT_TOKEN(anon_sym_COMMA);
       END_STATE();
     case 39:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == ' ') ADVANCE(18);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
-      if (('A' <= lookahead && lookahead <= 'Z') ||
-          lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
       END_STATE();
     case 40:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == ' ') ADVANCE(16);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == ' ') ADVANCE(18);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 41:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == 'c') ADVANCE(40);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == ' ') ADVANCE(16);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 42:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == 'e') ADVANCE(39);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == 'c') ADVANCE(41);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 43:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == 'l') ADVANCE(46);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == 'e') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 44:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == 'n') ADVANCE(41);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == 'l') ADVANCE(47);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 45:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == 's') ADVANCE(47);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == 'n') ADVANCE(42);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 46:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == 's') ADVANCE(42);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == 's') ADVANCE(48);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 47:
       ACCEPT_TOKEN(sym_identifier);
-      if (lookahead == 'y') ADVANCE(44);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == 's') ADVANCE(43);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 48:
       ACCEPT_TOKEN(sym_identifier);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38);
+      if (lookahead == 'y') ADVANCE(45);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(48);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 49:
-      ACCEPT_TOKEN(sym_integer);
-      if (lookahead == '.') ADVANCE(25);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
+      ACCEPT_TOKEN(sym_identifier);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(49);
       END_STATE();
     case 50:
-      ACCEPT_TOKEN(sym_float);
+      ACCEPT_TOKEN(sym_integer);
+      if (lookahead == '.') ADVANCE(26);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
       END_STATE();
     case 51:
-      ACCEPT_TOKEN(sym_string);
+      ACCEPT_TOKEN(sym_float);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(51);
       END_STATE();
     case 52:
-      ACCEPT_TOKEN(anon_sym_LBRACK);
+      ACCEPT_TOKEN(sym_string);
       END_STATE();
     case 53:
-      ACCEPT_TOKEN(anon_sym_RBRACK);
+      ACCEPT_TOKEN(anon_sym_LBRACK);
       END_STATE();
     case 54:
-      ACCEPT_TOKEN(anon_sym_EQ);
+      ACCEPT_TOKEN(anon_sym_RBRACK);
       END_STATE();
     case 55:
       ACCEPT_TOKEN(anon_sym_EQ);
-      if (lookahead == '=') ADVANCE(68);
       END_STATE();
     case 56:
       ACCEPT_TOKEN(anon_sym_EQ);
-      if (lookahead == '=') ADVANCE(68);
-      if (lookahead == '>') ADVANCE(80);
+      if (lookahead == '=') ADVANCE(69);
       END_STATE();
     case 57:
-      ACCEPT_TOKEN(anon_sym_COLON);
+      ACCEPT_TOKEN(anon_sym_EQ);
+      if (lookahead == '=') ADVANCE(69);
+      if (lookahead == '>') ADVANCE(81);
       END_STATE();
     case 58:
-      ACCEPT_TOKEN(anon_sym_DOT_DOT);
+      ACCEPT_TOKEN(anon_sym_COLON);
       END_STATE();
     case 59:
-      ACCEPT_TOKEN(anon_sym_PLUS);
+      ACCEPT_TOKEN(anon_sym_DOT_DOT);
       END_STATE();
     case 60:
       ACCEPT_TOKEN(anon_sym_PLUS);
-      if (lookahead == '=') ADVANCE(77);
       END_STATE();
     case 61:
-      ACCEPT_TOKEN(anon_sym_DASH);
+      ACCEPT_TOKEN(anon_sym_PLUS);
       if (lookahead == '=') ADVANCE(78);
-      if (lookahead == '>') ADVANCE(84);
       END_STATE();
     case 62:
       ACCEPT_TOKEN(anon_sym_DASH);
-      if (lookahead == '>') ADVANCE(84);
+      if (lookahead == '=') ADVANCE(79);
+      if (lookahead == '>') ADVANCE(85);
       END_STATE();
     case 63:
       ACCEPT_TOKEN(anon_sym_DASH);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == '=') ADVANCE(78);
-      if (lookahead == '>') ADVANCE(84);
+      if (lookahead == '>') ADVANCE(85);
       END_STATE();
     case 64:
       ACCEPT_TOKEN(anon_sym_DASH);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(49);
-      if (lookahead == '>') ADVANCE(84);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == '=') ADVANCE(79);
+      if (lookahead == '>') ADVANCE(85);
       END_STATE();
     case 65:
-      ACCEPT_TOKEN(anon_sym_STAR);
+      ACCEPT_TOKEN(anon_sym_DASH);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(50);
+      if (lookahead == '>') ADVANCE(85);
       END_STATE();
     case 66:
-      ACCEPT_TOKEN(anon_sym_SLASH);
+      ACCEPT_TOKEN(anon_sym_STAR);
       END_STATE();
     case 67:
-      ACCEPT_TOKEN(anon_sym_PERCENT);
+      ACCEPT_TOKEN(anon_sym_SLASH);
       END_STATE();
     case 68:
-      ACCEPT_TOKEN(anon_sym_EQ_EQ);
+      ACCEPT_TOKEN(anon_sym_PERCENT);
       END_STATE();
     case 69:
-      ACCEPT_TOKEN(anon_sym_BANG_EQ);
+      ACCEPT_TOKEN(anon_sym_EQ_EQ);
       END_STATE();
     case 70:
-      ACCEPT_TOKEN(anon_sym_AMP_AMP);
+      ACCEPT_TOKEN(anon_sym_BANG_EQ);
       END_STATE();
     case 71:
-      ACCEPT_TOKEN(anon_sym_PIPE_PIPE);
+      ACCEPT_TOKEN(anon_sym_AMP_AMP);
       END_STATE();
     case 72:
-      ACCEPT_TOKEN(anon_sym_GT);
+      ACCEPT_TOKEN(anon_sym_PIPE_PIPE);
       END_STATE();
     case 73:
       ACCEPT_TOKEN(anon_sym_GT);
-      if (lookahead == '=') ADVANCE(75);
       END_STATE();
     case 74:
-      ACCEPT_TOKEN(anon_sym_LT);
+      ACCEPT_TOKEN(anon_sym_GT);
       if (lookahead == '=') ADVANCE(76);
       END_STATE();
     case 75:
-      ACCEPT_TOKEN(anon_sym_GT_EQ);
+      ACCEPT_TOKEN(anon_sym_LT);
+      if (lookahead == '=') ADVANCE(77);
       END_STATE();
     case 76:
-      ACCEPT_TOKEN(anon_sym_LT_EQ);
+      ACCEPT_TOKEN(anon_sym_GT_EQ);
       END_STATE();
     case 77:
-      ACCEPT_TOKEN(anon_sym_PLUS_EQ);
+      ACCEPT_TOKEN(anon_sym_LT_EQ);
       END_STATE();
     case 78:
-      ACCEPT_TOKEN(anon_sym_DASH_EQ);
+      ACCEPT_TOKEN(anon_sym_PLUS_EQ);
       END_STATE();
     case 79:
-      ACCEPT_TOKEN(anon_sym_elseif);
+      ACCEPT_TOKEN(anon_sym_DASH_EQ);
       END_STATE();
     case 80:
-      ACCEPT_TOKEN(anon_sym_EQ_GT);
+      ACCEPT_TOKEN(anon_sym_elseif);
       END_STATE();
     case 81:
-      ACCEPT_TOKEN(anon_sym_asyncfor);
+      ACCEPT_TOKEN(anon_sym_EQ_GT);
       END_STATE();
     case 82:
-      ACCEPT_TOKEN(anon_sym_PIPE);
+      ACCEPT_TOKEN(anon_sym_asyncfor);
       END_STATE();
     case 83:
       ACCEPT_TOKEN(anon_sym_PIPE);
-      if (lookahead == '|') ADVANCE(71);
       END_STATE();
     case 84:
+      ACCEPT_TOKEN(anon_sym_PIPE);
+      if (lookahead == '|') ADVANCE(72);
+      END_STATE();
+    case 85:
       ACCEPT_TOKEN(anon_sym_DASH_GT);
       END_STATE();
     default:
@@ -1784,31 +1728,31 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) {
       if (lookahead == 'i') ADVANCE(5);
       if (lookahead == 'l') ADVANCE(6);
       if (lookahead == 'm') ADVANCE(7);
-      if (lookahead == 'r') ADVANCE(8);
-      if (lookahead == 's') ADVANCE(9);
-      if (lookahead == 't') ADVANCE(10);
-      if (lookahead == 'u') ADVANCE(11);
-      if (lookahead == 'w') ADVANCE(12);
+      if (lookahead == 'n') ADVANCE(8);
+      if (lookahead == 'r') ADVANCE(9);
+      if (lookahead == 's') ADVANCE(10);
+      if (lookahead == 't') ADVANCE(11);
+      if (lookahead == 'u') ADVANCE(12);
+      if (lookahead == 'w') ADVANCE(13);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(0)
       END_STATE();
     case 1:
-      if (lookahead == 'n') ADVANCE(13);
-      if (lookahead == 's') ADVANCE(14);
+      if (lookahead == 'n') ADVANCE(14);
+      if (lookahead == 's') ADVANCE(15);
       END_STATE();
     case 2:
-      if (lookahead == 'o') ADVANCE(15);
+      if (lookahead == 'o') ADVANCE(16);
       END_STATE();
     case 3:
-      if (lookahead == 'l') ADVANCE(16);
+      if (lookahead == 'l') ADVANCE(17);
       END_STATE();
     case 4:
-      if (lookahead == 'a') ADVANCE(17);
-      if (lookahead == 'n') ADVANCE(18);
-      if (lookahead == 'o') ADVANCE(19);
-      if (lookahead == 'r') ADVANCE(20);
+      if (lookahead == 'a') ADVANCE(18);
+      if (lookahead == 'n') ADVANCE(19);
+      if (lookahead == 'o') ADVANCE(20);
       END_STATE();
     case 5:
       if (lookahead == 'f') ADVANCE(21);
@@ -1821,215 +1765,182 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) {
       if (lookahead == 'a') ADVANCE(24);
       END_STATE();
     case 8:
-      if (lookahead == 'e') ADVANCE(25);
+      if (lookahead == 'u') ADVANCE(25);
       END_STATE();
     case 9:
       if (lookahead == 'e') ADVANCE(26);
-      if (lookahead == 't') ADVANCE(27);
       END_STATE();
     case 10:
+      if (lookahead == 't') ADVANCE(27);
+      END_STATE();
+    case 11:
       if (lookahead == 'a') ADVANCE(28);
       if (lookahead == 'r') ADVANCE(29);
       END_STATE();
-    case 11:
+    case 12:
       if (lookahead == 's') ADVANCE(30);
       END_STATE();
-    case 12:
+    case 13:
       if (lookahead == 'h') ADVANCE(31);
       END_STATE();
-    case 13:
+    case 14:
       if (lookahead == 'y') ADVANCE(32);
       END_STATE();
-    case 14:
+    case 15:
       if (lookahead == 'y') ADVANCE(33);
       END_STATE();
-    case 15:
+    case 16:
       if (lookahead == 'o') ADVANCE(34);
       END_STATE();
-    case 16:
+    case 17:
       if (lookahead == 's') ADVANCE(35);
       END_STATE();
-    case 17:
+    case 18:
       if (lookahead == 'l') ADVANCE(36);
       END_STATE();
-    case 18:
+    case 19:
       ACCEPT_TOKEN(anon_sym_fn);
       END_STATE();
-    case 19:
-      if (lookahead == 'r') ADVANCE(37);
-      END_STATE();
     case 20:
-      if (lookahead == 'o') ADVANCE(38);
+      if (lookahead == 'r') ADVANCE(37);
       END_STATE();
     case 21:
       ACCEPT_TOKEN(anon_sym_if);
       END_STATE();
     case 22:
       ACCEPT_TOKEN(anon_sym_in);
-      if (lookahead == 's') ADVANCE(39);
-      if (lookahead == 't') ADVANCE(40);
+      if (lookahead == 't') ADVANCE(38);
       END_STATE();
     case 23:
-      if (lookahead == 's') ADVANCE(41);
+      if (lookahead == 's') ADVANCE(39);
       END_STATE();
     case 24:
-      if (lookahead == 'p') ADVANCE(42);
-      if (lookahead == 't') ADVANCE(43);
+      if (lookahead == 'p') ADVANCE(40);
+      if (lookahead == 't') ADVANCE(41);
       END_STATE();
     case 25:
-      if (lookahead == 't') ADVANCE(44);
+      if (lookahead == 'm') ADVANCE(42);
       END_STATE();
     case 26:
-      if (lookahead == 'l') ADVANCE(45);
+      if (lookahead == 't') ADVANCE(43);
       END_STATE();
     case 27:
-      if (lookahead == 'r') ADVANCE(46);
+      if (lookahead == 'r') ADVANCE(44);
       END_STATE();
     case 28:
-      if (lookahead == 'b') ADVANCE(47);
+      if (lookahead == 'b') ADVANCE(45);
       END_STATE();
     case 29:
-      if (lookahead == 'u') ADVANCE(48);
+      if (lookahead == 'u') ADVANCE(46);
       END_STATE();
     case 30:
-      if (lookahead == 'e') ADVANCE(49);
+      if (lookahead == 'e') ADVANCE(47);
       END_STATE();
     case 31:
-      if (lookahead == 'i') ADVANCE(50);
+      if (lookahead == 'i') ADVANCE(48);
       END_STATE();
     case 32:
       ACCEPT_TOKEN(anon_sym_any);
       END_STATE();
     case 33:
-      if (lookahead == 'n') ADVANCE(51);
+      if (lookahead == 'n') ADVANCE(49);
       END_STATE();
     case 34:
-      if (lookahead == 'l') ADVANCE(52);
+      if (lookahead == 'l') ADVANCE(50);
       END_STATE();
     case 35:
-      if (lookahead == 'e') ADVANCE(53);
+      if (lookahead == 'e') ADVANCE(51);
       END_STATE();
     case 36:
-      if (lookahead == 's') ADVANCE(54);
+      if (lookahead == 's') ADVANCE(52);
       END_STATE();
     case 37:
       ACCEPT_TOKEN(anon_sym_for);
       END_STATE();
     case 38:
-      if (lookahead == 'm') ADVANCE(55);
+      ACCEPT_TOKEN(anon_sym_int);
       END_STATE();
     case 39:
-      if (lookahead == 'e') ADVANCE(56);
+      if (lookahead == 't') ADVANCE(53);
       END_STATE();
     case 40:
-      ACCEPT_TOKEN(anon_sym_int);
-      if (lookahead == 'o') ADVANCE(57);
-      END_STATE();
-    case 41:
-      if (lookahead == 't') ADVANCE(58);
-      END_STATE();
-    case 42:
       ACCEPT_TOKEN(anon_sym_map);
       END_STATE();
+    case 41:
+      if (lookahead == 'c') ADVANCE(54);
+      END_STATE();
+    case 42:
+      ACCEPT_TOKEN(anon_sym_num);
+      END_STATE();
     case 43:
-      if (lookahead == 'c') ADVANCE(59);
+      if (lookahead == 'u') ADVANCE(55);
       END_STATE();
     case 44:
-      if (lookahead == 'u') ADVANCE(60);
-      END_STATE();
-    case 45:
-      if (lookahead == 'e') ADVANCE(61);
-      END_STATE();
-    case 46:
       ACCEPT_TOKEN(anon_sym_str);
       END_STATE();
+    case 45:
+      if (lookahead == 'l') ADVANCE(56);
+      END_STATE();
+    case 46:
+      if (lookahead == 'e') ADVANCE(57);
+      END_STATE();
     case 47:
-      if (lookahead == 'l') ADVANCE(62);
-      END_STATE();
-    case 48:
-      if (lookahead == 'e') ADVANCE(63);
-      END_STATE();
-    case 49:
       ACCEPT_TOKEN(anon_sym_use);
       END_STATE();
+    case 48:
+      if (lookahead == 'l') ADVANCE(58);
+      END_STATE();
+    case 49:
+      if (lookahead == 'c') ADVANCE(59);
+      END_STATE();
     case 50:
-      if (lookahead == 'l') ADVANCE(64);
-      END_STATE();
-    case 51:
-      if (lookahead == 'c') ADVANCE(65);
-      END_STATE();
-    case 52:
       ACCEPT_TOKEN(anon_sym_bool);
       END_STATE();
-    case 53:
+    case 51:
       ACCEPT_TOKEN(anon_sym_else);
       END_STATE();
-    case 54:
-      if (lookahead == 'e') ADVANCE(66);
+    case 52:
+      if (lookahead == 'e') ADVANCE(60);
       END_STATE();
-    case 55:
-      ACCEPT_TOKEN(anon_sym_from);
-      END_STATE();
-    case 56:
-      if (lookahead == 'r') ADVANCE(67);
-      END_STATE();
-    case 57:
-      ACCEPT_TOKEN(anon_sym_into);
-      END_STATE();
-    case 58:
+    case 53:
       ACCEPT_TOKEN(anon_sym_list);
       END_STATE();
-    case 59:
-      if (lookahead == 'h') ADVANCE(68);
+    case 54:
+      if (lookahead == 'h') ADVANCE(61);
       END_STATE();
-    case 60:
-      if (lookahead == 'r') ADVANCE(69);
+    case 55:
+      if (lookahead == 'r') ADVANCE(62);
       END_STATE();
-    case 61:
-      if (lookahead == 'c') ADVANCE(70);
+    case 56:
+      if (lookahead == 'e') ADVANCE(63);
       END_STATE();
-    case 62:
-      if (lookahead == 'e') ADVANCE(71);
-      END_STATE();
-    case 63:
+    case 57:
       ACCEPT_TOKEN(anon_sym_true);
       END_STATE();
-    case 64:
-      if (lookahead == 'e') ADVANCE(72);
+    case 58:
+      if (lookahead == 'e') ADVANCE(64);
       END_STATE();
-    case 65:
+    case 59:
       ACCEPT_TOKEN(anon_sym_async);
       END_STATE();
-    case 66:
+    case 60:
       ACCEPT_TOKEN(anon_sym_false);
       END_STATE();
-    case 67:
-      if (lookahead == 't') ADVANCE(73);
-      END_STATE();
-    case 68:
+    case 61:
       ACCEPT_TOKEN(anon_sym_match);
       END_STATE();
-    case 69:
-      if (lookahead == 'n') ADVANCE(74);
+    case 62:
+      if (lookahead == 'n') ADVANCE(65);
       END_STATE();
-    case 70:
-      if (lookahead == 't') ADVANCE(75);
-      END_STATE();
-    case 71:
+    case 63:
       ACCEPT_TOKEN(anon_sym_table);
       END_STATE();
-    case 72:
+    case 64:
       ACCEPT_TOKEN(anon_sym_while);
       END_STATE();
-    case 73:
-      ACCEPT_TOKEN(anon_sym_insert);
-      END_STATE();
-    case 74:
+    case 65:
       ACCEPT_TOKEN(anon_sym_return);
       END_STATE();
-    case 75:
-      ACCEPT_TOKEN(anon_sym_select);
-      END_STATE();
     default:
       return false;
   }
@@ -2037,92 +1948,92 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) {
 
 static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [0] = {.lex_state = 0},
-  [1] = {.lex_state = 27},
-  [2] = {.lex_state = 27},
-  [3] = {.lex_state = 27},
-  [4] = {.lex_state = 27},
-  [5] = {.lex_state = 27},
-  [6] = {.lex_state = 27},
-  [7] = {.lex_state = 27},
-  [8] = {.lex_state = 27},
-  [9] = {.lex_state = 27},
-  [10] = {.lex_state = 27},
-  [11] = {.lex_state = 27},
-  [12] = {.lex_state = 27},
-  [13] = {.lex_state = 27},
-  [14] = {.lex_state = 27},
-  [15] = {.lex_state = 27},
-  [16] = {.lex_state = 27},
-  [17] = {.lex_state = 27},
-  [18] = {.lex_state = 27},
-  [19] = {.lex_state = 27},
-  [20] = {.lex_state = 27},
-  [21] = {.lex_state = 27},
-  [22] = {.lex_state = 27},
-  [23] = {.lex_state = 27},
-  [24] = {.lex_state = 27},
-  [25] = {.lex_state = 27},
-  [26] = {.lex_state = 27},
-  [27] = {.lex_state = 27},
-  [28] = {.lex_state = 27},
-  [29] = {.lex_state = 27},
-  [30] = {.lex_state = 27},
-  [31] = {.lex_state = 27},
-  [32] = {.lex_state = 27},
-  [33] = {.lex_state = 27},
-  [34] = {.lex_state = 27},
+  [1] = {.lex_state = 28},
+  [2] = {.lex_state = 28},
+  [3] = {.lex_state = 28},
+  [4] = {.lex_state = 28},
+  [5] = {.lex_state = 28},
+  [6] = {.lex_state = 28},
+  [7] = {.lex_state = 28},
+  [8] = {.lex_state = 28},
+  [9] = {.lex_state = 28},
+  [10] = {.lex_state = 28},
+  [11] = {.lex_state = 28},
+  [12] = {.lex_state = 28},
+  [13] = {.lex_state = 28},
+  [14] = {.lex_state = 28},
+  [15] = {.lex_state = 28},
+  [16] = {.lex_state = 28},
+  [17] = {.lex_state = 28},
+  [18] = {.lex_state = 28},
+  [19] = {.lex_state = 28},
+  [20] = {.lex_state = 28},
+  [21] = {.lex_state = 28},
+  [22] = {.lex_state = 28},
+  [23] = {.lex_state = 28},
+  [24] = {.lex_state = 28},
+  [25] = {.lex_state = 28},
+  [26] = {.lex_state = 28},
+  [27] = {.lex_state = 28},
+  [28] = {.lex_state = 28},
+  [29] = {.lex_state = 28},
+  [30] = {.lex_state = 28},
+  [31] = {.lex_state = 28},
+  [32] = {.lex_state = 28},
+  [33] = {.lex_state = 28},
+  [34] = {.lex_state = 28},
   [35] = {.lex_state = 27},
-  [36] = {.lex_state = 27},
-  [37] = {.lex_state = 27},
-  [38] = {.lex_state = 27},
-  [39] = {.lex_state = 27},
-  [40] = {.lex_state = 27},
-  [41] = {.lex_state = 27},
-  [42] = {.lex_state = 26},
-  [43] = {.lex_state = 26},
-  [44] = {.lex_state = 26},
-  [45] = {.lex_state = 26},
-  [46] = {.lex_state = 26},
-  [47] = {.lex_state = 26},
-  [48] = {.lex_state = 26},
-  [49] = {.lex_state = 26},
-  [50] = {.lex_state = 26},
-  [51] = {.lex_state = 26},
-  [52] = {.lex_state = 26},
-  [53] = {.lex_state = 26},
-  [54] = {.lex_state = 26},
+  [36] = {.lex_state = 28},
+  [37] = {.lex_state = 1},
+  [38] = {.lex_state = 28},
+  [39] = {.lex_state = 28},
+  [40] = {.lex_state = 28},
+  [41] = {.lex_state = 1},
+  [42] = {.lex_state = 27},
+  [43] = {.lex_state = 1},
+  [44] = {.lex_state = 28},
+  [45] = {.lex_state = 28},
+  [46] = {.lex_state = 1},
+  [47] = {.lex_state = 28},
+  [48] = {.lex_state = 27},
+  [49] = {.lex_state = 1},
+  [50] = {.lex_state = 27},
+  [51] = {.lex_state = 27},
+  [52] = {.lex_state = 27},
+  [53] = {.lex_state = 1},
+  [54] = {.lex_state = 1},
   [55] = {.lex_state = 1},
-  [56] = {.lex_state = 26},
-  [57] = {.lex_state = 26},
-  [58] = {.lex_state = 26},
-  [59] = {.lex_state = 26},
-  [60] = {.lex_state = 26},
-  [61] = {.lex_state = 1},
-  [62] = {.lex_state = 1},
-  [63] = {.lex_state = 26},
-  [64] = {.lex_state = 26},
-  [65] = {.lex_state = 26},
-  [66] = {.lex_state = 26},
-  [67] = {.lex_state = 26},
-  [68] = {.lex_state = 26},
-  [69] = {.lex_state = 1},
-  [70] = {.lex_state = 26},
-  [71] = {.lex_state = 26},
-  [72] = {.lex_state = 26},
-  [73] = {.lex_state = 26},
-  [74] = {.lex_state = 1},
-  [75] = {.lex_state = 26},
-  [76] = {.lex_state = 1},
-  [77] = {.lex_state = 26},
-  [78] = {.lex_state = 26},
-  [79] = {.lex_state = 1},
-  [80] = {.lex_state = 1},
-  [81] = {.lex_state = 26},
-  [82] = {.lex_state = 26},
-  [83] = {.lex_state = 26},
-  [84] = {.lex_state = 26},
-  [85] = {.lex_state = 27},
-  [86] = {.lex_state = 27},
+  [56] = {.lex_state = 27},
+  [57] = {.lex_state = 27},
+  [58] = {.lex_state = 27},
+  [59] = {.lex_state = 27},
+  [60] = {.lex_state = 27},
+  [61] = {.lex_state = 27},
+  [62] = {.lex_state = 27},
+  [63] = {.lex_state = 27},
+  [64] = {.lex_state = 27},
+  [65] = {.lex_state = 27},
+  [66] = {.lex_state = 27},
+  [67] = {.lex_state = 27},
+  [68] = {.lex_state = 27},
+  [69] = {.lex_state = 27},
+  [70] = {.lex_state = 27},
+  [71] = {.lex_state = 27},
+  [72] = {.lex_state = 27},
+  [73] = {.lex_state = 27},
+  [74] = {.lex_state = 27},
+  [75] = {.lex_state = 27},
+  [76] = {.lex_state = 27},
+  [77] = {.lex_state = 27},
+  [78] = {.lex_state = 27},
+  [79] = {.lex_state = 27},
+  [80] = {.lex_state = 27},
+  [81] = {.lex_state = 27},
+  [82] = {.lex_state = 28},
+  [83] = {.lex_state = 28},
+  [84] = {.lex_state = 1},
+  [85] = {.lex_state = 1},
+  [86] = {.lex_state = 1},
   [87] = {.lex_state = 1},
   [88] = {.lex_state = 1},
   [89] = {.lex_state = 1},
@@ -2148,96 +2059,96 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [109] = {.lex_state = 1},
   [110] = {.lex_state = 1},
   [111] = {.lex_state = 1},
-  [112] = {.lex_state = 1},
-  [113] = {.lex_state = 1},
+  [112] = {.lex_state = 6},
+  [113] = {.lex_state = 6},
   [114] = {.lex_state = 1},
-  [115] = {.lex_state = 1},
-  [116] = {.lex_state = 28},
-  [117] = {.lex_state = 28},
-  [118] = {.lex_state = 6},
-  [119] = {.lex_state = 28},
-  [120] = {.lex_state = 6},
-  [121] = {.lex_state = 3},
-  [122] = {.lex_state = 1},
-  [123] = {.lex_state = 1},
-  [124] = {.lex_state = 3},
-  [125] = {.lex_state = 3},
-  [126] = {.lex_state = 1},
-  [127] = {.lex_state = 3},
-  [128] = {.lex_state = 3},
-  [129] = {.lex_state = 3},
+  [115] = {.lex_state = 29},
+  [116] = {.lex_state = 29},
+  [117] = {.lex_state = 1},
+  [118] = {.lex_state = 1},
+  [119] = {.lex_state = 6},
+  [120] = {.lex_state = 2},
+  [121] = {.lex_state = 6},
+  [122] = {.lex_state = 2},
+  [123] = {.lex_state = 2},
+  [124] = {.lex_state = 2},
+  [125] = {.lex_state = 6},
+  [126] = {.lex_state = 6},
+  [127] = {.lex_state = 6},
+  [128] = {.lex_state = 6},
+  [129] = {.lex_state = 6},
   [130] = {.lex_state = 6},
   [131] = {.lex_state = 6},
-  [132] = {.lex_state = 2},
-  [133] = {.lex_state = 2},
+  [132] = {.lex_state = 6},
+  [133] = {.lex_state = 6},
   [134] = {.lex_state = 2},
-  [135] = {.lex_state = 2},
+  [135] = {.lex_state = 6},
   [136] = {.lex_state = 2},
-  [137] = {.lex_state = 6},
-  [138] = {.lex_state = 6},
-  [139] = {.lex_state = 3},
+  [137] = {.lex_state = 2},
+  [138] = {.lex_state = 2},
+  [139] = {.lex_state = 6},
   [140] = {.lex_state = 2},
-  [141] = {.lex_state = 6},
+  [141] = {.lex_state = 2},
   [142] = {.lex_state = 2},
-  [143] = {.lex_state = 2},
+  [143] = {.lex_state = 29},
   [144] = {.lex_state = 2},
-  [145] = {.lex_state = 28},
-  [146] = {.lex_state = 6},
+  [145] = {.lex_state = 6},
+  [146] = {.lex_state = 2},
   [147] = {.lex_state = 2},
-  [148] = {.lex_state = 2},
-  [149] = {.lex_state = 6},
-  [150] = {.lex_state = 2},
-  [151] = {.lex_state = 2},
-  [152] = {.lex_state = 6},
-  [153] = {.lex_state = 28},
-  [154] = {.lex_state = 2},
-  [155] = {.lex_state = 6},
-  [156] = {.lex_state = 2},
-  [157] = {.lex_state = 6},
+  [148] = {.lex_state = 4},
+  [149] = {.lex_state = 3},
+  [150] = {.lex_state = 4},
+  [151] = {.lex_state = 3},
+  [152] = {.lex_state = 3},
+  [153] = {.lex_state = 3},
+  [154] = {.lex_state = 3},
+  [155] = {.lex_state = 3},
+  [156] = {.lex_state = 6},
+  [157] = {.lex_state = 29},
   [158] = {.lex_state = 6},
   [159] = {.lex_state = 6},
   [160] = {.lex_state = 6},
-  [161] = {.lex_state = 28},
-  [162] = {.lex_state = 3},
-  [163] = {.lex_state = 28},
-  [164] = {.lex_state = 3},
-  [165] = {.lex_state = 3},
+  [161] = {.lex_state = 6},
+  [162] = {.lex_state = 6},
+  [163] = {.lex_state = 6},
+  [164] = {.lex_state = 6},
+  [165] = {.lex_state = 6},
   [166] = {.lex_state = 6},
-  [167] = {.lex_state = 3},
-  [168] = {.lex_state = 3},
-  [169] = {.lex_state = 4},
-  [170] = {.lex_state = 4},
-  [171] = {.lex_state = 27},
-  [172] = {.lex_state = 27},
+  [167] = {.lex_state = 6},
+  [168] = {.lex_state = 6},
+  [169] = {.lex_state = 6},
+  [170] = {.lex_state = 6},
+  [171] = {.lex_state = 3},
+  [172] = {.lex_state = 6},
   [173] = {.lex_state = 6},
   [174] = {.lex_state = 6},
   [175] = {.lex_state = 6},
-  [176] = {.lex_state = 6},
-  [177] = {.lex_state = 6},
-  [178] = {.lex_state = 6},
+  [176] = {.lex_state = 3},
+  [177] = {.lex_state = 3},
+  [178] = {.lex_state = 29},
   [179] = {.lex_state = 6},
   [180] = {.lex_state = 6},
-  [181] = {.lex_state = 6},
-  [182] = {.lex_state = 27},
+  [181] = {.lex_state = 3},
+  [182] = {.lex_state = 6},
   [183] = {.lex_state = 6},
   [184] = {.lex_state = 6},
   [185] = {.lex_state = 6},
   [186] = {.lex_state = 6},
-  [187] = {.lex_state = 6},
-  [188] = {.lex_state = 3},
+  [187] = {.lex_state = 29},
+  [188] = {.lex_state = 6},
   [189] = {.lex_state = 6},
   [190] = {.lex_state = 6},
   [191] = {.lex_state = 6},
-  [192] = {.lex_state = 6},
+  [192] = {.lex_state = 29},
   [193] = {.lex_state = 6},
   [194] = {.lex_state = 6},
-  [195] = {.lex_state = 27},
+  [195] = {.lex_state = 6},
   [196] = {.lex_state = 6},
-  [197] = {.lex_state = 3},
-  [198] = {.lex_state = 6},
-  [199] = {.lex_state = 27},
-  [200] = {.lex_state = 27},
-  [201] = {.lex_state = 27},
+  [197] = {.lex_state = 6},
+  [198] = {.lex_state = 3},
+  [199] = {.lex_state = 6},
+  [200] = {.lex_state = 6},
+  [201] = {.lex_state = 6},
   [202] = {.lex_state = 6},
   [203] = {.lex_state = 6},
   [204] = {.lex_state = 6},
@@ -2250,81 +2161,81 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [211] = {.lex_state = 6},
   [212] = {.lex_state = 6},
   [213] = {.lex_state = 6},
-  [214] = {.lex_state = 27},
+  [214] = {.lex_state = 6},
   [215] = {.lex_state = 6},
   [216] = {.lex_state = 6},
   [217] = {.lex_state = 6},
-  [218] = {.lex_state = 27},
-  [219] = {.lex_state = 6},
-  [220] = {.lex_state = 6},
-  [221] = {.lex_state = 27},
-  [222] = {.lex_state = 6},
-  [223] = {.lex_state = 6},
-  [224] = {.lex_state = 6},
-  [225] = {.lex_state = 27},
-  [226] = {.lex_state = 6},
-  [227] = {.lex_state = 27},
-  [228] = {.lex_state = 6},
-  [229] = {.lex_state = 6},
-  [230] = {.lex_state = 6},
-  [231] = {.lex_state = 6},
-  [232] = {.lex_state = 6},
-  [233] = {.lex_state = 6},
-  [234] = {.lex_state = 6},
-  [235] = {.lex_state = 6},
-  [236] = {.lex_state = 6},
-  [237] = {.lex_state = 6},
-  [238] = {.lex_state = 6},
-  [239] = {.lex_state = 6},
-  [240] = {.lex_state = 27},
-  [241] = {.lex_state = 6},
-  [242] = {.lex_state = 6},
-  [243] = {.lex_state = 27},
-  [244] = {.lex_state = 27},
-  [245] = {.lex_state = 27},
-  [246] = {.lex_state = 6},
-  [247] = {.lex_state = 3},
+  [218] = {.lex_state = 6},
+  [219] = {.lex_state = 3},
+  [220] = {.lex_state = 3},
+  [221] = {.lex_state = 3},
+  [222] = {.lex_state = 28},
+  [223] = {.lex_state = 28},
+  [224] = {.lex_state = 28},
+  [225] = {.lex_state = 28},
+  [226] = {.lex_state = 28},
+  [227] = {.lex_state = 28},
+  [228] = {.lex_state = 28},
+  [229] = {.lex_state = 28},
+  [230] = {.lex_state = 28},
+  [231] = {.lex_state = 28},
+  [232] = {.lex_state = 28},
+  [233] = {.lex_state = 28},
+  [234] = {.lex_state = 28},
+  [235] = {.lex_state = 28},
+  [236] = {.lex_state = 28},
+  [237] = {.lex_state = 5},
+  [238] = {.lex_state = 5},
+  [239] = {.lex_state = 2},
+  [240] = {.lex_state = 2},
+  [241] = {.lex_state = 5},
+  [242] = {.lex_state = 2},
+  [243] = {.lex_state = 5},
+  [244] = {.lex_state = 5},
+  [245] = {.lex_state = 5},
+  [246] = {.lex_state = 2},
+  [247] = {.lex_state = 2},
   [248] = {.lex_state = 5},
   [249] = {.lex_state = 5},
   [250] = {.lex_state = 5},
-  [251] = {.lex_state = 3},
-  [252] = {.lex_state = 5},
-  [253] = {.lex_state = 27},
-  [254] = {.lex_state = 3},
-  [255] = {.lex_state = 3},
-  [256] = {.lex_state = 5},
-  [257] = {.lex_state = 5},
-  [258] = {.lex_state = 3},
-  [259] = {.lex_state = 3},
-  [260] = {.lex_state = 5},
-  [261] = {.lex_state = 3},
-  [262] = {.lex_state = 5},
-  [263] = {.lex_state = 3},
-  [264] = {.lex_state = 3},
-  [265] = {.lex_state = 5},
-  [266] = {.lex_state = 5},
-  [267] = {.lex_state = 3},
-  [268] = {.lex_state = 3},
-  [269] = {.lex_state = 3},
-  [270] = {.lex_state = 3},
-  [271] = {.lex_state = 4},
-  [272] = {.lex_state = 4},
+  [251] = {.lex_state = 2},
+  [252] = {.lex_state = 2},
+  [253] = {.lex_state = 5},
+  [254] = {.lex_state = 2},
+  [255] = {.lex_state = 2},
+  [256] = {.lex_state = 2},
+  [257] = {.lex_state = 2},
+  [258] = {.lex_state = 28},
+  [259] = {.lex_state = 4},
+  [260] = {.lex_state = 4},
+  [261] = {.lex_state = 6},
+  [262] = {.lex_state = 6},
+  [263] = {.lex_state = 6},
+  [264] = {.lex_state = 6},
+  [265] = {.lex_state = 6},
+  [266] = {.lex_state = 6},
+  [267] = {.lex_state = 6},
+  [268] = {.lex_state = 6},
+  [269] = {.lex_state = 6},
+  [270] = {.lex_state = 6},
+  [271] = {.lex_state = 6},
+  [272] = {.lex_state = 6},
   [273] = {.lex_state = 6},
   [274] = {.lex_state = 6},
   [275] = {.lex_state = 6},
   [276] = {.lex_state = 6},
-  [277] = {.lex_state = 6},
-  [278] = {.lex_state = 6},
-  [279] = {.lex_state = 6},
-  [280] = {.lex_state = 6},
-  [281] = {.lex_state = 6},
-  [282] = {.lex_state = 4},
+  [277] = {.lex_state = 1},
+  [278] = {.lex_state = 4},
+  [279] = {.lex_state = 1},
+  [280] = {.lex_state = 1},
+  [281] = {.lex_state = 4},
+  [282] = {.lex_state = 1},
   [283] = {.lex_state = 4},
-  [284] = {.lex_state = 1},
-  [285] = {.lex_state = 6},
-  [286] = {.lex_state = 4},
-  [287] = {.lex_state = 4},
-  [288] = {.lex_state = 4},
+  [284] = {.lex_state = 4},
+  [285] = {.lex_state = 4},
+  [286] = {.lex_state = 28},
+  [287] = {.lex_state = 1},
+  [288] = {.lex_state = 1},
   [289] = {.lex_state = 1},
   [290] = {.lex_state = 1},
   [291] = {.lex_state = 1},
@@ -2333,94 +2244,71 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [294] = {.lex_state = 1},
   [295] = {.lex_state = 1},
   [296] = {.lex_state = 1},
-  [297] = {.lex_state = 6},
-  [298] = {.lex_state = 27},
-  [299] = {.lex_state = 6},
-  [300] = {.lex_state = 6},
-  [301] = {.lex_state = 27},
-  [302] = {.lex_state = 1},
+  [297] = {.lex_state = 1},
+  [298] = {.lex_state = 1},
+  [299] = {.lex_state = 28},
+  [300] = {.lex_state = 1},
+  [301] = {.lex_state = 1},
+  [302] = {.lex_state = 28},
   [303] = {.lex_state = 1},
-  [304] = {.lex_state = 1},
+  [304] = {.lex_state = 6},
   [305] = {.lex_state = 1},
   [306] = {.lex_state = 1},
   [307] = {.lex_state = 1},
-  [308] = {.lex_state = 1},
+  [308] = {.lex_state = 6},
   [309] = {.lex_state = 1},
   [310] = {.lex_state = 1},
   [311] = {.lex_state = 1},
-  [312] = {.lex_state = 6},
-  [313] = {.lex_state = 6},
+  [312] = {.lex_state = 1},
+  [313] = {.lex_state = 1},
   [314] = {.lex_state = 6},
   [315] = {.lex_state = 1},
   [316] = {.lex_state = 6},
   [317] = {.lex_state = 1},
   [318] = {.lex_state = 1},
   [319] = {.lex_state = 6},
-  [320] = {.lex_state = 6},
+  [320] = {.lex_state = 1},
   [321] = {.lex_state = 1},
   [322] = {.lex_state = 1},
   [323] = {.lex_state = 6},
   [324] = {.lex_state = 6},
   [325] = {.lex_state = 1},
-  [326] = {.lex_state = 1},
-  [327] = {.lex_state = 1},
-  [328] = {.lex_state = 1},
+  [326] = {.lex_state = 6},
+  [327] = {.lex_state = 6},
+  [328] = {.lex_state = 6},
   [329] = {.lex_state = 1},
   [330] = {.lex_state = 1},
-  [331] = {.lex_state = 1},
-  [332] = {.lex_state = 1},
-  [333] = {.lex_state = 1},
-  [334] = {.lex_state = 1},
-  [335] = {.lex_state = 1},
-  [336] = {.lex_state = 6},
-  [337] = {.lex_state = 1},
-  [338] = {.lex_state = 1},
-  [339] = {.lex_state = 6},
-  [340] = {.lex_state = 1},
-  [341] = {.lex_state = 1},
-  [342] = {.lex_state = 6},
+  [331] = {.lex_state = 6},
+  [332] = {.lex_state = 6},
+  [333] = {.lex_state = 28},
+  [334] = {.lex_state = 28},
+  [335] = {.lex_state = 28},
+  [336] = {.lex_state = 1},
+  [337] = {.lex_state = 28},
+  [338] = {.lex_state = 6},
+  [339] = {.lex_state = 28},
+  [340] = {.lex_state = 28},
+  [341] = {.lex_state = 28},
+  [342] = {.lex_state = 28},
   [343] = {.lex_state = 1},
-  [344] = {.lex_state = 1},
+  [344] = {.lex_state = 0},
   [345] = {.lex_state = 1},
-  [346] = {.lex_state = 27},
-  [347] = {.lex_state = 27},
-  [348] = {.lex_state = 27},
-  [349] = {.lex_state = 27},
-  [350] = {.lex_state = 27},
-  [351] = {.lex_state = 27},
-  [352] = {.lex_state = 27},
-  [353] = {.lex_state = 1},
-  [354] = {.lex_state = 27},
-  [355] = {.lex_state = 6},
-  [356] = {.lex_state = 6},
+  [346] = {.lex_state = 0},
+  [347] = {.lex_state = 0},
+  [348] = {.lex_state = 0},
+  [349] = {.lex_state = 0},
+  [350] = {.lex_state = 0},
+  [351] = {.lex_state = 28},
+  [352] = {.lex_state = 1},
+  [353] = {.lex_state = 0},
+  [354] = {.lex_state = 0},
+  [355] = {.lex_state = 1},
+  [356] = {.lex_state = 0},
   [357] = {.lex_state = 0},
-  [358] = {.lex_state = 27},
-  [359] = {.lex_state = 27},
+  [358] = {.lex_state = 28},
+  [359] = {.lex_state = 0},
   [360] = {.lex_state = 0},
   [361] = {.lex_state = 0},
-  [362] = {.lex_state = 0},
-  [363] = {.lex_state = 0},
-  [364] = {.lex_state = 0},
-  [365] = {.lex_state = 1},
-  [366] = {.lex_state = 1},
-  [367] = {.lex_state = 0},
-  [368] = {.lex_state = 1},
-  [369] = {.lex_state = 1},
-  [370] = {.lex_state = 1},
-  [371] = {.lex_state = 1},
-  [372] = {.lex_state = 0},
-  [373] = {.lex_state = 0},
-  [374] = {.lex_state = 0},
-  [375] = {.lex_state = 1},
-  [376] = {.lex_state = 0},
-  [377] = {.lex_state = 0},
-  [378] = {.lex_state = 0},
-  [379] = {.lex_state = 27},
-  [380] = {.lex_state = 27},
-  [381] = {.lex_state = 1},
-  [382] = {.lex_state = 1},
-  [383] = {.lex_state = 0},
-  [384] = {.lex_state = 1},
 };
 
 static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
@@ -2469,10 +2357,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(1),
     [anon_sym_asyncfor] = ACTIONS(1),
     [anon_sym_in] = ACTIONS(1),
-    [anon_sym_select] = ACTIONS(1),
-    [anon_sym_from] = ACTIONS(1),
-    [anon_sym_insert] = ACTIONS(1),
-    [anon_sym_into] = ACTIONS(1),
     [anon_sym_PIPE] = ACTIONS(1),
     [anon_sym_table] = ACTIONS(1),
     [anon_sym_return] = ACTIONS(1),
@@ -2480,41 +2364,40 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_any] = ACTIONS(1),
     [anon_sym_bool] = ACTIONS(1),
     [anon_sym_fn] = ACTIONS(1),
+    [anon_sym_DASH_GT] = ACTIONS(1),
     [anon_sym_int] = ACTIONS(1),
     [anon_sym_list] = ACTIONS(1),
     [anon_sym_map] = ACTIONS(1),
+    [anon_sym_num] = ACTIONS(1),
     [anon_sym_str] = ACTIONS(1),
-    [anon_sym_DASH_GT] = ACTIONS(1),
   },
   [1] = {
-    [sym_root] = STATE(376),
-    [sym_block] = STATE(182),
-    [sym_statement] = STATE(8),
-    [sym_expression] = STATE(82),
-    [sym__expression_kind] = STATE(77),
-    [sym_value] = STATE(77),
-    [sym_boolean] = STATE(70),
-    [sym_list] = STATE(70),
-    [sym_map] = STATE(70),
-    [sym_index] = STATE(56),
-    [sym_math] = STATE(77),
-    [sym_logic] = STATE(77),
-    [sym_assignment] = STATE(182),
-    [sym_index_assignment] = STATE(182),
-    [sym_if_else] = STATE(182),
-    [sym_if] = STATE(117),
-    [sym_match] = STATE(182),
-    [sym_while] = STATE(182),
-    [sym_for] = STATE(182),
-    [sym_select] = STATE(182),
-    [sym_insert] = STATE(182),
-    [sym_table] = STATE(70),
-    [sym_return] = STATE(182),
-    [sym_use] = STATE(182),
-    [sym_function] = STATE(70),
-    [sym_function_call] = STATE(77),
-    [sym_yield] = STATE(77),
-    [aux_sym_root_repeat1] = STATE(8),
+    [sym_root] = STATE(361),
+    [sym_block] = STATE(222),
+    [sym_statement] = STATE(17),
+    [sym_expression] = STATE(80),
+    [sym__expression_kind] = STATE(74),
+    [sym_value] = STATE(74),
+    [sym_boolean] = STATE(77),
+    [sym_list] = STATE(77),
+    [sym_map] = STATE(77),
+    [sym_index] = STATE(75),
+    [sym_math] = STATE(74),
+    [sym_logic] = STATE(74),
+    [sym_assignment] = STATE(222),
+    [sym_index_assignment] = STATE(222),
+    [sym_if_else] = STATE(222),
+    [sym_if] = STATE(115),
+    [sym_match] = STATE(222),
+    [sym_while] = STATE(222),
+    [sym_for] = STATE(222),
+    [sym_table] = STATE(77),
+    [sym_return] = STATE(222),
+    [sym_use] = STATE(222),
+    [sym_function] = STATE(77),
+    [sym_function_call] = STATE(74),
+    [sym_yield] = STATE(74),
+    [aux_sym_root_repeat1] = STATE(17),
     [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_async] = ACTIONS(7),
@@ -2531,17 +2414,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_while] = ACTIONS(25),
     [anon_sym_for] = ACTIONS(27),
     [anon_sym_asyncfor] = ACTIONS(29),
-    [anon_sym_select] = ACTIONS(31),
-    [anon_sym_insert] = ACTIONS(33),
-    [anon_sym_PIPE] = ACTIONS(35),
-    [anon_sym_table] = ACTIONS(37),
-    [anon_sym_return] = ACTIONS(39),
-    [anon_sym_use] = ACTIONS(41),
+    [anon_sym_PIPE] = ACTIONS(31),
+    [anon_sym_table] = ACTIONS(33),
+    [anon_sym_return] = ACTIONS(35),
+    [anon_sym_use] = ACTIONS(37),
   },
 };
 
 static const uint16_t ts_small_parse_table[] = {
-  [0] = 29,
+  [0] = 27,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(7), 1,
@@ -2565,28 +2446,24 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    ACTIONS(43), 1,
+    ACTIONS(39), 1,
       sym_identifier,
-    ACTIONS(45), 1,
+    ACTIONS(41), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
-    STATE(337), 1,
+    STATE(310), 1,
       aux_sym_map_repeat1,
     ACTIONS(15), 2,
       sym_float,
@@ -2594,23 +2471,23 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(7), 2,
+    STATE(13), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -2618,79 +2495,73 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [110] = 28,
+  [102] = 26,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(49), 1,
+    ACTIONS(45), 1,
       sym_identifier,
-    ACTIONS(52), 1,
+    ACTIONS(48), 1,
       anon_sym_async,
-    ACTIONS(55), 1,
+    ACTIONS(51), 1,
       anon_sym_LBRACE,
-    ACTIONS(58), 1,
+    ACTIONS(54), 1,
       anon_sym_LPAREN,
-    ACTIONS(61), 1,
+    ACTIONS(57), 1,
       sym_integer,
-    ACTIONS(70), 1,
+    ACTIONS(66), 1,
       anon_sym_LBRACK,
-    ACTIONS(73), 1,
+    ACTIONS(69), 1,
       anon_sym_if,
-    ACTIONS(76), 1,
+    ACTIONS(72), 1,
       anon_sym_match,
-    ACTIONS(79), 1,
+    ACTIONS(75), 1,
       anon_sym_while,
-    ACTIONS(82), 1,
+    ACTIONS(78), 1,
       anon_sym_for,
-    ACTIONS(85), 1,
+    ACTIONS(81), 1,
       anon_sym_asyncfor,
-    ACTIONS(88), 1,
-      anon_sym_select,
-    ACTIONS(91), 1,
-      anon_sym_insert,
-    ACTIONS(94), 1,
+    ACTIONS(84), 1,
       anon_sym_PIPE,
-    ACTIONS(97), 1,
+    ACTIONS(87), 1,
       anon_sym_table,
-    ACTIONS(100), 1,
+    ACTIONS(90), 1,
       anon_sym_return,
-    ACTIONS(103), 1,
+    ACTIONS(93), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
-    ACTIONS(47), 2,
+    ACTIONS(43), 2,
       ts_builtin_sym_end,
       anon_sym_RBRACE,
-    ACTIONS(64), 2,
+    ACTIONS(60), 2,
       sym_float,
       sym_string,
-    ACTIONS(67), 2,
+    ACTIONS(63), 2,
       anon_sym_true,
       anon_sym_false,
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -2698,11 +2569,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [218] = 29,
+  [202] = 27,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(7), 1,
@@ -2726,28 +2595,24 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    ACTIONS(43), 1,
+    ACTIONS(39), 1,
       sym_identifier,
-    ACTIONS(106), 1,
+    ACTIONS(96), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
-    STATE(330), 1,
+    STATE(300), 1,
       aux_sym_map_repeat1,
     ACTIONS(15), 2,
       sym_float,
@@ -2755,23 +2620,23 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(15), 2,
+    STATE(10), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -2779,11 +2644,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [328] = 28,
+  [304] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -2809,24 +2672,385 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    ACTIONS(98), 1,
+      anon_sym_RBRACE,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(3), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [403] = 26,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    ACTIONS(100), 1,
+      anon_sym_RBRACE,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(3), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [502] = 26,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    ACTIONS(102), 1,
+      anon_sym_RBRACE,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(3), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [601] = 26,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    ACTIONS(104), 1,
+      anon_sym_RBRACE,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(3), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [700] = 26,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    ACTIONS(106), 1,
+      anon_sym_RBRACE,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(3), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [799] = 26,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(108), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -2837,20 +3061,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -2858,11 +3082,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [435] = 28,
+  [898] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -2888,24 +3110,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(110), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -2916,20 +3134,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -2937,11 +3155,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [542] = 28,
+  [997] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -2967,24 +3183,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(112), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -2995,20 +3207,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -3016,11 +3228,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [649] = 28,
+  [1096] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -3046,24 +3256,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(114), 1,
-      ts_builtin_sym_end,
-    STATE(56), 1,
+      anon_sym_RBRACE,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -3074,20 +3280,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -3095,11 +3301,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [756] = 28,
+  [1195] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -3125,24 +3329,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(116), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -3153,20 +3353,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -3174,11 +3374,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [863] = 28,
+  [1294] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -3204,24 +3402,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(118), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -3232,20 +3426,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -3253,11 +3447,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [970] = 28,
+  [1393] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -3283,24 +3475,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(120), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -3311,20 +3499,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -3332,11 +3520,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [1077] = 28,
+  [1492] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -3362,24 +3548,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(122), 1,
-      anon_sym_RBRACE,
-    STATE(56), 1,
+      ts_builtin_sym_end,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -3390,20 +3572,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -3411,11 +3593,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [1184] = 28,
+  [1591] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -3441,24 +3621,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(124), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -3469,20 +3645,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -3490,11 +3666,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [1291] = 28,
+  [1690] = 26,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -3520,24 +3694,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
     ACTIONS(126), 1,
       anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -3548,20 +3718,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(3), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -3569,11 +3739,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [1398] = 28,
+  [1789] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -3599,494 +3767,18 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    ACTIONS(128), 1,
-      anon_sym_RBRACE,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(3), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [1505] = 28,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
     ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    ACTIONS(130), 1,
-      anon_sym_RBRACE,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(3), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [1612] = 28,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
     ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    ACTIONS(132), 1,
-      anon_sym_RBRACE,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(3), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [1719] = 28,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
     ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
       anon_sym_use,
-    ACTIONS(134), 1,
-      anon_sym_RBRACE,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(3), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [1826] = 28,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    ACTIONS(136), 1,
-      anon_sym_RBRACE,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(3), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [1933] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(6), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [2037] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -4097,20 +3789,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(11), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -4118,11 +3810,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [2141] = 27,
+  [1885] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -4148,253 +3838,18 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(17), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [2245] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
     ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(19), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [2349] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
     ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(13), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [2453] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
     ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -4405,20 +3860,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(18), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -4426,11 +3881,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [2557] = 27,
+  [1981] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -4456,22 +3909,18 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -4479,23 +3928,23 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(12), 2,
+    STATE(13), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -4503,11 +3952,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [2661] = 27,
+  [2077] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -4533,253 +3980,18 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(10), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [2765] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
     ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(15), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [2869] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
     ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
-      anon_sym_use,
-    STATE(56), 1,
-      sym_index,
-    STATE(82), 1,
-      sym_expression,
-    STATE(117), 1,
-      sym_if,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(7), 2,
-      sym_statement,
-      aux_sym_root_repeat1,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(182), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [2973] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym_identifier,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(9), 1,
-      anon_sym_LBRACE,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_if,
-    ACTIONS(23), 1,
-      anon_sym_match,
-    ACTIONS(25), 1,
-      anon_sym_while,
-    ACTIONS(27), 1,
-      anon_sym_for,
-    ACTIONS(29), 1,
-      anon_sym_asyncfor,
-    ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
     ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(39), 1,
-      anon_sym_return,
-    ACTIONS(41), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -4790,20 +4002,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(5), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -4811,11 +4023,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [3077] = 27,
+  [2173] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -4841,22 +4051,18 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -4867,20 +4073,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(9), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -4888,11 +4094,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [3181] = 27,
+  [2269] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -4918,22 +4122,18 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -4941,23 +4141,23 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(16), 2,
+    STATE(19), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -4965,11 +4165,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [3285] = 27,
+  [2365] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -4995,22 +4193,18 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(82), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
     ACTIONS(15), 2,
       sym_float,
@@ -5021,20 +4215,20 @@ static const uint16_t ts_small_parse_table[] = {
     STATE(14), 2,
       sym_statement,
       aux_sym_root_repeat1,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(182), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -5042,163 +4236,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [3389] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(138), 1,
-      sym_identifier,
-    ACTIONS(140), 1,
-      anon_sym_async,
-    ACTIONS(142), 1,
-      anon_sym_LBRACE,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(154), 1,
-      anon_sym_if,
-    ACTIONS(156), 1,
-      anon_sym_match,
-    ACTIONS(158), 1,
-      anon_sym_while,
-    ACTIONS(160), 1,
-      anon_sym_for,
-    ACTIONS(162), 1,
-      anon_sym_asyncfor,
-    ACTIONS(164), 1,
-      anon_sym_select,
-    ACTIONS(166), 1,
-      anon_sym_insert,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(172), 1,
-      anon_sym_return,
-    ACTIONS(174), 1,
-      anon_sym_use,
-    STATE(247), 1,
-      sym_index,
-    STATE(258), 1,
-      sym_expression,
-    STATE(283), 1,
-      sym_if,
-    STATE(328), 1,
-      sym_statement,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(303), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [3492] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(138), 1,
-      sym_identifier,
-    ACTIONS(140), 1,
-      anon_sym_async,
-    ACTIONS(142), 1,
-      anon_sym_LBRACE,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(154), 1,
-      anon_sym_if,
-    ACTIONS(156), 1,
-      anon_sym_match,
-    ACTIONS(158), 1,
-      anon_sym_while,
-    ACTIONS(160), 1,
-      anon_sym_for,
-    ACTIONS(162), 1,
-      anon_sym_asyncfor,
-    ACTIONS(164), 1,
-      anon_sym_select,
-    ACTIONS(166), 1,
-      anon_sym_insert,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(172), 1,
-      anon_sym_return,
-    ACTIONS(174), 1,
-      anon_sym_use,
-    STATE(247), 1,
-      sym_index,
-    STATE(258), 1,
-      sym_expression,
-    STATE(283), 1,
-      sym_if,
-    STATE(328), 1,
-      sym_statement,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(303), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [3595] = 27,
+  [2461] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -5224,121 +4264,42 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(83), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
-    STATE(243), 1,
-      sym_statement,
     ACTIONS(15), 2,
       sym_float,
       sym_string,
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(195), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [3698] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(138), 1,
-      sym_identifier,
-    ACTIONS(140), 1,
-      anon_sym_async,
-    ACTIONS(142), 1,
-      anon_sym_LBRACE,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(154), 1,
-      anon_sym_if,
-    ACTIONS(156), 1,
-      anon_sym_match,
-    ACTIONS(158), 1,
-      anon_sym_while,
-    ACTIONS(160), 1,
-      anon_sym_for,
-    ACTIONS(162), 1,
-      anon_sym_asyncfor,
-    ACTIONS(164), 1,
-      anon_sym_select,
-    ACTIONS(166), 1,
-      anon_sym_insert,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(172), 1,
-      anon_sym_return,
-    ACTIONS(174), 1,
-      anon_sym_use,
-    STATE(247), 1,
-      sym_index,
-    STATE(251), 1,
-      sym_expression,
-    STATE(283), 1,
-      sym_if,
-    STATE(311), 1,
+    STATE(10), 2,
       sym_statement,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(150), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(302), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -5346,11 +4307,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [3801] = 27,
+  [2557] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -5376,45 +4335,42 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(83), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
-    STATE(214), 1,
-      sym_statement,
     ACTIONS(15), 2,
       sym_float,
       sym_string,
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(70), 5,
+    STATE(15), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(195), 11,
+    STATE(222), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -5422,11 +4378,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [3904] = 27,
+  [2653] = 25,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
@@ -5452,24 +4406,375 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(29), 1,
       anon_sym_asyncfor,
     ACTIONS(31), 1,
-      anon_sym_select,
-    ACTIONS(33), 1,
-      anon_sym_insert,
-    ACTIONS(35), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(39), 1,
+    ACTIONS(35), 1,
       anon_sym_return,
-    ACTIONS(41), 1,
+    ACTIONS(37), 1,
       anon_sym_use,
-    STATE(56), 1,
+    STATE(75), 1,
       sym_index,
-    STATE(83), 1,
+    STATE(80), 1,
       sym_expression,
-    STATE(117), 1,
+    STATE(115), 1,
       sym_if,
-    STATE(227), 1,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(6), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [2749] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(7), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [2845] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(8), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [2941] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(16), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [3037] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    STATE(75), 1,
+      sym_index,
+    STATE(80), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(12), 2,
+      sym_statement,
+      aux_sym_root_repeat1,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(222), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [3133] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    STATE(75), 1,
+      sym_index,
+    STATE(81), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    STATE(225), 1,
       sym_statement,
     ACTIONS(15), 2,
       sym_float,
@@ -5477,20 +4782,20 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 6,
+    STATE(74), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(195), 11,
+    STATE(234), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -5498,151 +4803,119 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [4007] = 27,
+  [3228] = 5,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(138), 1,
-      sym_identifier,
-    ACTIONS(140), 1,
+    STATE(215), 1,
+      sym_logic_operator,
+    STATE(216), 1,
+      sym_math_operator,
+    ACTIONS(130), 18,
       anon_sym_async,
-    ACTIONS(142), 1,
-      anon_sym_LBRACE,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
+      sym_identifier,
       sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(154), 1,
-      anon_sym_if,
-    ACTIONS(156), 1,
-      anon_sym_match,
-    ACTIONS(158), 1,
-      anon_sym_while,
-    ACTIONS(160), 1,
-      anon_sym_for,
-    ACTIONS(162), 1,
-      anon_sym_asyncfor,
-    ACTIONS(164), 1,
-      anon_sym_select,
-    ACTIONS(166), 1,
-      anon_sym_insert,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(172), 1,
-      anon_sym_return,
-    ACTIONS(174), 1,
-      anon_sym_use,
-    STATE(247), 1,
-      sym_index,
-    STATE(251), 1,
-      sym_expression,
-    STATE(283), 1,
-      sym_if,
-    STATE(309), 1,
-      sym_statement,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 6,
-      sym__expression_kind,
-      sym_value,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    STATE(302), 11,
-      sym_block,
-      sym_assignment,
-      sym_index_assignment,
-      sym_if_else,
-      sym_match,
-      sym_while,
-      sym_for,
-      sym_select,
-      sym_insert,
-      sym_return,
-      sym_use,
-  [4110] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(138), 1,
-      sym_identifier,
-    ACTIONS(140), 1,
-      anon_sym_async,
-    ACTIONS(142), 1,
-      anon_sym_LBRACE,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(154), 1,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
       anon_sym_if,
-    ACTIONS(156), 1,
       anon_sym_match,
-    ACTIONS(158), 1,
       anon_sym_while,
-    ACTIONS(160), 1,
       anon_sym_for,
-    ACTIONS(162), 1,
-      anon_sym_asyncfor,
-    ACTIONS(164), 1,
-      anon_sym_select,
-    ACTIONS(166), 1,
-      anon_sym_insert,
-    ACTIONS(168), 1,
       anon_sym_PIPE,
-    ACTIONS(170), 1,
       anon_sym_table,
-    ACTIONS(172), 1,
       anon_sym_return,
-    ACTIONS(174), 1,
       anon_sym_use,
-    STATE(247), 1,
-      sym_index,
-    STATE(251), 1,
-      sym_expression,
-    STATE(283), 1,
-      sym_if,
-    STATE(306), 1,
-      sym_statement,
-    ACTIONS(148), 2,
+    ACTIONS(128), 23,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
       sym_float,
       sym_string,
-    ACTIONS(150), 2,
+      anon_sym_LBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+  [3283] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(132), 1,
+      sym_identifier,
+    ACTIONS(134), 1,
+      anon_sym_async,
+    ACTIONS(136), 1,
+      anon_sym_LBRACE,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(148), 1,
+      anon_sym_if,
+    ACTIONS(150), 1,
+      anon_sym_match,
+    ACTIONS(152), 1,
+      anon_sym_while,
+    ACTIONS(154), 1,
+      anon_sym_for,
+    ACTIONS(156), 1,
+      anon_sym_asyncfor,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
+    ACTIONS(162), 1,
+      anon_sym_return,
+    ACTIONS(164), 1,
+      anon_sym_use,
+    STATE(221), 1,
+      sym_index,
+    STATE(239), 1,
+      sym_expression,
+    STATE(281), 1,
+      sym_if,
+    STATE(303), 1,
+      sym_statement,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(133), 5,
+    STATE(146), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(150), 6,
+    STATE(144), 6,
       sym__expression_kind,
       sym_value,
       sym_math,
       sym_logic,
       sym_function_call,
       sym_yield,
-    STATE(302), 11,
+    STATE(287), 9,
       sym_block,
       sym_assignment,
       sym_index_assignment,
@@ -5650,183 +4923,364 @@ static const uint16_t ts_small_parse_table[] = {
       sym_match,
       sym_while,
       sym_for,
-      sym_select,
-      sym_insert,
       sym_return,
       sym_use,
-  [4213] = 11,
+  [3378] = 23,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(172), 1,
+      anon_sym_RPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
     ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(182), 1,
       anon_sym_COLON,
-    ACTIONS(190), 1,
-      anon_sym_DASH_GT,
-    STATE(186), 1,
-      sym_math_operator,
-    STATE(187), 1,
-      sym_logic_operator,
-    ACTIONS(182), 2,
-      anon_sym_PLUS,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(188), 2,
+    ACTIONS(192), 1,
+      anon_sym_PIPE,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    STATE(111), 1,
+      sym_expression,
+    STATE(145), 1,
+      aux_sym__expression_list,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(184), 3,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-    ACTIONS(176), 12,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
-    ACTIONS(178), 16,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [4282] = 6,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [3469] = 25,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    STATE(75), 1,
+      sym_index,
+    STATE(81), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    STATE(223), 1,
+      sym_statement,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(234), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [3564] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(132), 1,
+      sym_identifier,
+    ACTIONS(134), 1,
+      anon_sym_async,
+    ACTIONS(136), 1,
+      anon_sym_LBRACE,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(148), 1,
+      anon_sym_if,
+    ACTIONS(150), 1,
+      anon_sym_match,
+    ACTIONS(152), 1,
+      anon_sym_while,
+    ACTIONS(154), 1,
+      anon_sym_for,
+    ACTIONS(156), 1,
+      anon_sym_asyncfor,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
+    ACTIONS(162), 1,
+      anon_sym_return,
+    ACTIONS(164), 1,
+      anon_sym_use,
+    STATE(221), 1,
+      sym_index,
+    STATE(242), 1,
+      sym_expression,
+    STATE(281), 1,
+      sym_if,
+    STATE(288), 1,
+      sym_statement,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(289), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [3659] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(132), 1,
+      sym_identifier,
+    ACTIONS(134), 1,
+      anon_sym_async,
+    ACTIONS(136), 1,
+      anon_sym_LBRACE,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(148), 1,
+      anon_sym_if,
+    ACTIONS(150), 1,
+      anon_sym_match,
+    ACTIONS(152), 1,
+      anon_sym_while,
+    ACTIONS(154), 1,
+      anon_sym_for,
+    ACTIONS(156), 1,
+      anon_sym_asyncfor,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
+    ACTIONS(162), 1,
+      anon_sym_return,
+    ACTIONS(164), 1,
+      anon_sym_use,
+    STATE(221), 1,
+      sym_index,
+    STATE(242), 1,
+      sym_expression,
+    STATE(281), 1,
+      sym_if,
+    STATE(290), 1,
+      sym_statement,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(289), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [3754] = 23,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
     ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(182), 1,
       anon_sym_COLON,
-    STATE(186), 1,
-      sym_math_operator,
-    STATE(187), 1,
-      sym_logic_operator,
-    ACTIONS(194), 20,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_PLUS,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
+    ACTIONS(192), 1,
       anon_sym_PIPE,
+    ACTIONS(194), 1,
       anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-    ACTIONS(192), 22,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(198), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(126), 1,
+      aux_sym__expression_list,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(176), 2,
       sym_float,
       sym_string,
-      anon_sym_LBRACK,
-      anon_sym_DOT_DOT,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
-      anon_sym_DASH_GT,
-  [4341] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(186), 1,
-      sym_math_operator,
-    STATE(187), 1,
-      sym_logic_operator,
-    ACTIONS(198), 20,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-    ACTIONS(196), 23,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
-      anon_sym_DASH_GT,
-  [4398] = 6,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [3845] = 6,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(200), 1,
       anon_sym_DOT_DOT,
-    STATE(186), 1,
-      sym_math_operator,
-    STATE(187), 1,
+    STATE(215), 1,
       sym_logic_operator,
-    ACTIONS(198), 20,
+    STATE(216), 1,
+      sym_math_operator,
+    ACTIONS(130), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -5841,13 +5295,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(196), 22,
+    ACTIONS(128), 22,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -5870,72 +5322,360 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [4457] = 11,
+  [3902] = 23,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
     ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(182), 1,
       anon_sym_COLON,
-    ACTIONS(190), 1,
-      anon_sym_DASH_GT,
-    STATE(186), 1,
-      sym_math_operator,
-    STATE(187), 1,
-      sym_logic_operator,
-    ACTIONS(182), 2,
-      anon_sym_PLUS,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(188), 2,
+    ACTIONS(192), 1,
+      anon_sym_PIPE,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(202), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(127), 1,
+      aux_sym__expression_list,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(184), 3,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-    ACTIONS(202), 12,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
-    ACTIONS(204), 16,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [4526] = 5,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [3993] = 25,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(186), 1,
+    ACTIONS(132), 1,
+      sym_identifier,
+    ACTIONS(134), 1,
+      anon_sym_async,
+    ACTIONS(136), 1,
+      anon_sym_LBRACE,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(148), 1,
+      anon_sym_if,
+    ACTIONS(150), 1,
+      anon_sym_match,
+    ACTIONS(152), 1,
+      anon_sym_while,
+    ACTIONS(154), 1,
+      anon_sym_for,
+    ACTIONS(156), 1,
+      anon_sym_asyncfor,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
+    ACTIONS(162), 1,
+      anon_sym_return,
+    ACTIONS(164), 1,
+      anon_sym_use,
+    STATE(221), 1,
+      sym_index,
+    STATE(242), 1,
+      sym_expression,
+    STATE(281), 1,
+      sym_if,
+    STATE(298), 1,
+      sym_statement,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(289), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [4088] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_async,
+    ACTIONS(9), 1,
+      anon_sym_LBRACE,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_if,
+    ACTIONS(23), 1,
+      anon_sym_match,
+    ACTIONS(25), 1,
+      anon_sym_while,
+    ACTIONS(27), 1,
+      anon_sym_for,
+    ACTIONS(29), 1,
+      anon_sym_asyncfor,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    ACTIONS(37), 1,
+      anon_sym_use,
+    STATE(75), 1,
+      sym_index,
+    STATE(81), 1,
+      sym_expression,
+    STATE(115), 1,
+      sym_if,
+    STATE(235), 1,
+      sym_statement,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(234), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [4183] = 23,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(182), 1,
+      anon_sym_COLON,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(192), 1,
+      anon_sym_PIPE,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(204), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(131), 1,
+      aux_sym__expression_list,
+    STATE(173), 1,
       sym_math_operator,
-    STATE(187), 1,
+    STATE(174), 1,
       sym_logic_operator,
-    ACTIONS(208), 20,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [4274] = 25,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(132), 1,
+      sym_identifier,
+    ACTIONS(134), 1,
+      anon_sym_async,
+    ACTIONS(136), 1,
+      anon_sym_LBRACE,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(148), 1,
+      anon_sym_if,
+    ACTIONS(150), 1,
+      anon_sym_match,
+    ACTIONS(152), 1,
+      anon_sym_while,
+    ACTIONS(154), 1,
+      anon_sym_for,
+    ACTIONS(156), 1,
+      anon_sym_asyncfor,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
+    ACTIONS(162), 1,
+      anon_sym_return,
+    ACTIONS(164), 1,
+      anon_sym_use,
+    STATE(221), 1,
+      sym_index,
+    STATE(239), 1,
+      sym_expression,
+    STATE(281), 1,
+      sym_if,
+    STATE(303), 1,
+      sym_statement,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 6,
+      sym__expression_kind,
+      sym_value,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+    STATE(287), 9,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+      sym_use,
+  [4369] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(215), 1,
+      sym_logic_operator,
+    STATE(216), 1,
+      sym_math_operator,
+    ACTIONS(208), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -5950,8 +5690,6 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
@@ -5980,35 +5718,466 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [4583] = 11,
+  [4424] = 23,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(190), 1,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(182), 1,
+      anon_sym_COLON,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(192), 1,
+      anon_sym_PIPE,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(196), 1,
       anon_sym_DASH_GT,
     ACTIONS(210), 1,
-      anon_sym_COLON,
-    STATE(230), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(130), 1,
+      aux_sym__expression_list,
+    STATE(173), 1,
       sym_math_operator,
-    STATE(234), 1,
+    STATE(174), 1,
       sym_logic_operator,
-    ACTIONS(182), 2,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [4515] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(216), 1,
+      anon_sym_COLON,
+    ACTIONS(218), 1,
+      anon_sym_DASH_GT,
+    STATE(215), 1,
+      sym_logic_operator,
+    STATE(216), 1,
+      sym_math_operator,
+    ACTIONS(186), 2,
       anon_sym_PLUS,
       anon_sym_DASH,
-    ACTIONS(188), 2,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 3,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-    ACTIONS(176), 11,
+    ACTIONS(212), 12,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+    ACTIONS(214), 14,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [4582] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(216), 1,
+      anon_sym_COLON,
+    STATE(215), 1,
+      sym_logic_operator,
+    STATE(216), 1,
+      sym_math_operator,
+    ACTIONS(222), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+    ACTIONS(220), 22,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+  [4639] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(216), 1,
+      anon_sym_COLON,
+    ACTIONS(218), 1,
+      anon_sym_DASH_GT,
+    STATE(215), 1,
+      sym_logic_operator,
+    STATE(216), 1,
+      sym_math_operator,
+    ACTIONS(186), 2,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(224), 12,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+    ACTIONS(226), 14,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [4706] = 23,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(182), 1,
+      anon_sym_COLON,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(192), 1,
+      anon_sym_PIPE,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(228), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(132), 1,
+      aux_sym__expression_list,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [4797] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(182), 1,
+      anon_sym_COLON,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(234), 1,
+      anon_sym_PIPE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    STATE(82), 1,
+      aux_sym_match_repeat1,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    STATE(259), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [4885] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(182), 1,
+      anon_sym_COLON,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(234), 1,
+      anon_sym_PIPE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    STATE(113), 1,
+      aux_sym_match_repeat1,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    STATE(260), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [4973] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(218), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(238), 1,
+      anon_sym_COLON,
+    STATE(162), 1,
+      sym_logic_operator,
+    STATE(163), 1,
+      sym_math_operator,
+    ACTIONS(186), 2,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(224), 11,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6020,7 +6189,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
-    ACTIONS(178), 16,
+    ACTIONS(226), 14,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6031,27 +6200,25 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-  [4651] = 8,
+  [5039] = 8,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(216), 1,
+    ACTIONS(244), 1,
       anon_sym_EQ,
-    ACTIONS(218), 1,
+    ACTIONS(246), 1,
       anon_sym_LT,
-    STATE(36), 1,
+    STATE(38), 1,
       sym_assignment_operator,
-    STATE(298), 1,
-      sym_type,
-    ACTIONS(220), 2,
+    STATE(286), 1,
+      sym_type_definition,
+    ACTIONS(248), 2,
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
-    ACTIONS(214), 18,
+    ACTIONS(242), 16,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6064,13 +6231,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(212), 20,
+    ACTIONS(240), 20,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6091,14 +6256,119 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [4713] = 5,
+  [5099] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(230), 1,
-      sym_math_operator,
-    STATE(234), 1,
+    ACTIONS(238), 1,
+      anon_sym_COLON,
+    STATE(162), 1,
       sym_logic_operator,
-    ACTIONS(208), 20,
+    STATE(163), 1,
+      sym_math_operator,
+    ACTIONS(222), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+    ACTIONS(220), 21,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+  [5155] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(218), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(238), 1,
+      anon_sym_COLON,
+    STATE(162), 1,
+      sym_logic_operator,
+    STATE(163), 1,
+      sym_math_operator,
+    ACTIONS(186), 2,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(212), 11,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+    ACTIONS(214), 14,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [5221] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(162), 1,
+      sym_logic_operator,
+    STATE(163), 1,
+      sym_math_operator,
+    ACTIONS(208), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6113,8 +6383,6 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
@@ -6142,290 +6410,21 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [4769] = 11,
+  [5275] = 8,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(190), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(210), 1,
-      anon_sym_COLON,
-    STATE(230), 1,
-      sym_math_operator,
-    STATE(234), 1,
-      sym_logic_operator,
-    ACTIONS(182), 2,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 3,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(202), 11,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
-    ACTIONS(204), 16,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [4837] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(210), 1,
-      anon_sym_COLON,
-    STATE(230), 1,
-      sym_math_operator,
-    STATE(234), 1,
-      sym_logic_operator,
-    ACTIONS(194), 20,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-    ACTIONS(192), 21,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
-      anon_sym_DASH_GT,
-  [4895] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(224), 20,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-    ACTIONS(222), 23,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
-      anon_sym_DASH_GT,
-  [4946] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(228), 20,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-    ACTIONS(226), 23,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
-      anon_sym_DASH_GT,
-  [4997] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(236), 1,
-      anon_sym_RPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
     ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(248), 1,
-      anon_sym_PIPE,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    STATE(114), 1,
-      sym_expression,
-    STATE(152), 1,
-      aux_sym__expression_list,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [5088] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(216), 1,
+    ACTIONS(250), 1,
       anon_sym_EQ,
-    STATE(39), 1,
+    STATE(38), 1,
       sym_assignment_operator,
-    ACTIONS(220), 2,
+    STATE(286), 1,
+      sym_type_definition,
+    ACTIONS(248), 2,
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
-    ACTIONS(214), 19,
+    ACTIONS(242), 16,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6434,19 +6433,15 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_PLUS,
       anon_sym_DASH,
       anon_sym_GT,
-      anon_sym_LT,
       anon_sym_if,
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(212), 20,
-      ts_builtin_sym_end,
+    ACTIONS(240), 19,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -6466,10 +6461,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5145] = 3,
+  [5334] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(256), 20,
+    ACTIONS(254), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6484,13 +6479,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(254), 23,
+    ACTIONS(252), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6514,10 +6507,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5196] = 3,
+  [5383] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(260), 20,
+    ACTIONS(258), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6532,13 +6525,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(258), 23,
+    ACTIONS(256), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6562,10 +6553,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5247] = 3,
+  [5432] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(264), 20,
+    ACTIONS(262), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6580,13 +6571,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(262), 23,
+    ACTIONS(260), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6610,10 +6599,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5298] = 3,
+  [5481] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(268), 20,
+    ACTIONS(266), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6628,13 +6617,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(266), 23,
+    ACTIONS(264), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6658,146 +6645,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5349] = 23,
+  [5530] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(248), 1,
-      anon_sym_PIPE,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(270), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(130), 1,
-      aux_sym__expression_list,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [5440] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(248), 1,
-      anon_sym_PIPE,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(272), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(138), 1,
-      aux_sym__expression_list,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [5531] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(276), 20,
+    ACTIONS(270), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6812,13 +6663,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(274), 23,
+    ACTIONS(268), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6842,10 +6691,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5582] = 3,
+  [5579] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(280), 20,
+    ACTIONS(274), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6860,13 +6709,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(278), 23,
+    ACTIONS(272), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6890,10 +6737,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5633] = 3,
+  [5628] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(284), 20,
+    ACTIONS(278), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6908,13 +6755,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(282), 23,
+    ACTIONS(276), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6938,10 +6783,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5684] = 3,
+  [5677] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(288), 20,
+    ACTIONS(282), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -6956,13 +6801,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(286), 23,
+    ACTIONS(280), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -6986,10 +6829,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5735] = 3,
+  [5726] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(292), 20,
+    ACTIONS(286), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -7004,13 +6847,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(290), 23,
+    ACTIONS(284), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -7034,10 +6875,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5786] = 3,
+  [5775] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(296), 20,
+    ACTIONS(290), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -7052,13 +6893,11 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-    ACTIONS(294), 23,
+    ACTIONS(288), 23,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -7082,78 +6921,102 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5837] = 23,
+  [5824] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(248), 1,
-      anon_sym_PIPE,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(298), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(166), 1,
-      aux_sym__expression_list,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [5928] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(302), 20,
+    ACTIONS(294), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+    ACTIONS(292), 23,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+  [5873] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(298), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+    ACTIONS(296), 23,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+  [5922] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(302), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -7168,8 +7031,6 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
@@ -7198,10 +7059,59 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [5979] = 3,
+  [5971] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(306), 20,
+    ACTIONS(244), 1,
+      anon_sym_EQ,
+    STATE(34), 1,
+      sym_assignment_operator,
+    ACTIONS(248), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+    ACTIONS(242), 17,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+    ACTIONS(240), 20,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_COLON,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+  [6026] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(306), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -7216,8 +7126,6 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
@@ -7246,10 +7154,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [6030] = 3,
+  [6075] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(310), 20,
+    ACTIONS(310), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -7264,8 +7172,6 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
@@ -7294,10 +7200,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [6081] = 3,
+  [6124] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(314), 20,
+    ACTIONS(314), 18,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -7312,8 +7218,6 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
       anon_sym_return,
@@ -7342,220 +7246,35 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [6132] = 23,
+  [6173] = 11,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(248), 1,
-      anon_sym_PIPE,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(316), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(137), 1,
-      aux_sym__expression_list,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [6223] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
     ACTIONS(218), 1,
-      anon_sym_LT,
-    ACTIONS(318), 1,
-      anon_sym_EQ,
-    STATE(36), 1,
-      sym_assignment_operator,
-    STATE(298), 1,
-      sym_type,
-    ACTIONS(220), 2,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-    ACTIONS(214), 18,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-    ACTIONS(212), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_COLON,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [6284] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
     ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(246), 1,
       anon_sym_COLON,
-    ACTIONS(248), 1,
-      anon_sym_PIPE,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(320), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(160), 1,
-      aux_sym__expression_list,
-    STATE(178), 1,
+    STATE(162), 1,
       sym_logic_operator,
-    STATE(179), 1,
+    STATE(163), 1,
       sym_math_operator,
-    ACTIONS(188), 2,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
     ACTIONS(184), 4,
       anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [6375] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(324), 20,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-    ACTIONS(322), 23,
+    ACTIONS(316), 9,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -7564,8 +7283,343 @@ static const uint16_t ts_small_parse_table[] = {
       sym_float,
       sym_string,
       anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(318), 13,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [6236] = 12,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(218), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(238), 1,
+      anon_sym_COLON,
+    ACTIONS(324), 1,
+      anon_sym_SEMI,
+    STATE(162), 1,
+      sym_logic_operator,
+    STATE(163), 1,
+      sym_math_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(320), 8,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(322), 13,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [6301] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(218), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(238), 1,
+      anon_sym_COLON,
+    STATE(162), 1,
+      sym_logic_operator,
+    STATE(163), 1,
+      sym_math_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(320), 9,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(322), 13,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_PIPE,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [6364] = 16,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(83), 1,
+      aux_sym_match_repeat1,
+    STATE(259), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(326), 4,
+      ts_builtin_sym_end,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_asyncfor,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(328), 7,
+      anon_sym_async,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_use,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [6434] = 16,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(334), 1,
+      sym_identifier,
+    ACTIONS(339), 1,
+      anon_sym_LBRACE,
+    ACTIONS(342), 1,
+      anon_sym_LPAREN,
+    ACTIONS(345), 1,
+      sym_integer,
+    ACTIONS(354), 1,
+      anon_sym_LBRACK,
+    ACTIONS(357), 1,
+      anon_sym_PIPE,
+    ACTIONS(360), 1,
+      anon_sym_table,
+    STATE(83), 1,
+      aux_sym_match_repeat1,
+    STATE(259), 1,
+      sym_expression,
+    ACTIONS(348), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(351), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(332), 4,
+      ts_builtin_sym_end,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_asyncfor,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    ACTIONS(337), 7,
+      anon_sym_async,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_use,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [6504] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(363), 1,
+      anon_sym_COLON,
+    STATE(204), 1,
+      sym_logic_operator,
+    STATE(205), 1,
+      sym_math_operator,
+    ACTIONS(222), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(220), 20,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [6550] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(365), 1,
+      anon_sym_DOT_DOT,
+    STATE(204), 1,
+      sym_logic_operator,
+    STATE(205), 1,
+      sym_math_operator,
+    ACTIONS(130), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(128), 20,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_COLON,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [6596] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(204), 1,
+      sym_logic_operator,
+    STATE(205), 1,
+      sym_math_operator,
+    ACTIONS(130), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(128), 21,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
       anon_sym_COLON,
       anon_sym_DOT_DOT,
+      anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
@@ -7575,30 +7629,21 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_asyncfor,
       anon_sym_DASH_GT,
-  [6426] = 14,
+  [6640] = 11,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(7), 1,
-      anon_sym_async,
-    ACTIONS(182), 1,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(190), 1,
+    ACTIONS(196), 1,
       anon_sym_DASH_GT,
-    ACTIONS(210), 1,
+    ACTIONS(363), 1,
       anon_sym_COLON,
-    ACTIONS(330), 1,
-      anon_sym_LBRACE,
-    STATE(199), 1,
-      sym_block,
-    STATE(230), 1,
-      sym_math_operator,
-    STATE(234), 1,
+    STATE(204), 1,
       sym_logic_operator,
-    ACTIONS(188), 2,
+    STATE(205), 1,
+      sym_math_operator,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -7606,502 +7651,34 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-    ACTIONS(326), 8,
-      ts_builtin_sym_end,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(328), 14,
+    ACTIONS(214), 6,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_PIPE,
       anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [6498] = 22,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
+    ACTIONS(212), 9,
       anon_sym_LBRACE,
-    ACTIONS(336), 1,
-      anon_sym_PIPE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    STATE(118), 1,
-      aux_sym_match_repeat1,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    STATE(271), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [6586] = 22,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(336), 1,
-      anon_sym_PIPE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    STATE(86), 1,
-      aux_sym_match_repeat1,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    STATE(272), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [6674] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(190), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(210), 1,
-      anon_sym_COLON,
-    STATE(230), 1,
-      sym_math_operator,
-    STATE(234), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(340), 9,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
       anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
       sym_float,
       sym_string,
       anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(342), 15,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [6739] = 12,
+      anon_sym_RBRACK,
+      anon_sym_DOT_DOT,
+  [6696] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(190), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(210), 1,
-      anon_sym_COLON,
-    ACTIONS(348), 1,
-      anon_sym_SEMI,
-    STATE(230), 1,
-      sym_math_operator,
-    STATE(234), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(344), 8,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(346), 15,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [6806] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(190), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(210), 1,
-      anon_sym_COLON,
-    STATE(230), 1,
-      sym_math_operator,
-    STATE(234), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(344), 9,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(346), 15,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [6871] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(190), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(210), 1,
-      anon_sym_COLON,
-    STATE(230), 1,
-      sym_math_operator,
-    STATE(234), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(350), 9,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(352), 15,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_PIPE,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [6936] = 16,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(356), 1,
-      sym_identifier,
-    ACTIONS(361), 1,
-      anon_sym_LBRACE,
-    ACTIONS(364), 1,
-      anon_sym_LPAREN,
-    ACTIONS(367), 1,
-      sym_integer,
-    ACTIONS(376), 1,
-      anon_sym_LBRACK,
-    ACTIONS(379), 1,
-      anon_sym_PIPE,
-    ACTIONS(382), 1,
-      anon_sym_table,
-    STATE(85), 1,
-      aux_sym_match_repeat1,
-    STATE(272), 1,
-      sym_expression,
-    ACTIONS(370), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(373), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(354), 4,
-      ts_builtin_sym_end,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_asyncfor,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    ACTIONS(359), 9,
-      anon_sym_async,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_return,
-      anon_sym_use,
-  [7008] = 16,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(85), 1,
-      aux_sym_match_repeat1,
-    STATE(272), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(385), 4,
-      ts_builtin_sym_end,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_asyncfor,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-    ACTIONS(387), 9,
-      anon_sym_async,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_return,
-      anon_sym_use,
-  [7080] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(296), 9,
+    ACTIONS(290), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
@@ -8111,7 +7688,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(294), 23,
+    ACTIONS(288), 23,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -8135,13 +7712,58 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [7120] = 5,
+  [6736] = 11,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(215), 1,
-      sym_math_operator,
-    STATE(216), 1,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(363), 1,
+      anon_sym_COLON,
+    STATE(204), 1,
       sym_logic_operator,
+    STATE(205), 1,
+      sym_math_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(226), 6,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(224), 9,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_DOT_DOT,
+  [6792] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(204), 1,
+      sym_logic_operator,
+    STATE(205), 1,
+      sym_math_operator,
     ACTIONS(208), 9,
       sym_identifier,
       sym_integer,
@@ -8174,16 +7796,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [7164] = 6,
+  [6836] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(391), 1,
-      anon_sym_COLON,
-    STATE(215), 1,
-      sym_math_operator,
-    STATE(216), 1,
-      sym_logic_operator,
-    ACTIONS(194), 9,
+    ACTIONS(278), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
@@ -8193,210 +7809,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(192), 20,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7210] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(391), 1,
-      anon_sym_COLON,
-    STATE(215), 1,
-      sym_math_operator,
-    STATE(216), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(204), 6,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(202), 9,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_DOT_DOT,
-  [7266] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(215), 1,
-      sym_math_operator,
-    STATE(216), 1,
-      sym_logic_operator,
-    ACTIONS(198), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(196), 21,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7310] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(391), 1,
-      anon_sym_COLON,
-    STATE(215), 1,
-      sym_math_operator,
-    STATE(216), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(178), 6,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(176), 9,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_DOT_DOT,
-  [7366] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(393), 1,
-      anon_sym_DOT_DOT,
-    STATE(215), 1,
-      sym_math_operator,
-    STATE(216), 1,
-      sym_logic_operator,
-    ACTIONS(198), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(196), 20,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7412] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(260), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(258), 23,
+    ACTIONS(276), 23,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -8420,42 +7833,26 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [7452] = 11,
+  [6876] = 6,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(246), 1,
       anon_sym_COLON,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
+    STATE(173), 1,
       sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(178), 6,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(222), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(176), 8,
+    ACTIONS(220), 19,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
@@ -8464,13 +7861,112 @@ static const uint16_t ts_small_parse_table[] = {
       sym_string,
       anon_sym_LBRACK,
       anon_sym_RBRACK,
-  [7507] = 5,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [6921] = 11,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
+    ACTIONS(182), 1,
+      anon_sym_COLON,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
       sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(214), 6,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(212), 8,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+  [6976] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(182), 1,
+      anon_sym_COLON,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(226), 6,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(224), 8,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+  [7031] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
     ACTIONS(208), 9,
       sym_identifier,
       sym_integer,
@@ -8502,60 +7998,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [7550] = 11,
+  [7074] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(204), 6,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(202), 8,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-  [7605] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    ACTIONS(194), 9,
+    ACTIONS(270), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
@@ -8565,40 +8011,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(192), 19,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7650] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(302), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(300), 21,
+    ACTIONS(268), 21,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
@@ -8620,10 +8033,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [7688] = 3,
+  [7112] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(276), 9,
+    ACTIONS(294), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
@@ -8633,7 +8046,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(274), 21,
+    ACTIONS(292), 21,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
@@ -8655,296 +8068,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [7726] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(228), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(226), 21,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7764] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(224), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(222), 21,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7802] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(306), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(304), 21,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7840] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(264), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(262), 21,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7878] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(280), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(278), 21,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7916] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(284), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(282), 21,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7954] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(292), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(290), 21,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [7992] = 12,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(246), 1,
-      anon_sym_COLON,
-    ACTIONS(252), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(399), 1,
-      anon_sym_COMMA,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
-      sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(395), 6,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(397), 6,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-  [8048] = 3,
+  [7150] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(314), 9,
@@ -8979,10 +8103,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [8086] = 3,
+  [7188] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(288), 9,
+    ACTIONS(266), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
@@ -8992,7 +8116,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(286), 21,
+    ACTIONS(264), 21,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
@@ -9014,10 +8138,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [8124] = 3,
+  [7226] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(324), 9,
+    ACTIONS(254), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
@@ -9027,7 +8151,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(322), 21,
+    ACTIONS(252), 21,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
@@ -9049,7 +8173,182 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [8162] = 3,
+  [7264] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(298), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(296), 21,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [7302] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(302), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(300), 21,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [7340] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(282), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(280), 21,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [7378] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(262), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(260), 21,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [7416] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(286), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(284), 21,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [7454] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(310), 9,
@@ -9084,10 +8383,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [8200] = 3,
+  [7492] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(256), 9,
+    ACTIONS(274), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
@@ -9097,7 +8396,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(254), 21,
+    ACTIONS(272), 21,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
@@ -9119,22 +8418,22 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [8238] = 12,
+  [7530] = 12,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(246), 1,
       anon_sym_COLON,
-    ACTIONS(252), 1,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(196), 1,
       anon_sym_DASH_GT,
-    ACTIONS(405), 1,
+    ACTIONS(371), 1,
       anon_sym_COMMA,
-    STATE(178), 1,
-      sym_logic_operator,
-    STATE(179), 1,
+    STATE(173), 1,
       sym_math_operator,
-    ACTIONS(188), 2,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -9142,31 +8441,31 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-    ACTIONS(401), 6,
+    ACTIONS(367), 6,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(403), 6,
+    ACTIONS(369), 6,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
-      anon_sym_RPAREN,
       sym_float,
       sym_string,
       anon_sym_LBRACK,
-  [8294] = 3,
+      anon_sym_RBRACK,
+  [7586] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(268), 9,
+    ACTIONS(258), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
@@ -9176,7 +8475,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT,
       anon_sym_PIPE,
       anon_sym_table,
-    ACTIONS(266), 21,
+    ACTIONS(256), 21,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
@@ -9198,57 +8497,221 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [8332] = 7,
+  [7624] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(411), 1,
-      anon_sym_elseif,
-    ACTIONS(413), 1,
-      anon_sym_else,
-    STATE(172), 1,
-      sym_else,
-    STATE(119), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(407), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(409), 14,
-      anon_sym_async,
+    ACTIONS(306), 9,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
       anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [8377] = 7,
+    ACTIONS(304), 21,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [7662] = 12,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(411), 1,
+    ACTIONS(182), 1,
+      anon_sym_COLON,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(196), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(377), 1,
+      anon_sym_COMMA,
+    STATE(173), 1,
+      sym_math_operator,
+    STATE(174), 1,
+      sym_logic_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(373), 6,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(375), 6,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+  [7718] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(334), 1,
+      sym_identifier,
+    ACTIONS(339), 1,
+      anon_sym_LBRACE,
+    ACTIONS(342), 1,
+      anon_sym_LPAREN,
+    ACTIONS(345), 1,
+      sym_integer,
+    ACTIONS(354), 1,
+      anon_sym_LBRACK,
+    ACTIONS(357), 1,
+      anon_sym_PIPE,
+    ACTIONS(360), 1,
+      anon_sym_table,
+    STATE(112), 1,
+      aux_sym_match_repeat1,
+    STATE(260), 1,
+      sym_expression,
+    ACTIONS(348), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(351), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(332), 3,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [7778] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(112), 1,
+      aux_sym_match_repeat1,
+    STATE(260), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    ACTIONS(326), 3,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [7838] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(379), 1,
+      anon_sym_RPAREN,
+    ACTIONS(302), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(300), 17,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_COLON,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [7875] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(385), 1,
       anon_sym_elseif,
-    ACTIONS(413), 1,
+    ACTIONS(387), 1,
       anon_sym_else,
-    STATE(245), 1,
+    STATE(232), 1,
       sym_else,
     STATE(116), 2,
       sym_else_if,
       aux_sym_if_else_repeat1,
-    ACTIONS(415), 10,
+    ACTIONS(381), 10,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -9259,7 +8722,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LBRACK,
       anon_sym_asyncfor,
       anon_sym_PIPE,
-    ACTIONS(417), 14,
+    ACTIONS(383), 12,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -9269,65 +8732,22 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-  [8422] = 15,
+  [7918] = 7,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(120), 1,
-      aux_sym_match_repeat1,
-    STATE(271), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    ACTIONS(385), 3,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [8482] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(423), 1,
+    ACTIONS(385), 1,
       anon_sym_elseif,
-    STATE(119), 2,
+    ACTIONS(387), 1,
+      anon_sym_else,
+    STATE(230), 1,
+      sym_else,
+    STATE(143), 2,
       sym_else_if,
       aux_sym_if_else_repeat1,
-    ACTIONS(419), 10,
+    ACTIONS(389), 10,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -9338,60 +8758,121 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LBRACK,
       anon_sym_asyncfor,
       anon_sym_PIPE,
-    ACTIONS(421), 15,
+    ACTIONS(391), 12,
       anon_sym_async,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_if,
-      anon_sym_else,
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-  [8522] = 15,
+  [7961] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(356), 1,
+    ACTIONS(393), 1,
+      anon_sym_RPAREN,
+    ACTIONS(302), 9,
       sym_identifier,
-    ACTIONS(361), 1,
-      anon_sym_LBRACE,
-    ACTIONS(364), 1,
-      anon_sym_LPAREN,
-    ACTIONS(367), 1,
       sym_integer,
-    ACTIONS(376), 1,
-      anon_sym_LBRACK,
-    ACTIONS(379), 1,
-      anon_sym_PIPE,
-    ACTIONS(382), 1,
-      anon_sym_table,
-    STATE(120), 1,
-      aux_sym_match_repeat1,
-    STATE(271), 1,
-      sym_expression,
-    ACTIONS(370), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(373), 2,
       anon_sym_true,
       anon_sym_false,
-    ACTIONS(354), 3,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-    STATE(133), 5,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(300), 17,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_COLON,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [7998] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(395), 1,
+      anon_sym_RPAREN,
+    ACTIONS(302), 9,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_PIPE,
+      anon_sym_table,
+    ACTIONS(300), 17,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_COLON,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [8035] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(397), 1,
+      anon_sym_RBRACK,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(108), 1,
+      sym_expression,
+    STATE(125), 1,
+      aux_sym_list_repeat1,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(150), 7,
+    STATE(102), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -9399,14 +8880,10 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [8582] = 5,
+  [8093] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(194), 1,
-      sym_math_operator,
-    STATE(232), 1,
-      sym_logic_operator,
-    ACTIONS(198), 7,
+    ACTIONS(282), 7,
       anon_sym_async,
       sym_identifier,
       anon_sym_EQ,
@@ -9414,7 +8891,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(196), 18,
+    ACTIONS(280), 19,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -9432,369 +8909,44 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT_EQ,
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
+      anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [8621] = 4,
+  [8127] = 15,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(426), 1,
-      anon_sym_RPAREN,
-    ACTIONS(324), 9,
+    ACTIONS(166), 1,
       sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(322), 17,
+    ACTIONS(168), 1,
       anon_sym_LBRACE,
+    ACTIONS(170), 1,
       anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_COLON,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [8658] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(428), 1,
-      anon_sym_RPAREN,
-    ACTIONS(324), 9,
-      sym_identifier,
+    ACTIONS(174), 1,
       sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
-      anon_sym_table,
-    ACTIONS(322), 17,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
+    ACTIONS(180), 1,
       anon_sym_LBRACK,
-      anon_sym_COLON,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [8695] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(430), 1,
-      anon_sym_COLON,
-    STATE(194), 1,
-      sym_math_operator,
-    STATE(232), 1,
-      sym_logic_operator,
-    ACTIONS(194), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(192), 17,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_DASH_GT,
-  [8736] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(430), 1,
-      anon_sym_COLON,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    STATE(194), 1,
-      sym_math_operator,
-    STATE(232), 1,
-      sym_logic_operator,
-    ACTIONS(182), 2,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(178), 3,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-    ACTIONS(184), 3,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(176), 7,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-  [8787] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(434), 1,
-      anon_sym_RPAREN,
-    ACTIONS(324), 9,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_PIPE,
+    ACTIONS(194), 1,
       anon_sym_table,
-    ACTIONS(322), 17,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_COLON,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [8824] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(436), 1,
-      anon_sym_DOT_DOT,
-    STATE(194), 1,
-      sym_math_operator,
-    STATE(232), 1,
-      sym_logic_operator,
-    ACTIONS(198), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(196), 17,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_DASH_GT,
-  [8865] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(430), 1,
-      anon_sym_COLON,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    STATE(194), 1,
-      sym_math_operator,
-    STATE(232), 1,
-      sym_logic_operator,
-    ACTIONS(182), 2,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 3,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(204), 3,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(202), 7,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-  [8916] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(194), 1,
-      sym_math_operator,
-    STATE(232), 1,
-      sym_logic_operator,
-    ACTIONS(208), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(206), 18,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_DASH_GT,
-  [8955] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(438), 1,
-      anon_sym_RPAREN,
-    ACTIONS(440), 1,
+    ACTIONS(399), 1,
       anon_sym_PIPE,
-    STATE(114), 1,
-      sym_expression,
-    STATE(158), 1,
-      aux_sym__expression_list,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [9013] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(442), 1,
+    ACTIONS(401), 1,
       anon_sym_RBRACK,
     STATE(108), 1,
       sym_expression,
-    STATE(141), 1,
+    STATE(133), 1,
       aux_sym_list_repeat1,
-    ACTIONS(240), 2,
+    ACTIONS(176), 2,
       sym_float,
       sym_string,
-    ACTIONS(242), 2,
+    ACTIONS(178), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(99), 5,
+    STATE(106), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(111), 7,
+    STATE(102), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -9802,7 +8954,561 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [9071] = 3,
+  [8185] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(258), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(256), 19,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [8219] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(294), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(292), 19,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [8253] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(254), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(252), 19,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [8287] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(406), 1,
+      anon_sym_LBRACE,
+    ACTIONS(409), 1,
+      anon_sym_LPAREN,
+    ACTIONS(412), 1,
+      sym_integer,
+    ACTIONS(421), 1,
+      anon_sym_LBRACK,
+    ACTIONS(424), 1,
+      anon_sym_RBRACK,
+    ACTIONS(426), 1,
+      anon_sym_PIPE,
+    ACTIONS(429), 1,
+      anon_sym_table,
+    STATE(108), 1,
+      sym_expression,
+    STATE(125), 1,
+      aux_sym_list_repeat1,
+    ACTIONS(415), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(418), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8345] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(432), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(135), 1,
+      aux_sym__expression_list,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8403] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(434), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(135), 1,
+      aux_sym__expression_list,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8461] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(436), 1,
+      anon_sym_RBRACK,
+    STATE(108), 1,
+      sym_expression,
+    STATE(125), 1,
+      aux_sym_list_repeat1,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8519] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(438), 1,
+      anon_sym_RBRACK,
+    STATE(108), 1,
+      sym_expression,
+    STATE(128), 1,
+      aux_sym_list_repeat1,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8577] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(440), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(135), 1,
+      aux_sym__expression_list,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8635] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(442), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(135), 1,
+      aux_sym__expression_list,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8693] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(444), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(135), 1,
+      aux_sym__expression_list,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8751] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(446), 1,
+      anon_sym_RBRACK,
+    STATE(108), 1,
+      sym_expression,
+    STATE(125), 1,
+      aux_sym_list_repeat1,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8809] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(266), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(264), 19,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [8843] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(448), 1,
+      sym_identifier,
+    ACTIONS(451), 1,
+      anon_sym_LBRACE,
+    ACTIONS(454), 1,
+      anon_sym_LPAREN,
+    ACTIONS(457), 1,
+      anon_sym_RPAREN,
+    ACTIONS(459), 1,
+      sym_integer,
+    ACTIONS(468), 1,
+      anon_sym_LBRACK,
+    ACTIONS(471), 1,
+      anon_sym_PIPE,
+    ACTIONS(474), 1,
+      anon_sym_table,
+    STATE(111), 1,
+      sym_expression,
+    STATE(135), 1,
+      aux_sym__expression_list,
+    ACTIONS(462), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(465), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [8901] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(306), 7,
@@ -9833,10 +9539,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [9105] = 3,
+  [8935] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(302), 7,
+    ACTIONS(298), 7,
       anon_sym_async,
       sym_identifier,
       anon_sym_EQ,
@@ -9844,7 +9550,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(300), 19,
+    ACTIONS(296), 19,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -9864,10 +9570,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [9139] = 3,
+  [8969] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(224), 7,
+    ACTIONS(274), 7,
       anon_sym_async,
       sym_identifier,
       anon_sym_EQ,
@@ -9875,7 +9581,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(222), 19,
+    ACTIONS(272), 19,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -9895,104 +9601,42 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [9173] = 3,
+  [9003] = 15,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(280), 7,
-      anon_sym_async,
+    ACTIONS(166), 1,
       sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(278), 19,
+    ACTIONS(168), 1,
       anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [9207] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(284), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(282), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [9241] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
+    ACTIONS(170), 1,
       anon_sym_LPAREN,
-    ACTIONS(238), 1,
+    ACTIONS(174), 1,
       sym_integer,
-    ACTIONS(244), 1,
+    ACTIONS(180), 1,
       anon_sym_LBRACK,
-    ACTIONS(250), 1,
+    ACTIONS(194), 1,
       anon_sym_table,
-    ACTIONS(440), 1,
+    ACTIONS(399), 1,
       anon_sym_PIPE,
-    ACTIONS(444), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
+    ACTIONS(477), 1,
+      anon_sym_RBRACK,
+    STATE(108), 1,
       sym_expression,
-    STATE(158), 1,
-      aux_sym__expression_list,
-    ACTIONS(240), 2,
+    STATE(119), 1,
+      aux_sym_list_repeat1,
+    ACTIONS(176), 2,
       sym_float,
       sym_string,
-    ACTIONS(242), 2,
+    ACTIONS(178), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(99), 5,
+    STATE(106), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(111), 7,
+    STATE(102), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -10000,83 +9644,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [9299] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(446), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(158), 1,
-      aux_sym__expression_list,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [9357] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(190), 1,
-      sym_logic_operator,
-    STATE(198), 1,
-      sym_math_operator,
-    ACTIONS(208), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(206), 17,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_DASH_GT,
-  [9395] = 3,
+  [9061] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(314), 7,
@@ -10107,53 +9675,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [9429] = 15,
+  [9095] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(448), 1,
-      anon_sym_RBRACK,
-    STATE(108), 1,
-      sym_expression,
-    STATE(146), 1,
-      aux_sym_list_repeat1,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [9487] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(288), 7,
+    ACTIONS(286), 7,
       anon_sym_async,
       sym_identifier,
       anon_sym_EQ,
@@ -10161,7 +9686,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(286), 19,
+    ACTIONS(284), 19,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -10181,10 +9706,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [9521] = 3,
+  [9129] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(292), 7,
+    ACTIONS(270), 7,
       anon_sym_async,
       sym_identifier,
       anon_sym_EQ,
@@ -10192,7 +9717,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(290), 19,
+    ACTIONS(268), 19,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -10212,325 +9737,15 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [9555] = 3,
+  [9163] = 5,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(228), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(226), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [9589] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(450), 11,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_elseif,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(452), 15,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [9623] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(454), 1,
-      sym_identifier,
-    ACTIONS(457), 1,
-      anon_sym_LBRACE,
-    ACTIONS(460), 1,
-      anon_sym_LPAREN,
-    ACTIONS(463), 1,
-      sym_integer,
-    ACTIONS(472), 1,
-      anon_sym_LBRACK,
-    ACTIONS(475), 1,
-      anon_sym_RBRACK,
-    ACTIONS(477), 1,
-      anon_sym_PIPE,
-    ACTIONS(480), 1,
-      anon_sym_table,
-    STATE(108), 1,
-      sym_expression,
-    STATE(146), 1,
-      aux_sym_list_repeat1,
-    ACTIONS(466), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(469), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [9681] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(264), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(262), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [9715] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(256), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(254), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [9749] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
     ACTIONS(483), 1,
-      anon_sym_RBRACK,
-    STATE(108), 1,
-      sym_expression,
-    STATE(146), 1,
-      aux_sym_list_repeat1,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [9807] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(324), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(322), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [9841] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(276), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(274), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [9875] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(485), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(158), 1,
-      aux_sym__expression_list,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [9933] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(258), 11,
+      anon_sym_elseif,
+    STATE(143), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(479), 10,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -10539,10 +9754,9 @@ static const uint16_t ts_small_parse_table[] = {
       sym_float,
       sym_string,
       anon_sym_LBRACK,
-      anon_sym_elseif,
       anon_sym_asyncfor,
       anon_sym_PIPE,
-    ACTIONS(260), 15,
+    ACTIONS(481), 13,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -10553,12 +9767,84 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-  [9967] = 3,
+  [9201] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(302), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(300), 19,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [9235] = 15,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(486), 1,
+      anon_sym_RPAREN,
+    STATE(111), 1,
+      sym_expression,
+    STATE(135), 1,
+      aux_sym__expression_list,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [9293] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(310), 7,
@@ -10589,67 +9875,150 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_DASH_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [10001] = 15,
+  [9327] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(230), 1,
+    ACTIONS(262), 7,
+      anon_sym_async,
       sym_identifier,
-    ACTIONS(232), 1,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(260), 19,
       anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(487), 1,
-      anon_sym_RBRACK,
-    STATE(108), 1,
-      sym_expression,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [9361] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(278), 6,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_else,
+    ACTIONS(276), 19,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_elseif,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [9394] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(488), 1,
+      anon_sym_DOT_DOT,
+    STATE(158), 1,
+      sym_logic_operator,
     STATE(159), 1,
-      aux_sym_list_repeat1,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [10059] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(268), 7,
-      anon_sym_async,
-      sym_identifier,
+      sym_math_operator,
+    ACTIONS(130), 5,
       anon_sym_EQ,
       anon_sym_PLUS,
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(266), 19,
+    ACTIONS(128), 17,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_COLON,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_DASH_GT,
+  [9433] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(290), 6,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_else,
+    ACTIONS(288), 19,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
       anon_sym_COLON,
       anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_elseif,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [9466] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(158), 1,
+      sym_logic_operator,
+    STATE(159), 1,
+      sym_math_operator,
+    ACTIONS(208), 5,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(206), 18,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
@@ -10661,44 +10030,180 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT_EQ,
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [10093] = 15,
+  [9503] = 5,
     ACTIONS(3), 1,
       sym__comment,
+    STATE(158), 1,
+      sym_logic_operator,
+    STATE(159), 1,
+      sym_math_operator,
+    ACTIONS(130), 5,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(128), 18,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_DASH_GT,
+  [9540] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(226), 1,
+      anon_sym_EQ,
+    ACTIONS(490), 1,
+      anon_sym_COLON,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    STATE(158), 1,
+      sym_logic_operator,
+    STATE(159), 1,
+      sym_math_operator,
+    ACTIONS(186), 2,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(224), 7,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [9589] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(490), 1,
+      anon_sym_COLON,
+    STATE(158), 1,
+      sym_logic_operator,
+    STATE(159), 1,
+      sym_math_operator,
+    ACTIONS(222), 5,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(220), 17,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_DASH_GT,
+  [9628] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(214), 1,
+      anon_sym_EQ,
+    ACTIONS(490), 1,
+      anon_sym_COLON,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    STATE(158), 1,
+      sym_logic_operator,
+    STATE(159), 1,
+      sym_math_operator,
+    ACTIONS(186), 2,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(212), 7,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [9677] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
     ACTIONS(230), 1,
       sym_identifier,
     ACTIONS(232), 1,
       anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
+    ACTIONS(236), 1,
       anon_sym_table,
-    ACTIONS(440), 1,
+    ACTIONS(330), 1,
       anon_sym_PIPE,
-    ACTIONS(489), 1,
-      anon_sym_RBRACK,
-    STATE(108), 1,
+    STATE(251), 1,
       sym_expression,
-    STATE(149), 1,
-      aux_sym_list_repeat1,
-    ACTIONS(240), 2,
+    ACTIONS(142), 2,
       sym_float,
       sym_string,
-    ACTIONS(242), 2,
+    ACTIONS(144), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(99), 5,
+    STATE(146), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(111), 7,
+    STATE(144), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -10706,42 +10211,67 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [10151] = 15,
+  [9729] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(491), 1,
+    ACTIONS(276), 11,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(278), 13,
+      anon_sym_async,
       sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [9761] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
     ACTIONS(494), 1,
-      anon_sym_LBRACE,
-    ACTIONS(497), 1,
-      anon_sym_LPAREN,
-    ACTIONS(500), 1,
-      anon_sym_RPAREN,
-    ACTIONS(502), 1,
-      sym_integer,
-    ACTIONS(511), 1,
-      anon_sym_LBRACK,
-    ACTIONS(514), 1,
-      anon_sym_PIPE,
-    ACTIONS(517), 1,
       anon_sym_table,
-    STATE(114), 1,
+    STATE(155), 1,
       sym_expression,
-    STATE(158), 1,
-      aux_sym__expression_list,
-    ACTIONS(505), 2,
+    ACTIONS(142), 2,
       sym_float,
       sym_string,
-    ACTIONS(508), 2,
+    ACTIONS(144), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(99), 5,
+    STATE(146), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(111), 7,
+    STATE(144), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -10749,519 +10279,116 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [10209] = 15,
+  [9813] = 13,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
+    ACTIONS(138), 1,
       anon_sym_LPAREN,
-    ACTIONS(238), 1,
+    ACTIONS(140), 1,
       sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(520), 1,
-      anon_sym_RBRACK,
-    STATE(108), 1,
-      sym_expression,
-    STATE(146), 1,
-      aux_sym_list_repeat1,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [10267] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(522), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(158), 1,
-      aux_sym__expression_list,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [10325] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(524), 11,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_elseif,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(526), 15,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [10359] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(528), 1,
-      anon_sym_COLON,
-    STATE(190), 1,
-      sym_logic_operator,
-    STATE(198), 1,
-      sym_math_operator,
-    ACTIONS(182), 2,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(178), 3,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-    ACTIONS(184), 3,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(176), 6,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [10409] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(294), 11,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_elseif,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(296), 15,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [10443] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(528), 1,
-      anon_sym_COLON,
-    STATE(190), 1,
-      sym_logic_operator,
-    STATE(198), 1,
-      sym_math_operator,
-    ACTIONS(194), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(192), 16,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_DASH_GT,
-  [10483] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(528), 1,
-      anon_sym_COLON,
-    STATE(190), 1,
-      sym_logic_operator,
-    STATE(198), 1,
-      sym_math_operator,
-    ACTIONS(182), 2,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 3,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(204), 3,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-    ACTIONS(202), 6,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-  [10533] = 15,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(530), 1,
-      anon_sym_RPAREN,
-    STATE(114), 1,
-      sym_expression,
-    STATE(158), 1,
-      aux_sym__expression_list,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [10591] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(260), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(258), 18,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_DASH_GT,
-  [10624] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(296), 7,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(294), 18,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_DASH_GT,
-  [10657] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(260), 6,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_else,
-    ACTIONS(258), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_elseif,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [10690] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(296), 6,
-      anon_sym_async,
-      sym_identifier,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_else,
-    ACTIONS(294), 19,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_elseif,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [10723] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(532), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(534), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [10755] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(536), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(538), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [10787] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
     ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
       anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(494), 1,
+      anon_sym_table,
+    STATE(154), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [9865] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(494), 1,
+      anon_sym_table,
+    STATE(153), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [9917] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
     ACTIONS(168), 1,
-      anon_sym_PIPE,
+      anon_sym_LBRACE,
     ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(496), 1,
       anon_sym_table,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    STATE(188), 1,
+    STATE(86), 1,
       sym_expression,
-    ACTIONS(148), 2,
+    ACTIONS(176), 2,
       sym_float,
       sym_string,
-    ACTIONS(150), 2,
+    ACTIONS(178), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(133), 5,
+    STATE(106), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(150), 7,
+    STATE(102), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -11269,349 +10396,7 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [10839] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    STATE(255), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [10891] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(259), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [10943] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    STATE(79), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [10995] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(267), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [11047] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    STATE(97), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [11099] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    STATE(98), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [11151] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(540), 1,
-      anon_sym_table,
-    STATE(93), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [11203] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    ACTIONS(542), 1,
-      anon_sym_table,
-    STATE(249), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [11255] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(348), 1,
-      anon_sym_SEMI,
-    ACTIONS(344), 9,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(346), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [11289] = 13,
+  [9969] = 13,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(11), 1,
@@ -11620,13 +10405,91 @@ static const uint16_t ts_small_parse_table[] = {
       sym_integer,
     ACTIONS(19), 1,
       anon_sym_LBRACK,
-    ACTIONS(35), 1,
+    ACTIONS(31), 1,
       anon_sym_PIPE,
-    ACTIONS(544), 1,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(498), 1,
       sym_identifier,
-    ACTIONS(546), 1,
+    ACTIONS(500), 1,
       anon_sym_LBRACE,
-    ACTIONS(548), 1,
+    STATE(59), 1,
+      sym_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10021] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(498), 1,
+      sym_identifier,
+    ACTIONS(500), 1,
+      anon_sym_LBRACE,
+    STATE(58), 1,
+      sym_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10073] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(498), 1,
+      sym_identifier,
+    ACTIONS(500), 1,
+      anon_sym_LBRACE,
+    ACTIONS(502), 1,
       anon_sym_table,
     STATE(42), 1,
       sym_expression,
@@ -11636,13 +10499,13 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 7,
+    STATE(74), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -11650,38 +10513,38 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11341] = 13,
+  [10125] = 13,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(144), 1,
+    ACTIONS(11), 1,
       anon_sym_LPAREN,
-    ACTIONS(146), 1,
+    ACTIONS(13), 1,
       sym_integer,
-    ACTIONS(152), 1,
+    ACTIONS(19), 1,
       anon_sym_LBRACK,
-    ACTIONS(168), 1,
+    ACTIONS(31), 1,
       anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(332), 1,
+    ACTIONS(498), 1,
       sym_identifier,
-    ACTIONS(334), 1,
+    ACTIONS(500), 1,
       anon_sym_LBRACE,
-    STATE(139), 1,
+    ACTIONS(502), 1,
+      anon_sym_table,
+    STATE(35), 1,
       sym_expression,
-    ACTIONS(148), 2,
+    ACTIONS(15), 2,
       sym_float,
       sym_string,
-    ACTIONS(150), 2,
+    ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(133), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(150), 7,
+    STATE(74), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -11689,38 +10552,77 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11393] = 13,
+  [10177] = 13,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(33), 1,
+      anon_sym_table,
+    ACTIONS(498), 1,
+      sym_identifier,
+    ACTIONS(500), 1,
+      anon_sym_LBRACE,
+    STATE(56), 1,
+      sym_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10229] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
     ACTIONS(230), 1,
       sym_identifier,
     ACTIONS(232), 1,
       anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
+    ACTIONS(330), 1,
       anon_sym_PIPE,
-    STATE(95), 1,
+    ACTIONS(504), 1,
+      anon_sym_table,
+    STATE(243), 1,
       sym_expression,
-    ACTIONS(240), 2,
+    ACTIONS(142), 2,
       sym_float,
       sym_string,
-    ACTIONS(242), 2,
+    ACTIONS(144), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(99), 5,
+    STATE(146), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(111), 7,
+    STATE(144), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -11728,7 +10630,46 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11445] = 13,
+  [10281] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(94), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10333] = 13,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(11), 1,
@@ -11737,15 +10678,15 @@ static const uint16_t ts_small_parse_table[] = {
       sym_integer,
     ACTIONS(19), 1,
       anon_sym_LBRACK,
-    ACTIONS(35), 1,
+    ACTIONS(31), 1,
       anon_sym_PIPE,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    ACTIONS(548), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    STATE(43), 1,
+    ACTIONS(498), 1,
+      sym_identifier,
+    ACTIONS(500), 1,
+      anon_sym_LBRACE,
+    STATE(60), 1,
       sym_expression,
     ACTIONS(15), 2,
       sym_float,
@@ -11753,13 +10694,13 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 7,
+    STATE(74), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -11767,156 +10708,108 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11497] = 13,
+  [10385] = 13,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(11), 1,
+    ACTIONS(138), 1,
       anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    ACTIONS(548), 1,
-      anon_sym_table,
-    STATE(46), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [11549] = 14,
-    ACTIONS(3), 1,
-      sym__comment,
     ACTIONS(140), 1,
-      anon_sym_async,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(328), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(230), 1,
       sym_identifier,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(528), 1,
-      anon_sym_COLON,
-    ACTIONS(550), 1,
+    ACTIONS(232), 1,
       anon_sym_LBRACE,
-    STATE(190), 1,
+    ACTIONS(494), 1,
+      anon_sym_table,
+    STATE(152), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10437] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(182), 1,
       sym_logic_operator,
-    STATE(198), 1,
+    STATE(183), 1,
       sym_math_operator,
-    STATE(304), 1,
-      sym_block,
-    ACTIONS(188), 2,
+    ACTIONS(208), 5,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(326), 3,
+    ACTIONS(206), 17,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
+      sym_identifier,
+      anon_sym_COLON,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [11603] = 13,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_DASH_GT,
+  [10473] = 13,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(230), 1,
+    ACTIONS(166), 1,
       sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(540), 1,
-      anon_sym_table,
-    STATE(91), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [11655] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
     ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
       anon_sym_LBRACE,
-    STATE(165), 1,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(496), 1,
+      anon_sym_table,
+    STATE(85), 1,
       sym_expression,
-    ACTIONS(148), 2,
+    ACTIONS(176), 2,
       sym_float,
       sym_string,
-    ACTIONS(150), 2,
+    ACTIONS(178), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(133), 5,
+    STATE(106), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(150), 7,
+    STATE(102), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -11924,38 +10817,116 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11707] = 13,
+  [10525] = 13,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(92), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10577] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(93), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10629] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
     ACTIONS(230), 1,
       sym_identifier,
     ACTIONS(232), 1,
       anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    STATE(96), 1,
+    STATE(171), 1,
       sym_expression,
-    ACTIONS(240), 2,
+    ACTIONS(142), 2,
       sym_float,
       sym_string,
-    ACTIONS(242), 2,
+    ACTIONS(144), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(99), 5,
+    STATE(146), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(111), 7,
+    STATE(144), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -11963,7 +10934,707 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11759] = 13,
+  [10681] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(214), 1,
+      anon_sym_EQ,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(506), 1,
+      anon_sym_COLON,
+    STATE(182), 1,
+      sym_logic_operator,
+    STATE(183), 1,
+      sym_math_operator,
+    ACTIONS(186), 2,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(212), 6,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [10729] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(506), 1,
+      anon_sym_COLON,
+    STATE(182), 1,
+      sym_logic_operator,
+    STATE(183), 1,
+      sym_math_operator,
+    ACTIONS(222), 5,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(220), 16,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_DASH_GT,
+  [10767] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(288), 11,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(290), 13,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [10799] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(508), 1,
+      sym_identifier,
+    STATE(53), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(117), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10851] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(46), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [10903] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(226), 1,
+      anon_sym_EQ,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(506), 1,
+      anon_sym_COLON,
+    STATE(182), 1,
+      sym_logic_operator,
+    STATE(183), 1,
+      sym_math_operator,
+    ACTIONS(186), 2,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 3,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+    ACTIONS(224), 6,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [10951] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    STATE(176), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11003] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    STATE(177), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11055] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(494), 1,
+      anon_sym_table,
+    STATE(149), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11107] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(158), 1,
+      anon_sym_PIPE,
+    ACTIONS(160), 1,
+      anon_sym_table,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    STATE(181), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11159] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(510), 1,
+      sym_identifier,
+    STATE(37), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(118), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11211] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(512), 11,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(514), 13,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [11243] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(256), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11295] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(257), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11347] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(246), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11399] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(54), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11451] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(516), 11,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(518), 13,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [11483] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(255), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11535] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(41), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11587] = 13,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(11), 1,
@@ -11972,15 +11643,15 @@ static const uint16_t ts_small_parse_table[] = {
       sym_integer,
     ACTIONS(19), 1,
       anon_sym_LBRACK,
-    ACTIONS(35), 1,
+    ACTIONS(31), 1,
       anon_sym_PIPE,
-    ACTIONS(37), 1,
+    ACTIONS(33), 1,
       anon_sym_table,
-    ACTIONS(544), 1,
+    ACTIONS(498), 1,
       sym_identifier,
-    ACTIONS(546), 1,
+    ACTIONS(500), 1,
       anon_sym_LBRACE,
-    STATE(81), 1,
+    STATE(79), 1,
       sym_expression,
     ACTIONS(15), 2,
       sym_float,
@@ -11988,13 +11659,13 @@ static const uint16_t ts_small_parse_table[] = {
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(70), 5,
+    STATE(77), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(77), 7,
+    STATE(74), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -12002,38 +11673,38 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11811] = 13,
+  [11639] = 13,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
     ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
       anon_sym_LBRACE,
-    ACTIONS(552), 1,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
       anon_sym_table,
-    STATE(125), 1,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(520), 1,
+      sym_identifier,
+    STATE(43), 1,
       sym_expression,
-    ACTIONS(148), 2,
+    ACTIONS(176), 2,
       sym_float,
       sym_string,
-    ACTIONS(150), 2,
+    ACTIONS(178), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(133), 5,
+    STATE(106), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(150), 7,
+    STATE(114), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -12041,38 +11712,38 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11863] = 13,
+  [11691] = 13,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(144), 1,
+    ACTIONS(138), 1,
       anon_sym_LPAREN,
-    ACTIONS(146), 1,
+    ACTIONS(140), 1,
       sym_integer,
-    ACTIONS(152), 1,
+    ACTIONS(146), 1,
       anon_sym_LBRACK,
-    ACTIONS(168), 1,
+    ACTIONS(158), 1,
       anon_sym_PIPE,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(552), 1,
+    ACTIONS(160), 1,
       anon_sym_table,
-    STATE(124), 1,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    STATE(240), 1,
       sym_expression,
-    ACTIONS(148), 2,
+    ACTIONS(142), 2,
       sym_float,
       sym_string,
-    ACTIONS(150), 2,
+    ACTIONS(144), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(133), 5,
+    STATE(146), 5,
       sym_boolean,
       sym_list,
       sym_map,
       sym_table,
       sym_function,
-    STATE(150), 7,
+    STATE(144), 7,
       sym__expression_kind,
       sym_value,
       sym_index,
@@ -12080,10 +11751,939 @@ static const uint16_t ts_small_parse_table[] = {
       sym_logic,
       sym_function_call,
       sym_yield,
-  [11915] = 3,
+  [11743] = 8,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(344), 10,
+    ACTIONS(244), 1,
+      anon_sym_EQ,
+    ACTIONS(246), 1,
+      anon_sym_LT,
+    STATE(39), 1,
+      sym_assignment_operator,
+    STATE(299), 1,
+      sym_type_definition,
+    ACTIONS(248), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+    ACTIONS(242), 3,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+    ACTIONS(240), 15,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_COLON,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [11785] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    ACTIONS(504), 1,
+      anon_sym_table,
+    STATE(244), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11837] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(55), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11889] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(95), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11941] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    ACTIONS(504), 1,
+      anon_sym_table,
+    STATE(245), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [11993] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    ACTIONS(504), 1,
+      anon_sym_table,
+    STATE(241), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12045] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(496), 1,
+      anon_sym_table,
+    STATE(87), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12097] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(496), 1,
+      anon_sym_table,
+    STATE(84), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12149] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    ACTIONS(496), 1,
+      anon_sym_table,
+    STATE(89), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12201] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(166), 1,
+      sym_identifier,
+    ACTIONS(168), 1,
+      anon_sym_LBRACE,
+    ACTIONS(170), 1,
+      anon_sym_LPAREN,
+    ACTIONS(174), 1,
+      sym_integer,
+    ACTIONS(180), 1,
+      anon_sym_LBRACK,
+    ACTIONS(194), 1,
+      anon_sym_table,
+    ACTIONS(399), 1,
+      anon_sym_PIPE,
+    STATE(49), 1,
+      sym_expression,
+    ACTIONS(176), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(178), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(106), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(102), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12253] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(254), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12305] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(253), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12357] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(248), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12409] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    ACTIONS(504), 1,
+      anon_sym_table,
+    STATE(238), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12461] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(249), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12513] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(250), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12565] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(252), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12617] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(498), 1,
+      sym_identifier,
+    ACTIONS(500), 1,
+      anon_sym_LBRACE,
+    ACTIONS(502), 1,
+      anon_sym_table,
+    STATE(50), 1,
+      sym_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12669] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(498), 1,
+      sym_identifier,
+    ACTIONS(500), 1,
+      anon_sym_LBRACE,
+    ACTIONS(502), 1,
+      anon_sym_table,
+    STATE(51), 1,
+      sym_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12721] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(11), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(31), 1,
+      anon_sym_PIPE,
+    ACTIONS(498), 1,
+      sym_identifier,
+    ACTIONS(500), 1,
+      anon_sym_LBRACE,
+    ACTIONS(502), 1,
+      anon_sym_table,
+    STATE(52), 1,
+      sym_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(77), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(74), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12773] = 13,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(138), 1,
+      anon_sym_LPAREN,
+    ACTIONS(140), 1,
+      sym_integer,
+    ACTIONS(146), 1,
+      anon_sym_LBRACK,
+    ACTIONS(230), 1,
+      sym_identifier,
+    ACTIONS(232), 1,
+      anon_sym_LBRACE,
+    ACTIONS(236), 1,
+      anon_sym_table,
+    ACTIONS(330), 1,
+      anon_sym_PIPE,
+    STATE(247), 1,
+      sym_expression,
+    ACTIONS(142), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(144), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(146), 5,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_table,
+      sym_function,
+    STATE(144), 7,
+      sym__expression_kind,
+      sym_value,
+      sym_index,
+      sym_math,
+      sym_logic,
+      sym_function_call,
+      sym_yield,
+  [12825] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(290), 5,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(288), 18,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_DASH_GT,
+  [12856] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(278), 5,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(276), 18,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_DASH_GT,
+  [12887] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(244), 1,
+      anon_sym_EQ,
+    STATE(40), 1,
+      sym_assignment_operator,
+    ACTIONS(248), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+    ACTIONS(242), 4,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(240), 15,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+      anon_sym_COLON,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_DASH_GT,
+  [12924] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(324), 1,
+      anon_sym_SEMI,
+    ACTIONS(320), 9,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(322), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [12956] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(522), 10,
       ts_builtin_sym_end,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
@@ -12094,7 +12694,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LBRACK,
       anon_sym_asyncfor,
       anon_sym_PIPE,
-    ACTIONS(346), 14,
+    ACTIONS(524), 12,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -12104,124 +12704,307 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-  [11947] = 13,
+  [12986] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
+    ACTIONS(526), 10,
+      ts_builtin_sym_end,
       anon_sym_LBRACE,
-    STATE(254), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [11999] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(216), 1,
-      anon_sym_EQ,
-    ACTIONS(218), 1,
-      anon_sym_LT,
-    STATE(37), 1,
-      sym_assignment_operator,
-    STATE(301), 1,
-      sym_type,
-    ACTIONS(220), 2,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-    ACTIONS(214), 3,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-    ACTIONS(212), 15,
       anon_sym_RBRACE,
       anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-      anon_sym_COLON,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [12041] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
       anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    STATE(164), 1,
-      sym_expression,
-    ACTIONS(148), 2,
       sym_float,
       sym_string,
-    ACTIONS(150), 2,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(528), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
       anon_sym_true,
       anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12093] = 3,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13016] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(530), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(532), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13046] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(534), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(536), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13076] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(538), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(540), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13106] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(288), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(290), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13136] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(542), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(544), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13166] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(546), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(548), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13196] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(550), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(552), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13226] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(389), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(391), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13256] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(276), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(278), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13286] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(320), 10,
+      ts_builtin_sym_end,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(322), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [13316] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(554), 10,
@@ -12235,7 +13018,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LBRACK,
       anon_sym_asyncfor,
       anon_sym_PIPE,
-    ACTIONS(556), 14,
+    ACTIONS(556), 12,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -12245,12 +13028,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-  [12125] = 3,
+  [13346] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(558), 10,
@@ -12264,7 +13045,7 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LBRACK,
       anon_sym_asyncfor,
       anon_sym_PIPE,
-    ACTIONS(560), 14,
+    ACTIONS(560), 12,
       anon_sym_async,
       sym_identifier,
       sym_integer,
@@ -12274,1800 +13055,16 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
       anon_sym_table,
       anon_sym_return,
       anon_sym_use,
-  [12157] = 3,
+  [13376] = 5,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(562), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(564), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [12189] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(263), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12241] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(566), 1,
-      sym_identifier,
-    STATE(55), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(126), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12293] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    STATE(50), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12345] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(552), 1,
-      anon_sym_table,
-    STATE(127), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12397] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(264), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12449] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(260), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12501] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    ACTIONS(542), 1,
-      anon_sym_table,
-    STATE(248), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12553] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(265), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12605] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(266), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12657] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    STATE(69), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12709] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(170), 1,
-      anon_sym_table,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    STATE(162), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12761] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(540), 1,
-      anon_sym_table,
-    STATE(92), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12813] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(568), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(570), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [12845] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(540), 1,
-      anon_sym_table,
-    STATE(89), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12897] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(540), 1,
-      anon_sym_table,
-    STATE(90), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [12949] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    STATE(48), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13001] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(572), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(574), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [13033] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(269), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13085] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    ACTIONS(548), 1,
-      anon_sym_table,
-    STATE(44), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13137] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(258), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(260), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [13169] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(576), 1,
-      sym_identifier,
-    STATE(76), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(122), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13221] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(552), 1,
-      anon_sym_table,
-    STATE(121), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13273] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(262), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13325] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(578), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(580), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [13357] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    ACTIONS(548), 1,
-      anon_sym_table,
-    STATE(45), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13409] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(582), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(584), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [13441] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    STATE(62), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13493] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    ACTIONS(542), 1,
-      anon_sym_table,
-    STATE(257), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13545] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    STATE(52), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13597] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    ACTIONS(542), 1,
-      anon_sym_table,
-    STATE(256), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13649] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(168), 1,
-      anon_sym_PIPE,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(552), 1,
-      anon_sym_table,
-    STATE(128), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13701] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    ACTIONS(542), 1,
-      anon_sym_table,
-    STATE(252), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13753] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    STATE(51), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13805] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    STATE(84), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13857] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(11), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(35), 1,
-      anon_sym_PIPE,
-    ACTIONS(37), 1,
-      anon_sym_table,
-    ACTIONS(544), 1,
-      sym_identifier,
-    ACTIONS(546), 1,
-      anon_sym_LBRACE,
-    STATE(78), 1,
-      sym_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(70), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(77), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13909] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    ACTIONS(586), 1,
-      sym_identifier,
-    STATE(74), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(123), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [13961] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(270), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [14013] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(261), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [14065] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(588), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(590), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [14097] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    STATE(80), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [14149] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(230), 1,
-      sym_identifier,
-    ACTIONS(232), 1,
-      anon_sym_LBRACE,
-    ACTIONS(234), 1,
-      anon_sym_LPAREN,
-    ACTIONS(238), 1,
-      sym_integer,
-    ACTIONS(244), 1,
-      anon_sym_LBRACK,
-    ACTIONS(250), 1,
-      anon_sym_table,
-    ACTIONS(440), 1,
-      anon_sym_PIPE,
-    STATE(61), 1,
-      sym_expression,
-    ACTIONS(240), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(242), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(99), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(111), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [14201] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(592), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(594), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [14233] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(294), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(296), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [14265] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(407), 10,
-      ts_builtin_sym_end,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(409), 14,
-      anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [14297] = 13,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(144), 1,
-      anon_sym_LPAREN,
-    ACTIONS(146), 1,
-      sym_integer,
-    ACTIONS(152), 1,
-      anon_sym_LBRACK,
-    ACTIONS(332), 1,
-      sym_identifier,
-    ACTIONS(334), 1,
-      anon_sym_LBRACE,
-    ACTIONS(338), 1,
-      anon_sym_table,
-    ACTIONS(389), 1,
-      anon_sym_PIPE,
-    STATE(268), 1,
-      sym_expression,
-    ACTIONS(148), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(150), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(133), 5,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_table,
-      sym_function,
-    STATE(150), 7,
-      sym__expression_kind,
-      sym_value,
-      sym_index,
-      sym_math,
-      sym_logic,
-      sym_function_call,
-      sym_yield,
-  [14349] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(216), 1,
-      anon_sym_EQ,
-    STATE(40), 1,
-      sym_assignment_operator,
-    ACTIONS(220), 2,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-    ACTIONS(214), 4,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(212), 15,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-      anon_sym_COLON,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_DASH_GT,
-  [14386] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(596), 1,
-      anon_sym_DOT_DOT,
-    STATE(231), 1,
-      sym_math_operator,
-    STATE(233), 1,
+    STATE(199), 1,
       sym_logic_operator,
-    ACTIONS(198), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(196), 15,
-      anon_sym_async,
-      anon_sym_LBRACE,
-      anon_sym_COLON,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [14421] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(231), 1,
+    STATE(202), 1,
       sym_math_operator,
-    STATE(233), 1,
-      sym_logic_operator,
-    ACTIONS(198), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(196), 16,
-      anon_sym_async,
-      anon_sym_LBRACE,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-      anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [14454] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(231), 1,
-      sym_math_operator,
-    STATE(233), 1,
-      sym_logic_operator,
     ACTIONS(208), 3,
       anon_sym_DASH,
       anon_sym_GT,
@@ -14089,53 +13086,83 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [14487] = 10,
+  [13409] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(528), 1,
-      anon_sym_COLON,
-    STATE(190), 1,
+    ACTIONS(562), 1,
+      anon_sym_DOT_DOT,
+    STATE(199), 1,
       sym_logic_operator,
-    STATE(198), 1,
+    STATE(202), 1,
       sym_math_operator,
-    ACTIONS(188), 2,
+    ACTIONS(130), 3,
+      anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(184), 4,
+    ACTIONS(128), 15,
+      anon_sym_async,
+      anon_sym_LBRACE,
+      anon_sym_COLON,
       anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(344), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-    ACTIONS(186), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [14530] = 10,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [13444] = 11,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(432), 1,
+    ACTIONS(492), 1,
       anon_sym_DASH_GT,
-    ACTIONS(598), 1,
+    ACTIONS(506), 1,
       anon_sym_COLON,
-    STATE(231), 1,
-      sym_math_operator,
-    STATE(233), 1,
+    ACTIONS(564), 1,
+      anon_sym_SEMI,
+    STATE(182), 1,
       sym_logic_operator,
-    ACTIONS(188), 2,
+    STATE(183), 1,
+      sym_math_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(320), 3,
+      anon_sym_RBRACE,
+      anon_sym_COMMA,
+      sym_identifier,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+  [13489] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(506), 1,
+      anon_sym_COLON,
+    STATE(182), 1,
+      sym_logic_operator,
+    STATE(183), 1,
+      sym_math_operator,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -14143,58 +13170,126 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(202), 4,
+    ACTIONS(316), 4,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+  [13532] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(566), 1,
+      anon_sym_COLON,
+    STATE(199), 1,
+      sym_logic_operator,
+    STATE(202), 1,
+      sym_math_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(224), 4,
       anon_sym_async,
       anon_sym_LBRACE,
       anon_sym_DOT_DOT,
       anon_sym_EQ_GT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [14573] = 3,
+  [13575] = 10,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(602), 7,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-      anon_sym_PIPE,
-    ACTIONS(600), 14,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(506), 1,
+      anon_sym_COLON,
+    STATE(182), 1,
+      sym_logic_operator,
+    STATE(183), 1,
+      sym_math_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(320), 4,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+  [13618] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(199), 1,
+      sym_logic_operator,
+    STATE(202), 1,
+      sym_math_operator,
+    ACTIONS(130), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(128), 16,
       anon_sym_async,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_select,
-      anon_sym_insert,
-      anon_sym_table,
-      anon_sym_return,
-      anon_sym_use,
-  [14602] = 10,
+      anon_sym_LBRACE,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [13651] = 10,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(432), 1,
+    ACTIONS(492), 1,
       anon_sym_DASH_GT,
-    ACTIONS(528), 1,
+    ACTIONS(566), 1,
       anon_sym_COLON,
-    STATE(190), 1,
+    STATE(199), 1,
       sym_logic_operator,
-    STATE(198), 1,
+    STATE(202), 1,
       sym_math_operator,
-    ACTIONS(188), 2,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -14202,65 +13297,32 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(340), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-    ACTIONS(186), 6,
+    ACTIONS(212), 4,
+      anon_sym_async,
+      anon_sym_LBRACE,
+      anon_sym_DOT_DOT,
+      anon_sym_EQ_GT,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [14645] = 10,
+  [13694] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(528), 1,
+    ACTIONS(566), 1,
       anon_sym_COLON,
-    STATE(190), 1,
+    STATE(199), 1,
       sym_logic_operator,
-    STATE(198), 1,
+    STATE(202), 1,
       sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(350), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [14688] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(598), 1,
-      anon_sym_COLON,
-    STATE(231), 1,
-      sym_math_operator,
-    STATE(233), 1,
-      sym_logic_operator,
-    ACTIONS(194), 3,
+    ACTIONS(222), 3,
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(192), 15,
+    ACTIONS(220), 15,
       anon_sym_async,
       anon_sym_LBRACE,
       anon_sym_DOT_DOT,
@@ -14276,93 +13338,26 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [14723] = 10,
+  [13729] = 12,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(432), 1,
+    ACTIONS(492), 1,
       anon_sym_DASH_GT,
-    ACTIONS(598), 1,
-      anon_sym_COLON,
-    STATE(231), 1,
-      sym_math_operator,
-    STATE(233), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(176), 4,
+    ACTIONS(568), 1,
       anon_sym_async,
+    ACTIONS(570), 1,
       anon_sym_LBRACE,
-      anon_sym_DOT_DOT,
-      anon_sym_EQ_GT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [14766] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(528), 1,
+    ACTIONS(572), 1,
       anon_sym_COLON,
-    ACTIONS(604), 1,
-      anon_sym_SEMI,
-    STATE(190), 1,
-      sym_logic_operator,
-    STATE(198), 1,
+    STATE(212), 1,
       sym_math_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(344), 3,
-      anon_sym_RBRACE,
-      anon_sym_COMMA,
-      sym_identifier,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [14811] = 12,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(606), 1,
-      anon_sym_async,
-    ACTIONS(608), 1,
-      anon_sym_LBRACE,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    STATE(209), 1,
-      sym_math_operator,
-    STATE(210), 1,
+    STATE(213), 1,
       sym_logic_operator,
-    STATE(287), 1,
+    STATE(284), 1,
       sym_block,
-    ACTIONS(188), 2,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -14370,30 +13365,64 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [14857] = 10,
+  [13775] = 12,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(432), 1,
+    ACTIONS(492), 1,
       anon_sym_DASH_GT,
-    ACTIONS(610), 1,
+    ACTIONS(572), 1,
       anon_sym_COLON,
-    STATE(209), 1,
+    ACTIONS(574), 1,
+      anon_sym_async,
+    ACTIONS(576), 1,
+      anon_sym_LBRACE,
+    STATE(212), 1,
       sym_math_operator,
-    STATE(210), 1,
+    STATE(213), 1,
       sym_logic_operator,
-    ACTIONS(188), 2,
+    STATE(293), 1,
+      sym_block,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(176), 3,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+  [13821] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(572), 1,
+      anon_sym_COLON,
+    STATE(212), 1,
+      sym_math_operator,
+    STATE(213), 1,
+      sym_logic_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(224), 3,
       anon_sym_async,
       anon_sym_LBRACE,
       anon_sym_EQ_GT,
@@ -14402,33 +13431,93 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [14899] = 12,
+  [13863] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(330), 1,
-      anon_sym_LBRACE,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(610), 1,
+    ACTIONS(572), 1,
       anon_sym_COLON,
-    ACTIONS(612), 1,
-      anon_sym_async,
-    STATE(200), 1,
-      sym_block,
-    STATE(209), 1,
+    STATE(212), 1,
       sym_math_operator,
-    STATE(210), 1,
+    STATE(213), 1,
       sym_logic_operator,
-    ACTIONS(188), 2,
+    ACTIONS(222), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(220), 14,
+      anon_sym_async,
+      anon_sym_LBRACE,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+      anon_sym_EQ_GT,
+      anon_sym_DASH_GT,
+  [13897] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(572), 1,
+      anon_sym_COLON,
+    STATE(212), 1,
+      sym_math_operator,
+    STATE(213), 1,
+      sym_logic_operator,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(212), 3,
+      anon_sym_async,
+      anon_sym_LBRACE,
+      anon_sym_EQ_GT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+  [13939] = 12,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(572), 1,
+      anon_sym_COLON,
+    ACTIONS(578), 1,
+      anon_sym_async,
+    ACTIONS(580), 1,
+      anon_sym_LBRACE,
+    STATE(187), 1,
+      sym_block,
+    STATE(212), 1,
+      sym_math_operator,
+    STATE(213), 1,
+      sym_logic_operator,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -14436,19 +13525,53 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [14945] = 5,
+  [13985] = 12,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(209), 1,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(568), 1,
+      anon_sym_async,
+    ACTIONS(570), 1,
+      anon_sym_LBRACE,
+    ACTIONS(572), 1,
+      anon_sym_COLON,
+    STATE(212), 1,
       sym_math_operator,
-    STATE(210), 1,
+    STATE(213), 1,
+      sym_logic_operator,
+    STATE(285), 1,
+      sym_block,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+  [14031] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(212), 1,
+      sym_math_operator,
+    STATE(213), 1,
       sym_logic_operator,
     ACTIONS(208), 3,
       anon_sym_DASH,
@@ -14470,26 +13593,26 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT_EQ,
       anon_sym_EQ_GT,
       anon_sym_DASH_GT,
-  [14977] = 12,
+  [14063] = 12,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(432), 1,
+    ACTIONS(492), 1,
       anon_sym_DASH_GT,
-    ACTIONS(606), 1,
-      anon_sym_async,
-    ACTIONS(608), 1,
-      anon_sym_LBRACE,
-    ACTIONS(610), 1,
+    ACTIONS(572), 1,
       anon_sym_COLON,
-    STATE(209), 1,
+    ACTIONS(574), 1,
+      anon_sym_async,
+    ACTIONS(576), 1,
+      anon_sym_LBRACE,
+    STATE(212), 1,
       sym_math_operator,
-    STATE(210), 1,
+    STATE(213), 1,
       sym_logic_operator,
-    STATE(288), 1,
+    STATE(291), 1,
       sym_block,
-    ACTIONS(188), 2,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -14497,33 +13620,33 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [15023] = 12,
+  [14109] = 12,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
+    ACTIONS(186), 1,
       anon_sym_DASH,
-    ACTIONS(432), 1,
+    ACTIONS(492), 1,
       anon_sym_DASH_GT,
-    ACTIONS(550), 1,
-      anon_sym_LBRACE,
-    ACTIONS(610), 1,
+    ACTIONS(572), 1,
       anon_sym_COLON,
-    ACTIONS(614), 1,
+    ACTIONS(582), 1,
       anon_sym_async,
-    STATE(209), 1,
+    ACTIONS(584), 1,
+      anon_sym_LBRACE,
+    STATE(212), 1,
       sym_math_operator,
-    STATE(210), 1,
+    STATE(213), 1,
       sym_logic_operator,
-    STATE(305), 1,
+    STATE(224), 1,
       sym_block,
-    ACTIONS(188), 2,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -14531,93 +13654,151 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [15069] = 6,
+  [14155] = 12,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    STATE(209), 1,
-      sym_math_operator,
-    STATE(210), 1,
-      sym_logic_operator,
-    ACTIONS(194), 3,
+    ACTIONS(186), 1,
       anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(572), 1,
+      anon_sym_COLON,
+    ACTIONS(578), 1,
+      anon_sym_async,
+    ACTIONS(580), 1,
+      anon_sym_LBRACE,
+    STATE(192), 1,
+      sym_block,
+    STATE(212), 1,
+      sym_math_operator,
+    STATE(213), 1,
+      sym_logic_operator,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(192), 14,
-      anon_sym_async,
-      anon_sym_LBRACE,
+    ACTIONS(184), 4,
       anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
+  [14201] = 12,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(572), 1,
+      anon_sym_COLON,
+    ACTIONS(582), 1,
+      anon_sym_async,
+    ACTIONS(584), 1,
+      anon_sym_LBRACE,
+    STATE(212), 1,
+      sym_math_operator,
+    STATE(213), 1,
+      sym_logic_operator,
+    STATE(227), 1,
+      sym_block,
+    ACTIONS(190), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+  [14247] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(588), 7,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+      anon_sym_PIPE,
+    ACTIONS(586), 12,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_table,
+      anon_sym_return,
+      anon_sym_use,
+  [14274] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(572), 1,
+      anon_sym_COLON,
+    ACTIONS(590), 1,
       anon_sym_EQ_GT,
-      anon_sym_DASH_GT,
-  [15103] = 10,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    STATE(209), 1,
+    STATE(212), 1,
       sym_math_operator,
-    STATE(210), 1,
+    STATE(213), 1,
       sym_logic_operator,
-    ACTIONS(188), 2,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(202), 3,
-      anon_sym_async,
-      anon_sym_LBRACE,
+    ACTIONS(184), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(188), 6,
+      anon_sym_EQ_EQ,
+      anon_sym_BANG_EQ,
+      anon_sym_AMP_AMP,
+      anon_sym_PIPE_PIPE,
+      anon_sym_GT_EQ,
+      anon_sym_LT_EQ,
+  [14314] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(186), 1,
+      anon_sym_DASH,
+    ACTIONS(492), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(572), 1,
+      anon_sym_COLON,
+    ACTIONS(592), 1,
       anon_sym_EQ_GT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [15145] = 12,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(550), 1,
-      anon_sym_LBRACE,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    ACTIONS(614), 1,
-      anon_sym_async,
-    STATE(209), 1,
+    STATE(212), 1,
       sym_math_operator,
-    STATE(210), 1,
+    STATE(213), 1,
       sym_logic_operator,
-    STATE(310), 1,
-      sym_block,
-    ACTIONS(188), 2,
+    ACTIONS(190), 2,
       anon_sym_GT,
       anon_sym_LT,
     ACTIONS(184), 4,
@@ -14625,185 +13806,23 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(186), 6,
+    ACTIONS(188), 6,
       anon_sym_EQ_EQ,
       anon_sym_BANG_EQ,
       anon_sym_AMP_AMP,
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-  [15191] = 12,
+  [14354] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(330), 1,
-      anon_sym_LBRACE,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    ACTIONS(612), 1,
-      anon_sym_async,
-    STATE(209), 1,
-      sym_math_operator,
-    STATE(210), 1,
-      sym_logic_operator,
-    STATE(240), 1,
-      sym_block,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [15237] = 12,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    ACTIONS(616), 1,
-      anon_sym_async,
-    ACTIONS(618), 1,
-      anon_sym_LBRACE,
-    STATE(145), 1,
-      sym_block,
-    STATE(209), 1,
-      sym_math_operator,
-    STATE(210), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [15283] = 12,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    ACTIONS(616), 1,
-      anon_sym_async,
-    ACTIONS(618), 1,
-      anon_sym_LBRACE,
-    STATE(161), 1,
-      sym_block,
-    STATE(209), 1,
-      sym_math_operator,
-    STATE(210), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [15329] = 10,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    ACTIONS(620), 1,
-      anon_sym_EQ_GT,
-    STATE(209), 1,
-      sym_math_operator,
-    STATE(210), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [15369] = 10,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(182), 1,
-      anon_sym_DASH,
-    ACTIONS(432), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(610), 1,
-      anon_sym_COLON,
-    ACTIONS(622), 1,
-      anon_sym_EQ_GT,
-    STATE(209), 1,
-      sym_math_operator,
-    STATE(210), 1,
-      sym_logic_operator,
-    ACTIONS(188), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(184), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(186), 6,
-      anon_sym_EQ_EQ,
-      anon_sym_BANG_EQ,
-      anon_sym_AMP_AMP,
-      anon_sym_PIPE_PIPE,
-      anon_sym_GT_EQ,
-      anon_sym_LT_EQ,
-  [15409] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(564), 5,
+    ACTIONS(290), 5,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_table,
-    ACTIONS(562), 9,
+    ACTIONS(288), 9,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -14813,16 +13832,16 @@ static const uint16_t ts_small_parse_table[] = {
       sym_string,
       anon_sym_LBRACK,
       anon_sym_PIPE,
-  [15431] = 3,
+  [14376] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(296), 5,
+    ACTIONS(278), 5,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_table,
-    ACTIONS(294), 9,
+    ACTIONS(276), 9,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -14832,16 +13851,16 @@ static const uint16_t ts_small_parse_table[] = {
       sym_string,
       anon_sym_LBRACK,
       anon_sym_PIPE,
-  [15453] = 3,
+  [14398] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(260), 5,
+    ACTIONS(536), 5,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_table,
-    ACTIONS(258), 9,
+    ACTIONS(534), 9,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       anon_sym_SEMI,
@@ -14851,33 +13870,16 @@ static const uint16_t ts_small_parse_table[] = {
       sym_string,
       anon_sym_LBRACK,
       anon_sym_PIPE,
-  [15475] = 3,
+  [14420] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(624), 6,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_from,
-      anon_sym_table,
-    ACTIONS(626), 6,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_PIPE,
-  [15495] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(628), 5,
+    ACTIONS(594), 5,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_table,
-    ACTIONS(500), 7,
+    ACTIONS(457), 7,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
@@ -14885,33 +13887,16 @@ static const uint16_t ts_small_parse_table[] = {
       sym_string,
       anon_sym_LBRACK,
       anon_sym_PIPE,
-  [15515] = 3,
+  [14440] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(630), 6,
-      sym_identifier,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_from,
-      anon_sym_table,
-    ACTIONS(632), 6,
-      anon_sym_LBRACE,
-      anon_sym_LPAREN,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_PIPE,
-  [15535] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(634), 5,
+    ACTIONS(596), 5,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_table,
-    ACTIONS(475), 7,
+    ACTIONS(424), 7,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       sym_float,
@@ -14919,314 +13904,408 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LBRACK,
       anon_sym_RBRACK,
       anon_sym_PIPE,
-  [15555] = 3,
+  [14460] = 7,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(636), 5,
+    ACTIONS(598), 1,
+      anon_sym_GT,
+    ACTIONS(602), 1,
+      anon_sym_fn,
+    ACTIONS(604), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(606), 1,
+      anon_sym_list,
+    STATE(267), 2,
+      sym_type,
+      aux_sym_type_repeat1,
+    ACTIONS(600), 6,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14488] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(602), 1,
+      anon_sym_fn,
+    ACTIONS(606), 1,
+      anon_sym_list,
+    ACTIONS(608), 1,
+      anon_sym_GT,
+    ACTIONS(610), 1,
+      anon_sym_DASH_GT,
+    STATE(268), 2,
+      sym_type,
+      aux_sym_type_repeat1,
+    ACTIONS(600), 6,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14516] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(617), 1,
+      anon_sym_fn,
+    ACTIONS(620), 1,
+      anon_sym_list,
+    ACTIONS(612), 2,
+      anon_sym_GT,
+      anon_sym_DASH_GT,
+    STATE(268), 2,
+      sym_type,
+      aux_sym_type_repeat1,
+    ACTIONS(614), 6,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14542] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(623), 5,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_table,
-    ACTIONS(638), 6,
+    ACTIONS(625), 6,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       sym_float,
       sym_string,
       anon_sym_LBRACK,
       anon_sym_PIPE,
-  [15574] = 3,
+  [14561] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(640), 5,
+    ACTIONS(627), 5,
       sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_table,
-    ACTIONS(642), 6,
+    ACTIONS(629), 6,
       anon_sym_LBRACE,
       anon_sym_LPAREN,
       sym_float,
       sym_string,
       anon_sym_LBRACK,
       anon_sym_PIPE,
-  [15593] = 7,
+  [14580] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(409), 1,
+    ACTIONS(631), 5,
       sym_identifier,
-    ACTIONS(644), 1,
-      anon_sym_elseif,
-    ACTIONS(646), 1,
-      anon_sym_else,
-    STATE(307), 1,
-      sym_else,
-    STATE(286), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(407), 3,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-  [15618] = 7,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(417), 1,
-      sym_identifier,
-    ACTIONS(644), 1,
-      anon_sym_elseif,
-    ACTIONS(646), 1,
-      anon_sym_else,
-    STATE(315), 1,
-      sym_else,
-    STATE(282), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(415), 3,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-  [15643] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(648), 8,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
       anon_sym_table,
+    ACTIONS(633), 6,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_PIPE,
+  [14599] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(635), 5,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_table,
+    ACTIONS(637), 6,
+      anon_sym_LBRACE,
+      anon_sym_LPAREN,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_PIPE,
+  [14618] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(639), 10,
+      anon_sym_GT,
       anon_sym_any,
       anon_sym_bool,
       anon_sym_fn,
+      anon_sym_DASH_GT,
       anon_sym_int,
       anon_sym_list,
       anon_sym_map,
+      anon_sym_num,
       anon_sym_str,
-  [15657] = 3,
+  [14634] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(650), 2,
-      anon_sym_async,
+    ACTIONS(598), 10,
+      anon_sym_GT,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_fn,
+      anon_sym_DASH_GT,
+      anon_sym_int,
+      anon_sym_list,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14650] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(608), 10,
+      anon_sym_GT,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_fn,
+      anon_sym_DASH_GT,
+      anon_sym_int,
+      anon_sym_list,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14666] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(641), 10,
+      anon_sym_GT,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_fn,
+      anon_sym_DASH_GT,
+      anon_sym_int,
+      anon_sym_list,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14682] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(602), 1,
+      anon_sym_fn,
+    ACTIONS(606), 1,
+      anon_sym_list,
+    STATE(275), 1,
+      sym_type,
+    ACTIONS(600), 6,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14703] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(391), 1,
       sym_identifier,
-    ACTIONS(652), 6,
-      anon_sym_LBRACE,
-      anon_sym_COMMA,
-      anon_sym_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-      anon_sym_PIPE,
-  [15673] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(654), 1,
+    ACTIONS(643), 1,
       anon_sym_elseif,
-    ACTIONS(421), 2,
-      sym_identifier,
+    ACTIONS(645), 1,
       anon_sym_else,
-    STATE(286), 2,
+    STATE(292), 1,
+      sym_else,
+    STATE(283), 2,
       sym_else_if,
       aux_sym_if_else_repeat1,
-    ACTIONS(419), 3,
+    ACTIONS(389), 3,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
-  [15693] = 3,
+  [14728] = 5,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(452), 2,
+    ACTIONS(602), 1,
+      anon_sym_fn,
+    ACTIONS(606), 1,
+      anon_sym_list,
+    STATE(273), 1,
+      sym_type,
+    ACTIONS(600), 6,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14749] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(602), 1,
+      anon_sym_fn,
+    ACTIONS(606), 1,
+      anon_sym_list,
+    STATE(276), 1,
+      sym_type,
+    ACTIONS(600), 6,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14770] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(383), 1,
+      sym_identifier,
+    ACTIONS(643), 1,
+      anon_sym_elseif,
+    ACTIONS(645), 1,
+      anon_sym_else,
+    STATE(294), 1,
+      sym_else,
+    STATE(278), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(381), 3,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+  [14795] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(602), 1,
+      anon_sym_fn,
+    ACTIONS(606), 1,
+      anon_sym_list,
+    STATE(358), 1,
+      sym_type,
+    ACTIONS(600), 6,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [14816] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(647), 1,
+      anon_sym_elseif,
+    ACTIONS(481), 2,
       sym_identifier,
       anon_sym_else,
-    ACTIONS(450), 4,
+    STATE(283), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(479), 3,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+  [14836] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(518), 2,
+      sym_identifier,
+      anon_sym_else,
+    ACTIONS(516), 4,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
       anon_sym_elseif,
-  [15707] = 3,
+  [14850] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(526), 2,
+    ACTIONS(514), 2,
       sym_identifier,
       anon_sym_else,
-    ACTIONS(524), 4,
+    ACTIONS(512), 4,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
       anon_sym_elseif,
-  [15721] = 6,
+  [14864] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(657), 1,
-      anon_sym_async,
-    ACTIONS(659), 1,
-      anon_sym_LBRACE,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    STATE(151), 1,
-      sym_block,
-    STATE(343), 1,
-      sym_type,
-  [15740] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    ACTIONS(663), 1,
-      anon_sym_async,
-    ACTIONS(665), 1,
-      anon_sym_LBRACE,
-    STATE(59), 1,
-      sym_block,
-    STATE(335), 1,
-      sym_type,
-  [15759] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(550), 1,
-      anon_sym_LBRACE,
-    ACTIONS(614), 1,
-      anon_sym_async,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    STATE(100), 1,
-      sym_block,
-    STATE(333), 1,
-      sym_type,
-  [15778] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(657), 1,
-      anon_sym_async,
-    ACTIONS(659), 1,
-      anon_sym_LBRACE,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    STATE(147), 1,
-      sym_block,
-    STATE(344), 1,
-      sym_type,
-  [15797] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(606), 1,
-      anon_sym_async,
-    ACTIONS(608), 1,
-      anon_sym_LBRACE,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    STATE(151), 1,
-      sym_block,
-    STATE(345), 1,
-      sym_type,
-  [15816] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(550), 1,
-      anon_sym_LBRACE,
-    ACTIONS(614), 1,
-      anon_sym_async,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    STATE(104), 1,
-      sym_block,
-    STATE(321), 1,
-      sym_type,
-  [15835] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    ACTIONS(663), 1,
-      anon_sym_async,
-    ACTIONS(665), 1,
-      anon_sym_LBRACE,
-    STATE(63), 1,
-      sym_block,
-    STATE(331), 1,
-      sym_type,
-  [15854] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(606), 1,
-      anon_sym_async,
-    ACTIONS(608), 1,
-      anon_sym_LBRACE,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    STATE(147), 1,
-      sym_block,
-    STATE(322), 1,
-      sym_type,
-  [15873] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(667), 1,
-      sym_identifier,
-    ACTIONS(670), 1,
-      anon_sym_PIPE,
-    STATE(297), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [15887] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(38), 1,
+    STATE(45), 1,
       sym_assignment_operator,
-    ACTIONS(220), 3,
+    ACTIONS(248), 3,
       anon_sym_EQ,
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
-  [15899] = 4,
+  [14876] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(672), 1,
+    ACTIONS(564), 1,
+      anon_sym_SEMI,
+    ACTIONS(320), 3,
+      anon_sym_RBRACE,
+      anon_sym_COMMA,
       sym_identifier,
-    ACTIONS(674), 1,
-      anon_sym_PIPE,
-    STATE(319), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [15913] = 4,
+  [14888] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(672), 1,
-      sym_identifier,
-    ACTIONS(676), 1,
-      anon_sym_PIPE,
-    STATE(320), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [15927] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(41), 1,
-      sym_assignment_operator,
-    ACTIONS(220), 3,
-      anon_sym_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-  [15939] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(344), 4,
+    ACTIONS(522), 4,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
       sym_identifier,
-  [15949] = 3,
+  [14898] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(604), 1,
-      anon_sym_SEMI,
-    ACTIONS(344), 3,
-      anon_sym_RBRACE,
-      anon_sym_COMMA,
-      sym_identifier,
-  [15961] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(554), 4,
+    ACTIONS(320), 4,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
       sym_identifier,
-  [15971] = 2,
+  [14908] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(530), 4,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+  [14918] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(538), 4,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+  [14928] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(546), 4,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+  [14938] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(526), 4,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+  [14948] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(389), 4,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+  [14958] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(542), 4,
+      anon_sym_RBRACE,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      sym_identifier,
+  [14968] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(558), 4,
@@ -15234,1338 +14313,1206 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_SEMI,
       anon_sym_COMMA,
       sym_identifier,
-  [15981] = 2,
+  [14978] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(568), 4,
+    ACTIONS(550), 4,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
       sym_identifier,
-  [15991] = 2,
+  [14988] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(536), 4,
+    ACTIONS(554), 4,
       anon_sym_RBRACE,
       anon_sym_SEMI,
       anon_sym_COMMA,
       sym_identifier,
-  [16001] = 2,
+  [14998] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(532), 4,
+    STATE(44), 1,
+      sym_assignment_operator,
+    ACTIONS(248), 3,
+      anon_sym_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [15010] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(650), 1,
+      sym_identifier,
+    ACTIONS(652), 1,
       anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-  [16011] = 2,
+    STATE(309), 1,
+      aux_sym_map_repeat1,
+  [15023] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(582), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-  [16021] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(588), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-  [16031] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(592), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-  [16041] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(672), 1,
-      sym_identifier,
-    ACTIONS(678), 1,
-      anon_sym_PIPE,
-    STATE(297), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [16055] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(672), 1,
-      sym_identifier,
-    ACTIONS(680), 1,
-      anon_sym_PIPE,
-    STATE(312), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [16069] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(672), 1,
-      sym_identifier,
-    ACTIONS(682), 1,
-      anon_sym_PIPE,
-    STATE(316), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [16083] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(407), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-  [16093] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(672), 1,
-      sym_identifier,
-    ACTIONS(684), 1,
-      anon_sym_PIPE,
-    STATE(297), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [16107] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(578), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-  [16117] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(572), 4,
-      anon_sym_RBRACE,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      sym_identifier,
-  [16127] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(672), 1,
-      sym_identifier,
-    ACTIONS(686), 1,
-      anon_sym_PIPE,
-    STATE(297), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [16141] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(672), 1,
-      sym_identifier,
-    ACTIONS(688), 1,
-      anon_sym_PIPE,
-    STATE(297), 2,
-      sym_parameter,
-      aux_sym_function_repeat1,
-  [16155] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(550), 1,
-      anon_sym_LBRACE,
-    ACTIONS(614), 1,
+    ACTIONS(654), 1,
       anon_sym_async,
-    STATE(102), 1,
-      sym_block,
-  [16168] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(606), 1,
-      anon_sym_async,
-    ACTIONS(608), 1,
+    ACTIONS(656), 1,
       anon_sym_LBRACE,
-    STATE(134), 1,
+    STATE(122), 1,
       sym_block,
-  [16181] = 4,
+  [15036] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(690), 1,
+    ACTIONS(658), 3,
+      anon_sym_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [15045] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(662), 1,
+      anon_sym_COMMA,
+    ACTIONS(660), 2,
+      anon_sym_RBRACE,
       sym_identifier,
+  [15056] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(664), 1,
+      sym_identifier,
+    ACTIONS(666), 1,
+      anon_sym_PIPE,
+    STATE(328), 1,
+      aux_sym_identifier_list_repeat1,
+  [15069] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(582), 1,
+      anon_sym_async,
+    ACTIONS(584), 1,
+      anon_sym_LBRACE,
+    STATE(226), 1,
+      sym_block,
+  [15082] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(582), 1,
+      anon_sym_async,
+    ACTIONS(584), 1,
+      anon_sym_LBRACE,
+    STATE(229), 1,
+      sym_block,
+  [15095] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(41), 1,
+      anon_sym_RBRACE,
+    ACTIONS(650), 1,
+      sym_identifier,
+    STATE(310), 1,
+      aux_sym_map_repeat1,
+  [15108] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(664), 1,
+      sym_identifier,
+    ACTIONS(668), 1,
+      anon_sym_PIPE,
+    STATE(304), 1,
+      aux_sym_identifier_list_repeat1,
+  [15121] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(670), 1,
+      sym_identifier,
+    ACTIONS(673), 1,
+      anon_sym_RBRACE,
+    STATE(309), 1,
+      aux_sym_map_repeat1,
+  [15134] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(650), 1,
+      sym_identifier,
+    ACTIONS(675), 1,
+      anon_sym_RBRACE,
+    STATE(309), 1,
+      aux_sym_map_repeat1,
+  [15147] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(650), 1,
+      sym_identifier,
+    ACTIONS(677), 1,
+      anon_sym_RBRACE,
+    STATE(309), 1,
+      aux_sym_map_repeat1,
+  [15160] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(96), 1,
+      anon_sym_RBRACE,
+    ACTIONS(650), 1,
+      sym_identifier,
+    STATE(300), 1,
+      aux_sym_map_repeat1,
+  [15173] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(650), 1,
+      sym_identifier,
+    ACTIONS(679), 1,
+      anon_sym_RBRACE,
+    STATE(311), 1,
+      aux_sym_map_repeat1,
+  [15186] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(664), 1,
+      sym_identifier,
+    ACTIONS(681), 1,
+      anon_sym_PIPE,
+    STATE(316), 1,
+      aux_sym_identifier_list_repeat1,
+  [15199] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(568), 1,
+      anon_sym_async,
+    ACTIONS(570), 1,
+      anon_sym_LBRACE,
+    STATE(122), 1,
+      sym_block,
+  [15212] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(664), 1,
+      sym_identifier,
+    ACTIONS(683), 1,
+      anon_sym_PIPE,
+    STATE(328), 1,
+      aux_sym_identifier_list_repeat1,
+  [15225] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(574), 1,
+      anon_sym_async,
+    ACTIONS(576), 1,
+      anon_sym_LBRACE,
+    STATE(105), 1,
+      sym_block,
+  [15238] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(574), 1,
+      anon_sym_async,
+    ACTIONS(576), 1,
+      anon_sym_LBRACE,
+    STATE(295), 1,
+      sym_block,
+  [15251] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(664), 1,
+      sym_identifier,
+    ACTIONS(685), 1,
+      anon_sym_PIPE,
+    STATE(327), 1,
+      aux_sym_identifier_list_repeat1,
+  [15264] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(574), 1,
+      anon_sym_async,
+    ACTIONS(576), 1,
+      anon_sym_LBRACE,
+    STATE(109), 1,
+      sym_block,
+  [15277] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(687), 1,
+      anon_sym_async,
+    ACTIONS(689), 1,
+      anon_sym_LBRACE,
+    STATE(263), 1,
+      sym_block,
+  [15290] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(568), 1,
+      anon_sym_async,
+    ACTIONS(570), 1,
+      anon_sym_LBRACE,
+    STATE(141), 1,
+      sym_block,
+  [15303] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
     ACTIONS(693), 1,
-      anon_sym_PIPE,
-    STATE(323), 1,
-      aux_sym_identifier_list_repeat1,
-  [16194] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(695), 1,
+      anon_sym_COMMA,
+    ACTIONS(691), 2,
       sym_identifier,
-    ACTIONS(697), 1,
       anon_sym_PIPE,
-    STATE(336), 1,
+  [15314] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(664), 1,
+      sym_identifier,
+    ACTIONS(695), 1,
+      anon_sym_PIPE,
+    STATE(326), 1,
       aux_sym_identifier_list_repeat1,
-  [16207] = 4,
+  [15327] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(330), 1,
-      anon_sym_LBRACE,
-    ACTIONS(612), 1,
+    ACTIONS(697), 1,
       anon_sym_async,
-    STATE(201), 1,
-      sym_block,
-  [16220] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(550), 1,
-      anon_sym_LBRACE,
-    ACTIONS(614), 1,
-      anon_sym_async,
-    STATE(308), 1,
-      sym_block,
-  [16233] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
     ACTIONS(699), 1,
+      anon_sym_LBRACE,
+    STATE(70), 1,
+      sym_block,
+  [15340] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(664), 1,
       sym_identifier,
     ACTIONS(701), 1,
-      anon_sym_RBRACE,
-    STATE(340), 1,
-      aux_sym_map_repeat1,
-  [16246] = 3,
+      anon_sym_PIPE,
+    STATE(328), 1,
+      aux_sym_identifier_list_repeat1,
+  [15353] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(664), 1,
+      sym_identifier,
+    ACTIONS(703), 1,
+      anon_sym_PIPE,
+    STATE(328), 1,
+      aux_sym_identifier_list_repeat1,
+  [15366] = 4,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(705), 1,
-      anon_sym_COMMA,
-    ACTIONS(703), 2,
-      anon_sym_RBRACE,
       sym_identifier,
-  [16257] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(707), 1,
-      anon_sym_async,
-    ACTIONS(709), 1,
-      anon_sym_LBRACE,
-    STATE(273), 1,
-      sym_block,
-  [16270] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(699), 1,
-      sym_identifier,
-    ACTIONS(711), 1,
-      anon_sym_RBRACE,
-    STATE(340), 1,
-      aux_sym_map_repeat1,
-  [16283] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(663), 1,
-      anon_sym_async,
-    ACTIONS(665), 1,
-      anon_sym_LBRACE,
-    STATE(59), 1,
-      sym_block,
-  [16296] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(45), 1,
-      anon_sym_RBRACE,
-    ACTIONS(699), 1,
-      sym_identifier,
-    STATE(337), 1,
-      aux_sym_map_repeat1,
-  [16309] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(550), 1,
-      anon_sym_LBRACE,
-    ACTIONS(614), 1,
-      anon_sym_async,
-    STATE(104), 1,
-      sym_block,
-  [16322] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(699), 1,
-      sym_identifier,
-    ACTIONS(713), 1,
-      anon_sym_RBRACE,
-    STATE(327), 1,
-      aux_sym_map_repeat1,
-  [16335] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(663), 1,
-      anon_sym_async,
-    ACTIONS(665), 1,
-      anon_sym_LBRACE,
-    STATE(53), 1,
-      sym_block,
-  [16348] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(695), 1,
-      sym_identifier,
-    ACTIONS(715), 1,
+    ACTIONS(708), 1,
       anon_sym_PIPE,
-    STATE(323), 1,
+    STATE(328), 1,
       aux_sym_identifier_list_repeat1,
-  [16361] = 4,
+  [15379] = 4,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(697), 1,
+      anon_sym_async,
     ACTIONS(699), 1,
-      sym_identifier,
-    ACTIONS(717), 1,
-      anon_sym_RBRACE,
-    STATE(340), 1,
-      aux_sym_map_repeat1,
-  [16374] = 4,
+      anon_sym_LBRACE,
+    STATE(63), 1,
+      sym_block,
+  [15392] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(106), 1,
-      anon_sym_RBRACE,
-    ACTIONS(699), 1,
-      sym_identifier,
-    STATE(330), 1,
-      aux_sym_map_repeat1,
-  [16387] = 3,
+    ACTIONS(654), 1,
+      anon_sym_async,
+    ACTIONS(656), 1,
+      anon_sym_LBRACE,
+    STATE(141), 1,
+      sym_block,
+  [15405] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(721), 1,
-      anon_sym_COMMA,
-    ACTIONS(719), 2,
+    ACTIONS(664), 1,
       sym_identifier,
+    ACTIONS(710), 1,
       anon_sym_PIPE,
-  [16398] = 4,
+    STATE(328), 1,
+      aux_sym_identifier_list_repeat1,
+  [15418] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(723), 1,
-      sym_identifier,
-    ACTIONS(726), 1,
-      anon_sym_RBRACE,
-    STATE(340), 1,
-      aux_sym_map_repeat1,
-  [16411] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(330), 1,
-      anon_sym_LBRACE,
-    ACTIONS(612), 1,
-      anon_sym_async,
-    STATE(171), 1,
-      sym_block,
-  [16424] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(730), 1,
-      anon_sym_COMMA,
-    ACTIONS(728), 2,
+    ACTIONS(664), 1,
       sym_identifier,
+    ACTIONS(712), 1,
       anon_sym_PIPE,
-  [16435] = 4,
+    STATE(331), 1,
+      aux_sym_identifier_list_repeat1,
+  [15431] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(657), 1,
-      anon_sym_async,
-    ACTIONS(659), 1,
-      anon_sym_LBRACE,
-    STATE(147), 1,
-      sym_block,
-  [16448] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(657), 1,
-      anon_sym_async,
-    ACTIONS(659), 1,
-      anon_sym_LBRACE,
-    STATE(134), 1,
-      sym_block,
-  [16461] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(606), 1,
-      anon_sym_async,
-    ACTIONS(608), 1,
-      anon_sym_LBRACE,
-    STATE(147), 1,
-      sym_block,
-  [16474] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(732), 1,
-      anon_sym_PIPE,
-    STATE(207), 1,
-      sym_identifier_list,
-  [16484] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(732), 1,
+    ACTIONS(714), 1,
       anon_sym_PIPE,
     STATE(185), 1,
       sym_identifier_list,
-  [16494] = 3,
+  [15441] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(732), 1,
+    ACTIONS(714), 1,
       anon_sym_PIPE,
-    STATE(183), 1,
+    STATE(206), 1,
       sym_identifier_list,
-  [16504] = 3,
+  [15451] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(732), 1,
+    ACTIONS(714), 1,
       anon_sym_PIPE,
-    STATE(369), 1,
+    STATE(160), 1,
       sym_identifier_list,
-  [16514] = 3,
+  [15461] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(732), 1,
+    ACTIONS(716), 2,
+      anon_sym_RBRACE,
+      sym_identifier,
+  [15469] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(714), 1,
       anon_sym_PIPE,
-    STATE(193), 1,
+    STATE(203), 1,
       sym_identifier_list,
-  [16524] = 3,
+  [15479] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(732), 1,
+    ACTIONS(708), 2,
+      sym_identifier,
       anon_sym_PIPE,
-    STATE(382), 1,
-      sym_identifier_list,
-  [16534] = 3,
+  [15487] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(732), 1,
+    ACTIONS(714), 1,
+      anon_sym_PIPE,
+    STATE(166), 1,
+      sym_identifier_list,
+  [15497] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(714), 1,
+      anon_sym_PIPE,
+    STATE(210), 1,
+      sym_identifier_list,
+  [15507] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(714), 1,
       anon_sym_PIPE,
     STATE(217), 1,
       sym_identifier_list,
-  [16544] = 2,
+  [15517] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(734), 2,
-      anon_sym_RBRACE,
+    ACTIONS(714), 1,
+      anon_sym_PIPE,
+    STATE(168), 1,
+      sym_identifier_list,
+  [15527] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(718), 1,
+      anon_sym_in,
+  [15534] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(720), 1,
+      anon_sym_LPAREN,
+  [15541] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(722), 1,
       sym_identifier,
-  [16552] = 3,
+  [15548] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(724), 1,
+      anon_sym_LBRACE,
+  [15555] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(726), 1,
+      anon_sym_LBRACE,
+  [15562] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(728), 1,
+      anon_sym_LBRACE,
+  [15569] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(730), 1,
+      anon_sym_LBRACE,
+  [15576] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(732), 1,
-      anon_sym_PIPE,
-    STATE(212), 1,
-      sym_identifier_list,
-  [16562] = 2,
+      anon_sym_LPAREN,
+  [15583] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(736), 2,
-      sym_identifier,
-      anon_sym_PIPE,
-  [16570] = 2,
+    ACTIONS(734), 1,
+      anon_sym_EQ,
+  [15590] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(693), 2,
-      sym_identifier,
-      anon_sym_PIPE,
-  [16578] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(661), 1,
-      anon_sym_LT,
-    STATE(342), 1,
-      sym_type,
-  [16588] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(732), 1,
-      anon_sym_PIPE,
-    STATE(213), 1,
-      sym_identifier_list,
-  [16598] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(732), 1,
-      anon_sym_PIPE,
-    STATE(229), 1,
-      sym_identifier_list,
-  [16608] = 2,
+    ACTIONS(736), 1,
+      anon_sym_in,
+  [15597] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(738), 1,
-      sym_string,
-  [16615] = 2,
+      anon_sym_LBRACE,
+  [15604] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(740), 1,
       anon_sym_LBRACE,
-  [16622] = 2,
+  [15611] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(742), 1,
-      anon_sym_LBRACE,
-  [16629] = 2,
+      sym_identifier,
+  [15618] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(744), 1,
       anon_sym_LBRACE,
-  [16636] = 2,
+  [15625] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(746), 1,
-      anon_sym_LBRACE,
-  [16643] = 2,
+      sym_string,
+  [15632] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(748), 1,
-      sym_identifier,
-  [16650] = 2,
+      anon_sym_GT,
+  [15639] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(750), 1,
-      anon_sym_in,
-  [16657] = 2,
+      anon_sym_LPAREN,
+  [15646] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(752), 1,
-      anon_sym_LPAREN,
-  [16664] = 2,
+      sym_string,
+  [15653] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(754), 1,
-      sym_identifier,
-  [16671] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(756), 1,
-      anon_sym_from,
-  [16678] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(758), 1,
-      sym_identifier,
-  [16685] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(760), 1,
-      anon_sym_in,
-  [16692] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(762), 1,
-      anon_sym_LBRACE,
-  [16699] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(764), 1,
-      anon_sym_LBRACE,
-  [16706] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(766), 1,
-      anon_sym_LBRACE,
-  [16713] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(768), 1,
-      anon_sym_into,
-  [16720] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(770), 1,
       ts_builtin_sym_end,
-  [16727] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(772), 1,
-      anon_sym_LPAREN,
-  [16734] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(774), 1,
-      sym_string,
-  [16741] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(776), 1,
-      anon_sym_GT,
-  [16748] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(778), 1,
-      anon_sym_EQ,
-  [16755] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(780), 1,
-      anon_sym_into,
-  [16762] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(782), 1,
-      anon_sym_from,
-  [16769] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(784), 1,
-      anon_sym_LPAREN,
-  [16776] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(786), 1,
-      sym_identifier,
 };
 
 static const uint32_t ts_small_parse_table_map[] = {
   [SMALL_STATE(2)] = 0,
-  [SMALL_STATE(3)] = 110,
-  [SMALL_STATE(4)] = 218,
-  [SMALL_STATE(5)] = 328,
-  [SMALL_STATE(6)] = 435,
-  [SMALL_STATE(7)] = 542,
-  [SMALL_STATE(8)] = 649,
-  [SMALL_STATE(9)] = 756,
-  [SMALL_STATE(10)] = 863,
-  [SMALL_STATE(11)] = 970,
-  [SMALL_STATE(12)] = 1077,
-  [SMALL_STATE(13)] = 1184,
-  [SMALL_STATE(14)] = 1291,
-  [SMALL_STATE(15)] = 1398,
-  [SMALL_STATE(16)] = 1505,
-  [SMALL_STATE(17)] = 1612,
-  [SMALL_STATE(18)] = 1719,
-  [SMALL_STATE(19)] = 1826,
-  [SMALL_STATE(20)] = 1933,
-  [SMALL_STATE(21)] = 2037,
-  [SMALL_STATE(22)] = 2141,
-  [SMALL_STATE(23)] = 2245,
-  [SMALL_STATE(24)] = 2349,
-  [SMALL_STATE(25)] = 2453,
-  [SMALL_STATE(26)] = 2557,
-  [SMALL_STATE(27)] = 2661,
-  [SMALL_STATE(28)] = 2765,
-  [SMALL_STATE(29)] = 2869,
-  [SMALL_STATE(30)] = 2973,
-  [SMALL_STATE(31)] = 3077,
-  [SMALL_STATE(32)] = 3181,
-  [SMALL_STATE(33)] = 3285,
-  [SMALL_STATE(34)] = 3389,
-  [SMALL_STATE(35)] = 3492,
-  [SMALL_STATE(36)] = 3595,
-  [SMALL_STATE(37)] = 3698,
-  [SMALL_STATE(38)] = 3801,
-  [SMALL_STATE(39)] = 3904,
-  [SMALL_STATE(40)] = 4007,
-  [SMALL_STATE(41)] = 4110,
-  [SMALL_STATE(42)] = 4213,
-  [SMALL_STATE(43)] = 4282,
-  [SMALL_STATE(44)] = 4341,
-  [SMALL_STATE(45)] = 4398,
-  [SMALL_STATE(46)] = 4457,
-  [SMALL_STATE(47)] = 4526,
-  [SMALL_STATE(48)] = 4583,
-  [SMALL_STATE(49)] = 4651,
-  [SMALL_STATE(50)] = 4713,
-  [SMALL_STATE(51)] = 4769,
-  [SMALL_STATE(52)] = 4837,
-  [SMALL_STATE(53)] = 4895,
-  [SMALL_STATE(54)] = 4946,
-  [SMALL_STATE(55)] = 4997,
-  [SMALL_STATE(56)] = 5088,
-  [SMALL_STATE(57)] = 5145,
-  [SMALL_STATE(58)] = 5196,
-  [SMALL_STATE(59)] = 5247,
-  [SMALL_STATE(60)] = 5298,
-  [SMALL_STATE(61)] = 5349,
-  [SMALL_STATE(62)] = 5440,
-  [SMALL_STATE(63)] = 5531,
-  [SMALL_STATE(64)] = 5582,
-  [SMALL_STATE(65)] = 5633,
-  [SMALL_STATE(66)] = 5684,
-  [SMALL_STATE(67)] = 5735,
-  [SMALL_STATE(68)] = 5786,
-  [SMALL_STATE(69)] = 5837,
-  [SMALL_STATE(70)] = 5928,
-  [SMALL_STATE(71)] = 5979,
-  [SMALL_STATE(72)] = 6030,
-  [SMALL_STATE(73)] = 6081,
-  [SMALL_STATE(74)] = 6132,
-  [SMALL_STATE(75)] = 6223,
-  [SMALL_STATE(76)] = 6284,
-  [SMALL_STATE(77)] = 6375,
-  [SMALL_STATE(78)] = 6426,
-  [SMALL_STATE(79)] = 6498,
-  [SMALL_STATE(80)] = 6586,
-  [SMALL_STATE(81)] = 6674,
-  [SMALL_STATE(82)] = 6739,
-  [SMALL_STATE(83)] = 6806,
-  [SMALL_STATE(84)] = 6871,
-  [SMALL_STATE(85)] = 6936,
-  [SMALL_STATE(86)] = 7008,
-  [SMALL_STATE(87)] = 7080,
-  [SMALL_STATE(88)] = 7120,
-  [SMALL_STATE(89)] = 7164,
-  [SMALL_STATE(90)] = 7210,
-  [SMALL_STATE(91)] = 7266,
-  [SMALL_STATE(92)] = 7310,
-  [SMALL_STATE(93)] = 7366,
-  [SMALL_STATE(94)] = 7412,
-  [SMALL_STATE(95)] = 7452,
-  [SMALL_STATE(96)] = 7507,
-  [SMALL_STATE(97)] = 7550,
-  [SMALL_STATE(98)] = 7605,
-  [SMALL_STATE(99)] = 7650,
-  [SMALL_STATE(100)] = 7688,
-  [SMALL_STATE(101)] = 7726,
-  [SMALL_STATE(102)] = 7764,
-  [SMALL_STATE(103)] = 7802,
-  [SMALL_STATE(104)] = 7840,
-  [SMALL_STATE(105)] = 7878,
-  [SMALL_STATE(106)] = 7916,
-  [SMALL_STATE(107)] = 7954,
-  [SMALL_STATE(108)] = 7992,
-  [SMALL_STATE(109)] = 8048,
-  [SMALL_STATE(110)] = 8086,
-  [SMALL_STATE(111)] = 8124,
-  [SMALL_STATE(112)] = 8162,
-  [SMALL_STATE(113)] = 8200,
-  [SMALL_STATE(114)] = 8238,
-  [SMALL_STATE(115)] = 8294,
-  [SMALL_STATE(116)] = 8332,
-  [SMALL_STATE(117)] = 8377,
-  [SMALL_STATE(118)] = 8422,
-  [SMALL_STATE(119)] = 8482,
-  [SMALL_STATE(120)] = 8522,
-  [SMALL_STATE(121)] = 8582,
-  [SMALL_STATE(122)] = 8621,
-  [SMALL_STATE(123)] = 8658,
-  [SMALL_STATE(124)] = 8695,
-  [SMALL_STATE(125)] = 8736,
-  [SMALL_STATE(126)] = 8787,
-  [SMALL_STATE(127)] = 8824,
-  [SMALL_STATE(128)] = 8865,
-  [SMALL_STATE(129)] = 8916,
-  [SMALL_STATE(130)] = 8955,
-  [SMALL_STATE(131)] = 9013,
-  [SMALL_STATE(132)] = 9071,
-  [SMALL_STATE(133)] = 9105,
-  [SMALL_STATE(134)] = 9139,
-  [SMALL_STATE(135)] = 9173,
-  [SMALL_STATE(136)] = 9207,
-  [SMALL_STATE(137)] = 9241,
-  [SMALL_STATE(138)] = 9299,
-  [SMALL_STATE(139)] = 9357,
-  [SMALL_STATE(140)] = 9395,
-  [SMALL_STATE(141)] = 9429,
-  [SMALL_STATE(142)] = 9487,
-  [SMALL_STATE(143)] = 9521,
-  [SMALL_STATE(144)] = 9555,
-  [SMALL_STATE(145)] = 9589,
-  [SMALL_STATE(146)] = 9623,
-  [SMALL_STATE(147)] = 9681,
-  [SMALL_STATE(148)] = 9715,
-  [SMALL_STATE(149)] = 9749,
-  [SMALL_STATE(150)] = 9807,
-  [SMALL_STATE(151)] = 9841,
-  [SMALL_STATE(152)] = 9875,
-  [SMALL_STATE(153)] = 9933,
-  [SMALL_STATE(154)] = 9967,
-  [SMALL_STATE(155)] = 10001,
-  [SMALL_STATE(156)] = 10059,
-  [SMALL_STATE(157)] = 10093,
-  [SMALL_STATE(158)] = 10151,
-  [SMALL_STATE(159)] = 10209,
-  [SMALL_STATE(160)] = 10267,
-  [SMALL_STATE(161)] = 10325,
-  [SMALL_STATE(162)] = 10359,
-  [SMALL_STATE(163)] = 10409,
-  [SMALL_STATE(164)] = 10443,
-  [SMALL_STATE(165)] = 10483,
-  [SMALL_STATE(166)] = 10533,
-  [SMALL_STATE(167)] = 10591,
-  [SMALL_STATE(168)] = 10624,
-  [SMALL_STATE(169)] = 10657,
-  [SMALL_STATE(170)] = 10690,
-  [SMALL_STATE(171)] = 10723,
-  [SMALL_STATE(172)] = 10755,
-  [SMALL_STATE(173)] = 10787,
-  [SMALL_STATE(174)] = 10839,
-  [SMALL_STATE(175)] = 10891,
-  [SMALL_STATE(176)] = 10943,
-  [SMALL_STATE(177)] = 10995,
-  [SMALL_STATE(178)] = 11047,
-  [SMALL_STATE(179)] = 11099,
-  [SMALL_STATE(180)] = 11151,
-  [SMALL_STATE(181)] = 11203,
-  [SMALL_STATE(182)] = 11255,
-  [SMALL_STATE(183)] = 11289,
-  [SMALL_STATE(184)] = 11341,
-  [SMALL_STATE(185)] = 11393,
-  [SMALL_STATE(186)] = 11445,
-  [SMALL_STATE(187)] = 11497,
-  [SMALL_STATE(188)] = 11549,
-  [SMALL_STATE(189)] = 11603,
-  [SMALL_STATE(190)] = 11655,
-  [SMALL_STATE(191)] = 11707,
-  [SMALL_STATE(192)] = 11759,
-  [SMALL_STATE(193)] = 11811,
-  [SMALL_STATE(194)] = 11863,
-  [SMALL_STATE(195)] = 11915,
-  [SMALL_STATE(196)] = 11947,
-  [SMALL_STATE(197)] = 11999,
-  [SMALL_STATE(198)] = 12041,
-  [SMALL_STATE(199)] = 12093,
-  [SMALL_STATE(200)] = 12125,
-  [SMALL_STATE(201)] = 12157,
-  [SMALL_STATE(202)] = 12189,
-  [SMALL_STATE(203)] = 12241,
-  [SMALL_STATE(204)] = 12293,
-  [SMALL_STATE(205)] = 12345,
-  [SMALL_STATE(206)] = 12397,
-  [SMALL_STATE(207)] = 12449,
-  [SMALL_STATE(208)] = 12501,
-  [SMALL_STATE(209)] = 12553,
-  [SMALL_STATE(210)] = 12605,
-  [SMALL_STATE(211)] = 12657,
-  [SMALL_STATE(212)] = 12709,
-  [SMALL_STATE(213)] = 12761,
-  [SMALL_STATE(214)] = 12813,
-  [SMALL_STATE(215)] = 12845,
-  [SMALL_STATE(216)] = 12897,
-  [SMALL_STATE(217)] = 12949,
-  [SMALL_STATE(218)] = 13001,
-  [SMALL_STATE(219)] = 13033,
-  [SMALL_STATE(220)] = 13085,
-  [SMALL_STATE(221)] = 13137,
-  [SMALL_STATE(222)] = 13169,
-  [SMALL_STATE(223)] = 13221,
-  [SMALL_STATE(224)] = 13273,
-  [SMALL_STATE(225)] = 13325,
-  [SMALL_STATE(226)] = 13357,
-  [SMALL_STATE(227)] = 13409,
-  [SMALL_STATE(228)] = 13441,
-  [SMALL_STATE(229)] = 13493,
-  [SMALL_STATE(230)] = 13545,
-  [SMALL_STATE(231)] = 13597,
-  [SMALL_STATE(232)] = 13649,
-  [SMALL_STATE(233)] = 13701,
-  [SMALL_STATE(234)] = 13753,
-  [SMALL_STATE(235)] = 13805,
-  [SMALL_STATE(236)] = 13857,
-  [SMALL_STATE(237)] = 13909,
-  [SMALL_STATE(238)] = 13961,
-  [SMALL_STATE(239)] = 14013,
-  [SMALL_STATE(240)] = 14065,
-  [SMALL_STATE(241)] = 14097,
-  [SMALL_STATE(242)] = 14149,
-  [SMALL_STATE(243)] = 14201,
-  [SMALL_STATE(244)] = 14233,
-  [SMALL_STATE(245)] = 14265,
-  [SMALL_STATE(246)] = 14297,
-  [SMALL_STATE(247)] = 14349,
-  [SMALL_STATE(248)] = 14386,
-  [SMALL_STATE(249)] = 14421,
-  [SMALL_STATE(250)] = 14454,
-  [SMALL_STATE(251)] = 14487,
-  [SMALL_STATE(252)] = 14530,
-  [SMALL_STATE(253)] = 14573,
-  [SMALL_STATE(254)] = 14602,
-  [SMALL_STATE(255)] = 14645,
-  [SMALL_STATE(256)] = 14688,
-  [SMALL_STATE(257)] = 14723,
-  [SMALL_STATE(258)] = 14766,
-  [SMALL_STATE(259)] = 14811,
-  [SMALL_STATE(260)] = 14857,
-  [SMALL_STATE(261)] = 14899,
-  [SMALL_STATE(262)] = 14945,
-  [SMALL_STATE(263)] = 14977,
-  [SMALL_STATE(264)] = 15023,
-  [SMALL_STATE(265)] = 15069,
-  [SMALL_STATE(266)] = 15103,
-  [SMALL_STATE(267)] = 15145,
-  [SMALL_STATE(268)] = 15191,
-  [SMALL_STATE(269)] = 15237,
-  [SMALL_STATE(270)] = 15283,
-  [SMALL_STATE(271)] = 15329,
-  [SMALL_STATE(272)] = 15369,
-  [SMALL_STATE(273)] = 15409,
-  [SMALL_STATE(274)] = 15431,
-  [SMALL_STATE(275)] = 15453,
-  [SMALL_STATE(276)] = 15475,
-  [SMALL_STATE(277)] = 15495,
-  [SMALL_STATE(278)] = 15515,
-  [SMALL_STATE(279)] = 15535,
-  [SMALL_STATE(280)] = 15555,
-  [SMALL_STATE(281)] = 15574,
-  [SMALL_STATE(282)] = 15593,
-  [SMALL_STATE(283)] = 15618,
-  [SMALL_STATE(284)] = 15643,
-  [SMALL_STATE(285)] = 15657,
-  [SMALL_STATE(286)] = 15673,
-  [SMALL_STATE(287)] = 15693,
-  [SMALL_STATE(288)] = 15707,
-  [SMALL_STATE(289)] = 15721,
-  [SMALL_STATE(290)] = 15740,
-  [SMALL_STATE(291)] = 15759,
-  [SMALL_STATE(292)] = 15778,
-  [SMALL_STATE(293)] = 15797,
-  [SMALL_STATE(294)] = 15816,
-  [SMALL_STATE(295)] = 15835,
-  [SMALL_STATE(296)] = 15854,
-  [SMALL_STATE(297)] = 15873,
-  [SMALL_STATE(298)] = 15887,
-  [SMALL_STATE(299)] = 15899,
-  [SMALL_STATE(300)] = 15913,
-  [SMALL_STATE(301)] = 15927,
-  [SMALL_STATE(302)] = 15939,
-  [SMALL_STATE(303)] = 15949,
-  [SMALL_STATE(304)] = 15961,
-  [SMALL_STATE(305)] = 15971,
-  [SMALL_STATE(306)] = 15981,
-  [SMALL_STATE(307)] = 15991,
-  [SMALL_STATE(308)] = 16001,
-  [SMALL_STATE(309)] = 16011,
-  [SMALL_STATE(310)] = 16021,
-  [SMALL_STATE(311)] = 16031,
-  [SMALL_STATE(312)] = 16041,
-  [SMALL_STATE(313)] = 16055,
-  [SMALL_STATE(314)] = 16069,
-  [SMALL_STATE(315)] = 16083,
-  [SMALL_STATE(316)] = 16093,
-  [SMALL_STATE(317)] = 16107,
-  [SMALL_STATE(318)] = 16117,
-  [SMALL_STATE(319)] = 16127,
-  [SMALL_STATE(320)] = 16141,
-  [SMALL_STATE(321)] = 16155,
-  [SMALL_STATE(322)] = 16168,
-  [SMALL_STATE(323)] = 16181,
-  [SMALL_STATE(324)] = 16194,
-  [SMALL_STATE(325)] = 16207,
-  [SMALL_STATE(326)] = 16220,
-  [SMALL_STATE(327)] = 16233,
-  [SMALL_STATE(328)] = 16246,
-  [SMALL_STATE(329)] = 16257,
-  [SMALL_STATE(330)] = 16270,
-  [SMALL_STATE(331)] = 16283,
-  [SMALL_STATE(332)] = 16296,
-  [SMALL_STATE(333)] = 16309,
-  [SMALL_STATE(334)] = 16322,
-  [SMALL_STATE(335)] = 16335,
-  [SMALL_STATE(336)] = 16348,
-  [SMALL_STATE(337)] = 16361,
-  [SMALL_STATE(338)] = 16374,
-  [SMALL_STATE(339)] = 16387,
-  [SMALL_STATE(340)] = 16398,
-  [SMALL_STATE(341)] = 16411,
-  [SMALL_STATE(342)] = 16424,
-  [SMALL_STATE(343)] = 16435,
-  [SMALL_STATE(344)] = 16448,
-  [SMALL_STATE(345)] = 16461,
-  [SMALL_STATE(346)] = 16474,
-  [SMALL_STATE(347)] = 16484,
-  [SMALL_STATE(348)] = 16494,
-  [SMALL_STATE(349)] = 16504,
-  [SMALL_STATE(350)] = 16514,
-  [SMALL_STATE(351)] = 16524,
-  [SMALL_STATE(352)] = 16534,
-  [SMALL_STATE(353)] = 16544,
-  [SMALL_STATE(354)] = 16552,
-  [SMALL_STATE(355)] = 16562,
-  [SMALL_STATE(356)] = 16570,
-  [SMALL_STATE(357)] = 16578,
-  [SMALL_STATE(358)] = 16588,
-  [SMALL_STATE(359)] = 16598,
-  [SMALL_STATE(360)] = 16608,
-  [SMALL_STATE(361)] = 16615,
-  [SMALL_STATE(362)] = 16622,
-  [SMALL_STATE(363)] = 16629,
-  [SMALL_STATE(364)] = 16636,
-  [SMALL_STATE(365)] = 16643,
-  [SMALL_STATE(366)] = 16650,
-  [SMALL_STATE(367)] = 16657,
-  [SMALL_STATE(368)] = 16664,
-  [SMALL_STATE(369)] = 16671,
-  [SMALL_STATE(370)] = 16678,
-  [SMALL_STATE(371)] = 16685,
-  [SMALL_STATE(372)] = 16692,
-  [SMALL_STATE(373)] = 16699,
-  [SMALL_STATE(374)] = 16706,
-  [SMALL_STATE(375)] = 16713,
-  [SMALL_STATE(376)] = 16720,
-  [SMALL_STATE(377)] = 16727,
-  [SMALL_STATE(378)] = 16734,
-  [SMALL_STATE(379)] = 16741,
-  [SMALL_STATE(380)] = 16748,
-  [SMALL_STATE(381)] = 16755,
-  [SMALL_STATE(382)] = 16762,
-  [SMALL_STATE(383)] = 16769,
-  [SMALL_STATE(384)] = 16776,
+  [SMALL_STATE(3)] = 102,
+  [SMALL_STATE(4)] = 202,
+  [SMALL_STATE(5)] = 304,
+  [SMALL_STATE(6)] = 403,
+  [SMALL_STATE(7)] = 502,
+  [SMALL_STATE(8)] = 601,
+  [SMALL_STATE(9)] = 700,
+  [SMALL_STATE(10)] = 799,
+  [SMALL_STATE(11)] = 898,
+  [SMALL_STATE(12)] = 997,
+  [SMALL_STATE(13)] = 1096,
+  [SMALL_STATE(14)] = 1195,
+  [SMALL_STATE(15)] = 1294,
+  [SMALL_STATE(16)] = 1393,
+  [SMALL_STATE(17)] = 1492,
+  [SMALL_STATE(18)] = 1591,
+  [SMALL_STATE(19)] = 1690,
+  [SMALL_STATE(20)] = 1789,
+  [SMALL_STATE(21)] = 1885,
+  [SMALL_STATE(22)] = 1981,
+  [SMALL_STATE(23)] = 2077,
+  [SMALL_STATE(24)] = 2173,
+  [SMALL_STATE(25)] = 2269,
+  [SMALL_STATE(26)] = 2365,
+  [SMALL_STATE(27)] = 2461,
+  [SMALL_STATE(28)] = 2557,
+  [SMALL_STATE(29)] = 2653,
+  [SMALL_STATE(30)] = 2749,
+  [SMALL_STATE(31)] = 2845,
+  [SMALL_STATE(32)] = 2941,
+  [SMALL_STATE(33)] = 3037,
+  [SMALL_STATE(34)] = 3133,
+  [SMALL_STATE(35)] = 3228,
+  [SMALL_STATE(36)] = 3283,
+  [SMALL_STATE(37)] = 3378,
+  [SMALL_STATE(38)] = 3469,
+  [SMALL_STATE(39)] = 3564,
+  [SMALL_STATE(40)] = 3659,
+  [SMALL_STATE(41)] = 3754,
+  [SMALL_STATE(42)] = 3845,
+  [SMALL_STATE(43)] = 3902,
+  [SMALL_STATE(44)] = 3993,
+  [SMALL_STATE(45)] = 4088,
+  [SMALL_STATE(46)] = 4183,
+  [SMALL_STATE(47)] = 4274,
+  [SMALL_STATE(48)] = 4369,
+  [SMALL_STATE(49)] = 4424,
+  [SMALL_STATE(50)] = 4515,
+  [SMALL_STATE(51)] = 4582,
+  [SMALL_STATE(52)] = 4639,
+  [SMALL_STATE(53)] = 4706,
+  [SMALL_STATE(54)] = 4797,
+  [SMALL_STATE(55)] = 4885,
+  [SMALL_STATE(56)] = 4973,
+  [SMALL_STATE(57)] = 5039,
+  [SMALL_STATE(58)] = 5099,
+  [SMALL_STATE(59)] = 5155,
+  [SMALL_STATE(60)] = 5221,
+  [SMALL_STATE(61)] = 5275,
+  [SMALL_STATE(62)] = 5334,
+  [SMALL_STATE(63)] = 5383,
+  [SMALL_STATE(64)] = 5432,
+  [SMALL_STATE(65)] = 5481,
+  [SMALL_STATE(66)] = 5530,
+  [SMALL_STATE(67)] = 5579,
+  [SMALL_STATE(68)] = 5628,
+  [SMALL_STATE(69)] = 5677,
+  [SMALL_STATE(70)] = 5726,
+  [SMALL_STATE(71)] = 5775,
+  [SMALL_STATE(72)] = 5824,
+  [SMALL_STATE(73)] = 5873,
+  [SMALL_STATE(74)] = 5922,
+  [SMALL_STATE(75)] = 5971,
+  [SMALL_STATE(76)] = 6026,
+  [SMALL_STATE(77)] = 6075,
+  [SMALL_STATE(78)] = 6124,
+  [SMALL_STATE(79)] = 6173,
+  [SMALL_STATE(80)] = 6236,
+  [SMALL_STATE(81)] = 6301,
+  [SMALL_STATE(82)] = 6364,
+  [SMALL_STATE(83)] = 6434,
+  [SMALL_STATE(84)] = 6504,
+  [SMALL_STATE(85)] = 6550,
+  [SMALL_STATE(86)] = 6596,
+  [SMALL_STATE(87)] = 6640,
+  [SMALL_STATE(88)] = 6696,
+  [SMALL_STATE(89)] = 6736,
+  [SMALL_STATE(90)] = 6792,
+  [SMALL_STATE(91)] = 6836,
+  [SMALL_STATE(92)] = 6876,
+  [SMALL_STATE(93)] = 6921,
+  [SMALL_STATE(94)] = 6976,
+  [SMALL_STATE(95)] = 7031,
+  [SMALL_STATE(96)] = 7074,
+  [SMALL_STATE(97)] = 7112,
+  [SMALL_STATE(98)] = 7150,
+  [SMALL_STATE(99)] = 7188,
+  [SMALL_STATE(100)] = 7226,
+  [SMALL_STATE(101)] = 7264,
+  [SMALL_STATE(102)] = 7302,
+  [SMALL_STATE(103)] = 7340,
+  [SMALL_STATE(104)] = 7378,
+  [SMALL_STATE(105)] = 7416,
+  [SMALL_STATE(106)] = 7454,
+  [SMALL_STATE(107)] = 7492,
+  [SMALL_STATE(108)] = 7530,
+  [SMALL_STATE(109)] = 7586,
+  [SMALL_STATE(110)] = 7624,
+  [SMALL_STATE(111)] = 7662,
+  [SMALL_STATE(112)] = 7718,
+  [SMALL_STATE(113)] = 7778,
+  [SMALL_STATE(114)] = 7838,
+  [SMALL_STATE(115)] = 7875,
+  [SMALL_STATE(116)] = 7918,
+  [SMALL_STATE(117)] = 7961,
+  [SMALL_STATE(118)] = 7998,
+  [SMALL_STATE(119)] = 8035,
+  [SMALL_STATE(120)] = 8093,
+  [SMALL_STATE(121)] = 8127,
+  [SMALL_STATE(122)] = 8185,
+  [SMALL_STATE(123)] = 8219,
+  [SMALL_STATE(124)] = 8253,
+  [SMALL_STATE(125)] = 8287,
+  [SMALL_STATE(126)] = 8345,
+  [SMALL_STATE(127)] = 8403,
+  [SMALL_STATE(128)] = 8461,
+  [SMALL_STATE(129)] = 8519,
+  [SMALL_STATE(130)] = 8577,
+  [SMALL_STATE(131)] = 8635,
+  [SMALL_STATE(132)] = 8693,
+  [SMALL_STATE(133)] = 8751,
+  [SMALL_STATE(134)] = 8809,
+  [SMALL_STATE(135)] = 8843,
+  [SMALL_STATE(136)] = 8901,
+  [SMALL_STATE(137)] = 8935,
+  [SMALL_STATE(138)] = 8969,
+  [SMALL_STATE(139)] = 9003,
+  [SMALL_STATE(140)] = 9061,
+  [SMALL_STATE(141)] = 9095,
+  [SMALL_STATE(142)] = 9129,
+  [SMALL_STATE(143)] = 9163,
+  [SMALL_STATE(144)] = 9201,
+  [SMALL_STATE(145)] = 9235,
+  [SMALL_STATE(146)] = 9293,
+  [SMALL_STATE(147)] = 9327,
+  [SMALL_STATE(148)] = 9361,
+  [SMALL_STATE(149)] = 9394,
+  [SMALL_STATE(150)] = 9433,
+  [SMALL_STATE(151)] = 9466,
+  [SMALL_STATE(152)] = 9503,
+  [SMALL_STATE(153)] = 9540,
+  [SMALL_STATE(154)] = 9589,
+  [SMALL_STATE(155)] = 9628,
+  [SMALL_STATE(156)] = 9677,
+  [SMALL_STATE(157)] = 9729,
+  [SMALL_STATE(158)] = 9761,
+  [SMALL_STATE(159)] = 9813,
+  [SMALL_STATE(160)] = 9865,
+  [SMALL_STATE(161)] = 9917,
+  [SMALL_STATE(162)] = 9969,
+  [SMALL_STATE(163)] = 10021,
+  [SMALL_STATE(164)] = 10073,
+  [SMALL_STATE(165)] = 10125,
+  [SMALL_STATE(166)] = 10177,
+  [SMALL_STATE(167)] = 10229,
+  [SMALL_STATE(168)] = 10281,
+  [SMALL_STATE(169)] = 10333,
+  [SMALL_STATE(170)] = 10385,
+  [SMALL_STATE(171)] = 10437,
+  [SMALL_STATE(172)] = 10473,
+  [SMALL_STATE(173)] = 10525,
+  [SMALL_STATE(174)] = 10577,
+  [SMALL_STATE(175)] = 10629,
+  [SMALL_STATE(176)] = 10681,
+  [SMALL_STATE(177)] = 10729,
+  [SMALL_STATE(178)] = 10767,
+  [SMALL_STATE(179)] = 10799,
+  [SMALL_STATE(180)] = 10851,
+  [SMALL_STATE(181)] = 10903,
+  [SMALL_STATE(182)] = 10951,
+  [SMALL_STATE(183)] = 11003,
+  [SMALL_STATE(184)] = 11055,
+  [SMALL_STATE(185)] = 11107,
+  [SMALL_STATE(186)] = 11159,
+  [SMALL_STATE(187)] = 11211,
+  [SMALL_STATE(188)] = 11243,
+  [SMALL_STATE(189)] = 11295,
+  [SMALL_STATE(190)] = 11347,
+  [SMALL_STATE(191)] = 11399,
+  [SMALL_STATE(192)] = 11451,
+  [SMALL_STATE(193)] = 11483,
+  [SMALL_STATE(194)] = 11535,
+  [SMALL_STATE(195)] = 11587,
+  [SMALL_STATE(196)] = 11639,
+  [SMALL_STATE(197)] = 11691,
+  [SMALL_STATE(198)] = 11743,
+  [SMALL_STATE(199)] = 11785,
+  [SMALL_STATE(200)] = 11837,
+  [SMALL_STATE(201)] = 11889,
+  [SMALL_STATE(202)] = 11941,
+  [SMALL_STATE(203)] = 11993,
+  [SMALL_STATE(204)] = 12045,
+  [SMALL_STATE(205)] = 12097,
+  [SMALL_STATE(206)] = 12149,
+  [SMALL_STATE(207)] = 12201,
+  [SMALL_STATE(208)] = 12253,
+  [SMALL_STATE(209)] = 12305,
+  [SMALL_STATE(210)] = 12357,
+  [SMALL_STATE(211)] = 12409,
+  [SMALL_STATE(212)] = 12461,
+  [SMALL_STATE(213)] = 12513,
+  [SMALL_STATE(214)] = 12565,
+  [SMALL_STATE(215)] = 12617,
+  [SMALL_STATE(216)] = 12669,
+  [SMALL_STATE(217)] = 12721,
+  [SMALL_STATE(218)] = 12773,
+  [SMALL_STATE(219)] = 12825,
+  [SMALL_STATE(220)] = 12856,
+  [SMALL_STATE(221)] = 12887,
+  [SMALL_STATE(222)] = 12924,
+  [SMALL_STATE(223)] = 12956,
+  [SMALL_STATE(224)] = 12986,
+  [SMALL_STATE(225)] = 13016,
+  [SMALL_STATE(226)] = 13046,
+  [SMALL_STATE(227)] = 13076,
+  [SMALL_STATE(228)] = 13106,
+  [SMALL_STATE(229)] = 13136,
+  [SMALL_STATE(230)] = 13166,
+  [SMALL_STATE(231)] = 13196,
+  [SMALL_STATE(232)] = 13226,
+  [SMALL_STATE(233)] = 13256,
+  [SMALL_STATE(234)] = 13286,
+  [SMALL_STATE(235)] = 13316,
+  [SMALL_STATE(236)] = 13346,
+  [SMALL_STATE(237)] = 13376,
+  [SMALL_STATE(238)] = 13409,
+  [SMALL_STATE(239)] = 13444,
+  [SMALL_STATE(240)] = 13489,
+  [SMALL_STATE(241)] = 13532,
+  [SMALL_STATE(242)] = 13575,
+  [SMALL_STATE(243)] = 13618,
+  [SMALL_STATE(244)] = 13651,
+  [SMALL_STATE(245)] = 13694,
+  [SMALL_STATE(246)] = 13729,
+  [SMALL_STATE(247)] = 13775,
+  [SMALL_STATE(248)] = 13821,
+  [SMALL_STATE(249)] = 13863,
+  [SMALL_STATE(250)] = 13897,
+  [SMALL_STATE(251)] = 13939,
+  [SMALL_STATE(252)] = 13985,
+  [SMALL_STATE(253)] = 14031,
+  [SMALL_STATE(254)] = 14063,
+  [SMALL_STATE(255)] = 14109,
+  [SMALL_STATE(256)] = 14155,
+  [SMALL_STATE(257)] = 14201,
+  [SMALL_STATE(258)] = 14247,
+  [SMALL_STATE(259)] = 14274,
+  [SMALL_STATE(260)] = 14314,
+  [SMALL_STATE(261)] = 14354,
+  [SMALL_STATE(262)] = 14376,
+  [SMALL_STATE(263)] = 14398,
+  [SMALL_STATE(264)] = 14420,
+  [SMALL_STATE(265)] = 14440,
+  [SMALL_STATE(266)] = 14460,
+  [SMALL_STATE(267)] = 14488,
+  [SMALL_STATE(268)] = 14516,
+  [SMALL_STATE(269)] = 14542,
+  [SMALL_STATE(270)] = 14561,
+  [SMALL_STATE(271)] = 14580,
+  [SMALL_STATE(272)] = 14599,
+  [SMALL_STATE(273)] = 14618,
+  [SMALL_STATE(274)] = 14634,
+  [SMALL_STATE(275)] = 14650,
+  [SMALL_STATE(276)] = 14666,
+  [SMALL_STATE(277)] = 14682,
+  [SMALL_STATE(278)] = 14703,
+  [SMALL_STATE(279)] = 14728,
+  [SMALL_STATE(280)] = 14749,
+  [SMALL_STATE(281)] = 14770,
+  [SMALL_STATE(282)] = 14795,
+  [SMALL_STATE(283)] = 14816,
+  [SMALL_STATE(284)] = 14836,
+  [SMALL_STATE(285)] = 14850,
+  [SMALL_STATE(286)] = 14864,
+  [SMALL_STATE(287)] = 14876,
+  [SMALL_STATE(288)] = 14888,
+  [SMALL_STATE(289)] = 14898,
+  [SMALL_STATE(290)] = 14908,
+  [SMALL_STATE(291)] = 14918,
+  [SMALL_STATE(292)] = 14928,
+  [SMALL_STATE(293)] = 14938,
+  [SMALL_STATE(294)] = 14948,
+  [SMALL_STATE(295)] = 14958,
+  [SMALL_STATE(296)] = 14968,
+  [SMALL_STATE(297)] = 14978,
+  [SMALL_STATE(298)] = 14988,
+  [SMALL_STATE(299)] = 14998,
+  [SMALL_STATE(300)] = 15010,
+  [SMALL_STATE(301)] = 15023,
+  [SMALL_STATE(302)] = 15036,
+  [SMALL_STATE(303)] = 15045,
+  [SMALL_STATE(304)] = 15056,
+  [SMALL_STATE(305)] = 15069,
+  [SMALL_STATE(306)] = 15082,
+  [SMALL_STATE(307)] = 15095,
+  [SMALL_STATE(308)] = 15108,
+  [SMALL_STATE(309)] = 15121,
+  [SMALL_STATE(310)] = 15134,
+  [SMALL_STATE(311)] = 15147,
+  [SMALL_STATE(312)] = 15160,
+  [SMALL_STATE(313)] = 15173,
+  [SMALL_STATE(314)] = 15186,
+  [SMALL_STATE(315)] = 15199,
+  [SMALL_STATE(316)] = 15212,
+  [SMALL_STATE(317)] = 15225,
+  [SMALL_STATE(318)] = 15238,
+  [SMALL_STATE(319)] = 15251,
+  [SMALL_STATE(320)] = 15264,
+  [SMALL_STATE(321)] = 15277,
+  [SMALL_STATE(322)] = 15290,
+  [SMALL_STATE(323)] = 15303,
+  [SMALL_STATE(324)] = 15314,
+  [SMALL_STATE(325)] = 15327,
+  [SMALL_STATE(326)] = 15340,
+  [SMALL_STATE(327)] = 15353,
+  [SMALL_STATE(328)] = 15366,
+  [SMALL_STATE(329)] = 15379,
+  [SMALL_STATE(330)] = 15392,
+  [SMALL_STATE(331)] = 15405,
+  [SMALL_STATE(332)] = 15418,
+  [SMALL_STATE(333)] = 15431,
+  [SMALL_STATE(334)] = 15441,
+  [SMALL_STATE(335)] = 15451,
+  [SMALL_STATE(336)] = 15461,
+  [SMALL_STATE(337)] = 15469,
+  [SMALL_STATE(338)] = 15479,
+  [SMALL_STATE(339)] = 15487,
+  [SMALL_STATE(340)] = 15497,
+  [SMALL_STATE(341)] = 15507,
+  [SMALL_STATE(342)] = 15517,
+  [SMALL_STATE(343)] = 15527,
+  [SMALL_STATE(344)] = 15534,
+  [SMALL_STATE(345)] = 15541,
+  [SMALL_STATE(346)] = 15548,
+  [SMALL_STATE(347)] = 15555,
+  [SMALL_STATE(348)] = 15562,
+  [SMALL_STATE(349)] = 15569,
+  [SMALL_STATE(350)] = 15576,
+  [SMALL_STATE(351)] = 15583,
+  [SMALL_STATE(352)] = 15590,
+  [SMALL_STATE(353)] = 15597,
+  [SMALL_STATE(354)] = 15604,
+  [SMALL_STATE(355)] = 15611,
+  [SMALL_STATE(356)] = 15618,
+  [SMALL_STATE(357)] = 15625,
+  [SMALL_STATE(358)] = 15632,
+  [SMALL_STATE(359)] = 15639,
+  [SMALL_STATE(360)] = 15646,
+  [SMALL_STATE(361)] = 15653,
 };
 
 static const TSParseActionEntry ts_parse_actions[] = {
   [0] = {.entry = {.count = 0, .reusable = false}},
   [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(),
   [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(),
-  [5] = {.entry = {.count = 1, .reusable = false}}, SHIFT(49),
-  [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(374),
+  [5] = {.entry = {.count = 1, .reusable = false}}, SHIFT(57),
+  [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(354),
   [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2),
-  [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203),
-  [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(70),
-  [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70),
-  [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(71),
-  [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131),
-  [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(219),
-  [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(241),
-  [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(246),
-  [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(384),
-  [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(384),
-  [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(349),
-  [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381),
-  [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299),
-  [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(352),
-  [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(192),
-  [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(378),
-  [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(75),
-  [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72),
-  [47] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2),
-  [49] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(49),
-  [52] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(374),
-  [55] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(2),
-  [58] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(203),
-  [61] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(70),
-  [64] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(70),
-  [67] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(71),
-  [70] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(131),
-  [73] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(219),
-  [76] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(241),
-  [79] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(246),
-  [82] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(384),
-  [85] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(384),
-  [88] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(349),
-  [91] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(381),
-  [94] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(299),
-  [97] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(352),
-  [100] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(192),
-  [103] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(378),
-  [106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154),
-  [108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167),
-  [110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221),
-  [112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244),
-  [114] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_root, 1),
-  [116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274),
-  [118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153),
-  [120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68),
-  [122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163),
-  [124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58),
-  [126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275),
-  [128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87),
-  [130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94),
-  [132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170),
-  [134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169),
-  [136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168),
-  [138] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197),
-  [140] = {.entry = {.count = 1, .reusable = false}}, SHIFT(373),
-  [142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4),
-  [144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237),
-  [146] = {.entry = {.count = 1, .reusable = false}}, SHIFT(133),
-  [148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133),
-  [150] = {.entry = {.count = 1, .reusable = false}}, SHIFT(132),
-  [152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157),
-  [154] = {.entry = {.count = 1, .reusable = false}}, SHIFT(175),
-  [156] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176),
-  [158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(177),
-  [160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(365),
-  [162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365),
-  [164] = {.entry = {.count = 1, .reusable = false}}, SHIFT(351),
-  [166] = {.entry = {.count = 1, .reusable = false}}, SHIFT(375),
-  [168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300),
-  [170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(354),
-  [172] = {.entry = {.count = 1, .reusable = false}}, SHIFT(196),
-  [174] = {.entry = {.count = 1, .reusable = false}}, SHIFT(360),
-  [176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table, 3),
-  [178] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table, 3),
-  [180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220),
-  [182] = {.entry = {.count = 1, .reusable = false}}, SHIFT(281),
-  [184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281),
-  [186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280),
-  [188] = {.entry = {.count = 1, .reusable = false}}, SHIFT(280),
-  [190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(377),
-  [192] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math, 3),
-  [194] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math, 3),
-  [196] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index, 3),
-  [198] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index, 3),
-  [200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204),
-  [202] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic, 3),
-  [204] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic, 3),
+  [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186),
+  [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(77),
+  [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77),
+  [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(64),
+  [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139),
+  [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(188),
+  [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191),
+  [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(193),
+  [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(355),
+  [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355),
+  [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319),
+  [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(339),
+  [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(195),
+  [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(357),
+  [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(61),
+  [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73),
+  [43] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2),
+  [45] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(57),
+  [48] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(354),
+  [51] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(2),
+  [54] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(186),
+  [57] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(77),
+  [60] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(77),
+  [63] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(64),
+  [66] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(139),
+  [69] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(188),
+  [72] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(191),
+  [75] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(193),
+  [78] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(355),
+  [81] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(355),
+  [84] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(319),
+  [87] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(339),
+  [90] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(195),
+  [93] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(357),
+  [96] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137),
+  [98] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262),
+  [100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150),
+  [102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148),
+  [104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219),
+  [106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233),
+  [108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88),
+  [110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220),
+  [112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261),
+  [114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228),
+  [116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68),
+  [118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91),
+  [120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178),
+  [122] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_root, 1),
+  [124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157),
+  [126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71),
+  [128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index, 3),
+  [130] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index, 3),
+  [132] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198),
+  [134] = {.entry = {.count = 1, .reusable = false}}, SHIFT(356),
+  [136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4),
+  [138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196),
+  [140] = {.entry = {.count = 1, .reusable = false}}, SHIFT(146),
+  [142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146),
+  [144] = {.entry = {.count = 1, .reusable = false}}, SHIFT(147),
+  [146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129),
+  [148] = {.entry = {.count = 1, .reusable = false}}, SHIFT(190),
+  [150] = {.entry = {.count = 1, .reusable = false}}, SHIFT(200),
+  [152] = {.entry = {.count = 1, .reusable = false}}, SHIFT(218),
+  [154] = {.entry = {.count = 1, .reusable = false}}, SHIFT(345),
+  [156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(345),
+  [158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332),
+  [160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(333),
+  [162] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197),
+  [164] = {.entry = {.count = 1, .reusable = false}}, SHIFT(360),
+  [166] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102),
+  [168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313),
+  [170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179),
+  [172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69),
+  [174] = {.entry = {.count = 1, .reusable = false}}, SHIFT(106),
+  [176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106),
+  [178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(104),
+  [180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121),
+  [182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172),
+  [184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271),
+  [186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(271),
+  [188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272),
+  [190] = {.entry = {.count = 1, .reusable = false}}, SHIFT(272),
+  [192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(308),
+  [194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(342),
+  [196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(344),
+  [198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136),
+  [200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169),
+  [202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120),
+  [204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76),
   [206] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index, 5),
   [208] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index, 5),
-  [210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226),
-  [212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_kind, 1),
-  [214] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_kind, 1),
-  [216] = {.entry = {.count = 1, .reusable = false}}, SHIFT(253),
-  [218] = {.entry = {.count = 1, .reusable = false}}, SHIFT(284),
-  [220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253),
-  [222] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 5),
-  [224] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 5),
-  [226] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3),
-  [228] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3),
-  [230] = {.entry = {.count = 1, .reusable = false}}, SHIFT(111),
-  [232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(334),
-  [234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222),
-  [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54),
-  [238] = {.entry = {.count = 1, .reusable = false}}, SHIFT(99),
-  [240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99),
-  [242] = {.entry = {.count = 1, .reusable = false}}, SHIFT(103),
-  [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155),
-  [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180),
-  [248] = {.entry = {.count = 1, .reusable = false}}, SHIFT(314),
-  [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(347),
-  [252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383),
-  [254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4),
-  [256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4),
-  [258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4),
-  [260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4),
-  [262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 4),
-  [264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 4),
-  [266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 2),
-  [268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 2),
-  [270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135),
-  [272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64),
-  [274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 3),
-  [276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 3),
-  [278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield, 5),
-  [280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield, 5),
-  [282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield, 6),
-  [284] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield, 6),
-  [286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 3),
-  [288] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 3),
-  [290] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 3),
-  [292] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 3),
-  [294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3),
-  [296] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3),
-  [298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105),
-  [300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_value, 1),
-  [302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_value, 1),
-  [304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1),
-  [306] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1),
-  [308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 2),
-  [310] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 2),
-  [312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 3),
-  [314] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 3),
-  [316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144),
-  [318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(35),
-  [320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101),
-  [322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1),
-  [324] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1),
-  [326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select, 4),
-  [328] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select, 4),
-  [330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29),
-  [332] = {.entry = {.count = 1, .reusable = false}}, SHIFT(150),
-  [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338),
-  [336] = {.entry = {.count = 1, .reusable = false}}, SHIFT(313),
-  [338] = {.entry = {.count = 1, .reusable = false}}, SHIFT(346),
-  [340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return, 2),
-  [342] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return, 2),
-  [344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1),
-  [346] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1),
-  [348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225),
-  [350] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_insert, 4),
-  [352] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_insert, 4),
-  [354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2),
-  [356] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(150),
-  [359] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2),
-  [361] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(338),
-  [364] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(237),
-  [367] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(133),
-  [370] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(133),
-  [373] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(132),
-  [376] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(157),
-  [379] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(313),
-  [382] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(346),
-  [385] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match, 3),
-  [387] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match, 3),
-  [389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313),
-  [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189),
-  [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191),
-  [395] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 1),
-  [397] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 1),
-  [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279),
-  [401] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 1),
-  [403] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list, 1),
-  [405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277),
-  [407] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 2),
-  [409] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 2),
-  [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238),
-  [413] = {.entry = {.count = 1, .reusable = false}}, SHIFT(341),
-  [415] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 1),
-  [417] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 1),
-  [419] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2),
-  [421] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_else_repeat1, 2),
-  [423] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(238),
-  [426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107),
-  [428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143),
-  [430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223),
-  [432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367),
-  [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67),
-  [436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184),
-  [438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136),
-  [440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314),
-  [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60),
-  [444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148),
-  [446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65),
-  [448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66),
-  [450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if, 3),
-  [452] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if, 3),
-  [454] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(111),
-  [457] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(334),
-  [460] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(222),
-  [463] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(99),
-  [466] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(99),
-  [469] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(103),
-  [472] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(155),
-  [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2),
-  [477] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(314),
-  [480] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(347),
-  [483] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142),
-  [485] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57),
-  [487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115),
-  [489] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156),
-  [491] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(111),
-  [494] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(334),
-  [497] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(222),
-  [500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list, 2),
-  [502] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(99),
-  [505] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(99),
-  [508] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(103),
-  [511] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(155),
-  [514] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(314),
-  [517] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(347),
-  [520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110),
-  [522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113),
-  [524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if, 3),
-  [526] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if, 3),
-  [528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205),
-  [530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106),
-  [532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else, 2),
-  [534] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else, 2),
-  [536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 3),
-  [538] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 3),
-  [540] = {.entry = {.count = 1, .reusable = false}}, SHIFT(358),
-  [542] = {.entry = {.count = 1, .reusable = false}}, SHIFT(359),
-  [544] = {.entry = {.count = 1, .reusable = false}}, SHIFT(77),
-  [546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332),
-  [548] = {.entry = {.count = 1, .reusable = false}}, SHIFT(348),
-  [550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28),
-  [552] = {.entry = {.count = 1, .reusable = false}}, SHIFT(350),
-  [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_select, 5),
-  [556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_select, 5),
-  [558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for, 5),
-  [560] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for, 5),
-  [562] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 3),
-  [564] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 3),
-  [566] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126),
-  [568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 4, .production_id = 2),
-  [570] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 4, .production_id = 2),
-  [572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use, 2),
-  [574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_use, 2),
-  [576] = {.entry = {.count = 1, .reusable = false}}, SHIFT(122),
-  [578] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2),
-  [580] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2),
-  [582] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_assignment, 3),
-  [584] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_assignment, 3),
-  [586] = {.entry = {.count = 1, .reusable = false}}, SHIFT(123),
-  [588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while, 3),
-  [590] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while, 3),
-  [592] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, .production_id = 1),
-  [594] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3, .production_id = 1),
-  [596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224),
-  [598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181),
-  [600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_operator, 1),
-  [602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_operator, 1),
-  [604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317),
-  [606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(362),
-  [608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22),
-  [610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208),
-  [612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374),
-  [614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373),
-  [616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361),
-  [618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26),
-  [620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329),
-  [622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325),
-  [624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier_list, 3),
-  [626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier_list, 3),
-  [628] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 2),
-  [630] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier_list, 2),
-  [632] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier_list, 2),
-  [634] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2),
-  [636] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic_operator, 1),
-  [638] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic_operator, 1),
-  [640] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math_operator, 1),
-  [642] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math_operator, 1),
-  [644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202),
-  [646] = {.entry = {.count = 1, .reusable = false}}, SHIFT(326),
-  [648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379),
-  [650] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 3),
-  [652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 3),
-  [654] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(202),
-  [657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363),
-  [659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23),
-  [661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284),
-  [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372),
-  [665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21),
-  [667] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2), SHIFT_REPEAT(357),
-  [670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2),
-  [672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(357),
-  [674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295),
-  [676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289),
-  [678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296),
-  [680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293),
-  [682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291),
-  [684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294),
-  [686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290),
-  [688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292),
-  [690] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_identifier_list_repeat1, 2), SHIFT_REPEAT(339),
-  [693] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_identifier_list_repeat1, 2),
-  [695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(339),
-  [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278),
-  [699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(380),
-  [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109),
-  [703] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 3),
-  [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(353),
-  [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(364),
-  [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31),
-  [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140),
-  [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112),
-  [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276),
-  [717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73),
-  [719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_identifier_list_repeat1, 1),
-  [721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(356),
-  [723] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 2), SHIFT_REPEAT(380),
-  [726] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 2),
-  [728] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 2),
-  [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(355),
-  [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324),
-  [734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 4),
-  [736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3),
-  [738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318),
-  [740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27),
-  [742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25),
-  [744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30),
-  [746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33),
-  [748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366),
-  [750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206),
-  [752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242),
-  [754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235),
-  [756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236),
-  [758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174),
-  [760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239),
-  [762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24),
-  [764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32),
-  [766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20),
-  [768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370),
-  [770] = {.entry = {.count = 1, .reusable = true}},  ACCEPT_INPUT(),
-  [772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228),
-  [774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218),
-  [776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285),
-  [778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34),
-  [780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368),
-  [782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173),
-  [784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211),
-  [786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(371),
+  [210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110),
+  [212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic, 3),
+  [214] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic, 3),
+  [216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165),
+  [218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(350),
+  [220] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math, 3),
+  [222] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math, 3),
+  [224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_table, 3),
+  [226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_table, 3),
+  [228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103),
+  [230] = {.entry = {.count = 1, .reusable = false}}, SHIFT(144),
+  [232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312),
+  [234] = {.entry = {.count = 1, .reusable = false}}, SHIFT(314),
+  [236] = {.entry = {.count = 1, .reusable = false}}, SHIFT(340),
+  [238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164),
+  [240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_kind, 1),
+  [242] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_kind, 1),
+  [244] = {.entry = {.count = 1, .reusable = false}}, SHIFT(258),
+  [246] = {.entry = {.count = 1, .reusable = false}}, SHIFT(282),
+  [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258),
+  [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(47),
+  [252] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 3),
+  [254] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 3),
+  [256] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 4),
+  [258] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 4),
+  [260] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1),
+  [262] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1),
+  [264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 2),
+  [266] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 2),
+  [268] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield, 6),
+  [270] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield, 6),
+  [272] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 3),
+  [274] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 3),
+  [276] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4),
+  [278] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4),
+  [280] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3),
+  [282] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3),
+  [284] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 3),
+  [286] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 3),
+  [288] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3),
+  [290] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3),
+  [292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4),
+  [294] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4),
+  [296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 2),
+  [298] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 2),
+  [300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1),
+  [302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1),
+  [304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield, 5),
+  [306] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield, 5),
+  [308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_value, 1),
+  [310] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_value, 1),
+  [312] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 3),
+  [314] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 3),
+  [316] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return, 2),
+  [318] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return, 2),
+  [320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1),
+  [322] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1),
+  [324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236),
+  [326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match, 3),
+  [328] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match, 3),
+  [330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314),
+  [332] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2),
+  [334] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(144),
+  [337] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2),
+  [339] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(312),
+  [342] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(196),
+  [345] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(146),
+  [348] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(146),
+  [351] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(147),
+  [354] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(129),
+  [357] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(314),
+  [360] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(340),
+  [363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161),
+  [365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201),
+  [367] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 1),
+  [369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 1),
+  [371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265),
+  [373] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 1),
+  [375] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list, 1),
+  [377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264),
+  [379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124),
+  [381] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 1),
+  [383] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 1),
+  [385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156),
+  [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(306),
+  [389] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 2),
+  [391] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 2),
+  [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100),
+  [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62),
+  [397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78),
+  [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308),
+  [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99),
+  [403] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(102),
+  [406] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(313),
+  [409] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(179),
+  [412] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(106),
+  [415] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(106),
+  [418] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(104),
+  [421] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(121),
+  [424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2),
+  [426] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(308),
+  [429] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(342),
+  [432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142),
+  [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123),
+  [436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140),
+  [438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134),
+  [440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96),
+  [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66),
+  [444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97),
+  [446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98),
+  [448] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(102),
+  [451] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(313),
+  [454] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(179),
+  [457] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list, 2),
+  [459] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(106),
+  [462] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(106),
+  [465] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(104),
+  [468] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(121),
+  [471] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(308),
+  [474] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(342),
+  [477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65),
+  [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2),
+  [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_else_repeat1, 2),
+  [483] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(156),
+  [486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72),
+  [488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175),
+  [490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170),
+  [492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359),
+  [494] = {.entry = {.count = 1, .reusable = false}}, SHIFT(335),
+  [496] = {.entry = {.count = 1, .reusable = false}}, SHIFT(334),
+  [498] = {.entry = {.count = 1, .reusable = false}}, SHIFT(74),
+  [500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307),
+  [502] = {.entry = {.count = 1, .reusable = false}}, SHIFT(341),
+  [504] = {.entry = {.count = 1, .reusable = false}}, SHIFT(337),
+  [506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184),
+  [508] = {.entry = {.count = 1, .reusable = false}}, SHIFT(117),
+  [510] = {.entry = {.count = 1, .reusable = false}}, SHIFT(118),
+  [512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if, 3),
+  [514] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if, 3),
+  [516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if, 3),
+  [518] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if, 3),
+  [520] = {.entry = {.count = 1, .reusable = false}}, SHIFT(114),
+  [522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3, .production_id = 1),
+  [524] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3, .production_id = 1),
+  [526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while, 3),
+  [528] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while, 3),
+  [530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_assignment, 3),
+  [532] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_assignment, 3),
+  [534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 3),
+  [536] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 3),
+  [538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for, 5),
+  [540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for, 5),
+  [542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else, 2),
+  [544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else, 2),
+  [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 3),
+  [548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 3),
+  [550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use, 2),
+  [552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_use, 2),
+  [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 4, .production_id = 2),
+  [556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 4, .production_id = 2),
+  [558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2),
+  [560] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2),
+  [562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209),
+  [564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296),
+  [566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167),
+  [568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(353),
+  [570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29),
+  [572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211),
+  [574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(356),
+  [576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27),
+  [578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346),
+  [580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32),
+  [582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(354),
+  [584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22),
+  [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_operator, 1),
+  [588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_operator, 1),
+  [590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305),
+  [592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321),
+  [594] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 2),
+  [596] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2),
+  [598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1),
+  [600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274),
+  [602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266),
+  [604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279),
+  [606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277),
+  [608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 2),
+  [610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280),
+  [612] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2),
+  [614] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(274),
+  [617] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(266),
+  [620] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(277),
+  [623] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier_list, 3),
+  [625] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier_list, 3),
+  [627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier_list, 2),
+  [629] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier_list, 2),
+  [631] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math_operator, 1),
+  [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math_operator, 1),
+  [635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic_operator, 1),
+  [637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic_operator, 1),
+  [639] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 3),
+  [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 4),
+  [643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214),
+  [645] = {.entry = {.count = 1, .reusable = false}}, SHIFT(318),
+  [647] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(214),
+  [650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(351),
+  [652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138),
+  [654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(349),
+  [656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31),
+  [658] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_definition, 3),
+  [660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 3),
+  [662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336),
+  [664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323),
+  [666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320),
+  [668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317),
+  [670] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 2), SHIFT_REPEAT(351),
+  [673] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 2),
+  [675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67),
+  [677] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107),
+  [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101),
+  [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322),
+  [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315),
+  [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325),
+  [687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348),
+  [689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33),
+  [691] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_identifier_list_repeat1, 1),
+  [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338),
+  [695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270),
+  [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347),
+  [699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25),
+  [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269),
+  [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329),
+  [705] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_identifier_list_repeat1, 2), SHIFT_REPEAT(323),
+  [708] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_identifier_list_repeat1, 2),
+  [710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301),
+  [712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330),
+  [714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324),
+  [716] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 4),
+  [718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208),
+  [720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207),
+  [722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343),
+  [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21),
+  [726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26),
+  [728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23),
+  [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20),
+  [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180),
+  [734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36),
+  [736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189),
+  [738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30),
+  [740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24),
+  [742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(352),
+  [744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28),
+  [746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231),
+  [748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302),
+  [750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194),
+  [752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297),
+  [754] = {.entry = {.count = 1, .reusable = true}},  ACCEPT_INPUT(),
 };
 
 #ifdef __cplusplus
diff --git a/tree-sitter-dust/test_output.md b/tree-sitter-dust/test_output.md
deleted file mode 100644
index e95a7d1..0000000
--- a/tree-sitter-dust/test_output.md
+++ /dev/null
@@ -1,14 +0,0 @@
-| Command | Mean [ms] | Min [ms] | Max [ms] | Relative |
-|:---|---:|---:|---:|---:|
-| `dust -c '(length (from_json input))' -p seaCreatures.json` | 2.9 ± 0.4 | 2.5 | 6.7 | 1.00 |
-| `jq 'length' seaCreatures.json` | 36.7 ± 4.4 | 34.7 | 65.0 | 12.59 ± 2.14 |
-| `node --eval "require('node:fs').readFile('seaCreatures.json', (err, data)=>{console.log(JSON.parse(data).length)})"` | 241.2 ± 13.3 | 227.7 | 273.2 | 82.63 ± 11.00 |
-| `nu -c 'open seaCreatures.json \| length'` | 54.0 ± 3.3 | 50.3 | 69.2 | 18.49 ± 2.51 |
-| `dust -c '(length (from_json input))' -p jq_data.json` | 7.9 ± 0.8 | 6.6 | 12.5 | 2.70 ± 0.43 |
-| `jq 'length' jq_data.json` | 44.8 ± 0.6 | 43.5 | 47.3 | 15.36 ± 1.87 |
-| `node --eval "require('node:fs').readFile('jq_data.json', (err, data)=>{console.log(JSON.parse(data).length)})"` | 245.2 ± 7.1 | 235.4 | 259.7 | 84.00 ± 10.46 |
-| `nu -c 'open jq_data.json \| length'` | 65.9 ± 5.0 | 62.0 | 90.5 | 22.57 ± 3.22 |
-| `dust -c '(length (from_json input))' -p dielectron.json` | 1079.5 ± 22.7 | 1043.8 | 1121.5 | 369.86 ± 45.46 |
-| `jq 'length' dielectron.json` | 1365.0 ± 20.3 | 1318.5 | 1400.1 | 467.67 ± 57.07 |
-| `node --eval "require('node:fs').readFile('dielectron.json', (err, data)=>{console.log(JSON.parse(data).length)})"` | 1910.8 ± 47.9 | 1855.9 | 1985.7 | 654.66 ± 80.97 |
-| `nu -c 'open dielectron.json \| length'` | 2001.2 ± 65.1 | 1923.2 | 2112.7 | 685.65 ± 85.98 |