diff --git a/examples/random.ds b/examples/random.ds
index 4c40c36..fb07cf1 100644
--- a/examples/random.ds
+++ b/examples/random.ds
@@ -1,13 +1,13 @@
 stuff = [
-	random_integer()
-	random_integer()
-	random_integer()
-	random_float()
-	random_float()
-	random_float()
-	random_boolean()
-	random_boolean()
-	random_boolean()
+	random:integer()
+	random:integer()
+	random:integer()
+	random:float()
+	random:float()
+	random:float()
+	random:boolean()
+	random:boolean()
+	random:boolean()
 ]
 
-random(stuff)
+random:from(stuff)
diff --git a/src/abstract_tree/function_call.rs b/src/abstract_tree/function_call.rs
index 29a06d5..342aad9 100644
--- a/src/abstract_tree/function_call.rs
+++ b/src/abstract_tree/function_call.rs
@@ -1,10 +1,7 @@
 use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
-use crate::{
-    AbstractTree, Error, Expression, FunctionExpression, Map, Result, Type, Value,
-    BUILT_IN_FUNCTIONS,
-};
+use crate::{AbstractTree, Error, Expression, FunctionExpression, Map, Result, Type, Value};
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
 pub struct FunctionCall {
@@ -84,21 +81,6 @@ impl AbstractTree for FunctionCall {
         let value = match &self.function_expression {
             FunctionExpression::Identifier(identifier) => {
                 let key = identifier.inner();
-
-                for built_in_function in BUILT_IN_FUNCTIONS {
-                    if key == built_in_function.name() {
-                        let mut arguments = Vec::with_capacity(self.arguments.len());
-
-                        for expression in &self.arguments {
-                            let value = expression.run(source, context)?;
-
-                            arguments.push(value);
-                        }
-
-                        return built_in_function.run(&arguments, context);
-                    }
-                }
-
                 let variables = context.variables()?;
 
                 if let Some((value, _)) = variables.get(key) {
@@ -131,18 +113,6 @@ impl AbstractTree for FunctionCall {
     fn expected_type(&self, context: &Map) -> Result<Type> {
         match &self.function_expression {
             FunctionExpression::Identifier(identifier) => {
-                for built_in_function in BUILT_IN_FUNCTIONS {
-                    if identifier.inner() == built_in_function.name() {
-                        if let Type::Function {
-                            parameter_types: _,
-                            return_type,
-                        } = built_in_function.r#type()
-                        {
-                            return Ok(*return_type);
-                        }
-                    }
-                }
-
                 let identifier_type = identifier.expected_type(context)?;
 
                 if let Type::Function {
@@ -156,7 +126,15 @@ impl AbstractTree for FunctionCall {
                 }
             }
             FunctionExpression::FunctionCall(function_call) => function_call.expected_type(context),
-            FunctionExpression::Value(value_node) => value_node.expected_type(context),
+            FunctionExpression::Value(value_node) => {
+                let value_type = value_node.expected_type(context)?;
+
+                if let Type::Function { return_type, .. } = value_type {
+                    Ok(*return_type)
+                } else {
+                    Ok(value_type)
+                }
+            }
             FunctionExpression::Index(index) => index.expected_type(context),
             FunctionExpression::Yield(r#yield) => r#yield.expected_type(context),
         }
diff --git a/src/abstract_tree/function_expression.rs b/src/abstract_tree/function_expression.rs
index 094c709..85e7868 100644
--- a/src/abstract_tree/function_expression.rs
+++ b/src/abstract_tree/function_expression.rs
@@ -30,6 +30,7 @@ impl AbstractTree for FunctionExpression {
             "identifier" => FunctionExpression::Identifier(Identifier::from_syntax_node(
                 source, child, context,
             )?),
+
             "function_call" => FunctionExpression::FunctionCall(Box::new(
                 FunctionCall::from_syntax_node(source, child, context)?,
             )),
diff --git a/src/abstract_tree/identifier.rs b/src/abstract_tree/identifier.rs
index 4225b54..feac63e 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, Type, Value, BUILT_IN_FUNCTIONS};
+use crate::{AbstractTree, Error, Map, Result, Type, Value};
 
 /// A string by which a variable is known to a context.
 ///
@@ -47,12 +47,6 @@ impl AbstractTree for Identifier {
         if let Some((_value, r#type)) = context.variables()?.get(&self.0) {
             Ok(r#type.clone())
         } else {
-            for built_in_function in BUILT_IN_FUNCTIONS {
-                if self.0 == built_in_function.name() {
-                    return Ok(built_in_function.r#type());
-                }
-            }
-
             Ok(Type::None)
         }
     }
diff --git a/src/abstract_tree/type_definition.rs b/src/abstract_tree/type_definition.rs
index 97dd197..1f4a1a6 100644
--- a/src/abstract_tree/type_definition.rs
+++ b/src/abstract_tree/type_definition.rs
@@ -68,6 +68,17 @@ pub enum Type {
 }
 
 impl Type {
+    pub fn list_of(item_type: Type) -> Self {
+        Type::List(Box::new(item_type))
+    }
+
+    pub fn function(parameter_types: Vec<Type>, return_type: Type) -> Self {
+        Type::Function {
+            parameter_types,
+            return_type: Box::new(return_type),
+        }
+    }
+
     pub fn check(&self, other: &Type) -> Result<()> {
         match (self, other) {
             (Type::Any, _)
diff --git a/src/abstract_tree/value_node.rs b/src/abstract_tree/value_node.rs
index d13a69a..3c33ffb 100644
--- a/src/abstract_tree/value_node.rs
+++ b/src/abstract_tree/value_node.rs
@@ -4,8 +4,8 @@ use serde::{Deserialize, Serialize};
 use tree_sitter::Node;
 
 use crate::{
-    value::BuiltInValue, AbstractTree, Block, Error, Expression, Function, Identifier, List, Map,
-    Result, Statement, Type, TypeDefinition, Value,
+    AbstractTree, BuiltInValue, Error, Expression, Function, Identifier, List, Map, Result,
+    Statement, Type, TypeDefinition, Value,
 };
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, PartialOrd, Ord)]
@@ -29,58 +29,7 @@ impl AbstractTree for ValueNode {
         let value_node = match child.kind() {
             "boolean" => ValueNode::Boolean(source[child.byte_range()].to_string()),
             "float" => ValueNode::Float(source[child.byte_range()].to_string()),
-            "function" => {
-                let child_count = child.child_count();
-                let mut parameters = Vec::new();
-                let mut parameter_types = Vec::new();
-
-                for index in 1..child_count - 3 {
-                    let child = child.child(index).unwrap();
-
-                    if child.kind() == "identifier" {
-                        let identifier = Identifier::from_syntax_node(source, child, context)?;
-
-                        parameters.push(identifier);
-                    }
-
-                    if child.kind() == "type_definition" {
-                        let type_definition =
-                            TypeDefinition::from_syntax_node(source, child, context)?;
-
-                        parameter_types.push(type_definition.take_inner());
-                    }
-                }
-
-                let function_context = Map::clone_from(context)?;
-
-                for (parameter_name, parameter_type) in
-                    parameters.iter().zip(parameter_types.iter())
-                {
-                    function_context.set(
-                        parameter_name.inner().clone(),
-                        Value::none(),
-                        Some(parameter_type.clone()),
-                    )?;
-                }
-
-                let return_type_node = child.child(child_count - 2).unwrap();
-                let return_type =
-                    TypeDefinition::from_syntax_node(source, return_type_node, context)?;
-
-                let body_node = child.child(child_count - 1).unwrap();
-                let body = Block::from_syntax_node(source, body_node, &function_context)?;
-
-                return_type
-                    .inner()
-                    .check(&body.expected_type(&function_context)?)?;
-
-                let r#type = Type::Function {
-                    parameter_types,
-                    return_type: Box::new(return_type.take_inner()),
-                };
-
-                ValueNode::Function(Function::new(parameters, body, Some(r#type)))
-            }
+            "function" => ValueNode::Function(Function::from_syntax_node(source, child, context)?),
             "integer" => ValueNode::Integer(source[child.byte_range()].to_string()),
             "string" => {
                 let without_quotes = child.start_byte() + 1..child.end_byte() - 1;
diff --git a/src/bin/gui/app.rs b/src/bin/gui/app.rs
index 2af1a2c..98a30f4 100644
--- a/src/bin/gui/app.rs
+++ b/src/bin/gui/app.rs
@@ -223,6 +223,5 @@ fn display_value(value: &Value, ui: &mut egui::Ui) {
                 ui.label("none");
             }
         },
-        Value::BuiltIn(_) => todo!(),
     }
 }
diff --git a/src/built_in_functions/assert.rs b/src/built_in_functions/assert.rs
deleted file mode 100644
index 6a3968e..0000000
--- a/src/built_in_functions/assert.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct Assert;
-
-impl BuiltInFunction for Assert {
-    fn name(&self) -> &'static str {
-        "assert"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        for argument in arguments {
-            if !argument.as_boolean()? {
-                return Err(Error::AssertFailed);
-            }
-        }
-
-        Ok(Value::none())
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Any],
-            return_type: Box::new(Type::None),
-        }
-    }
-}
-
-pub struct AssertEqual;
-
-impl BuiltInFunction for AssertEqual {
-    fn name(&self) -> &'static str {
-        "assert_equal"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 2, arguments.len())?;
-
-        let left = arguments.get(0).unwrap();
-        let right = arguments.get(1).unwrap();
-
-        if left == right {
-            Ok(Value::none())
-        } else {
-            Err(Error::AssertEqualFailed {
-                expected: left.clone(),
-                actual: right.clone(),
-            })
-        }
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Any, Type::Any],
-            return_type: Box::new(Type::Boolean),
-        }
-    }
-}
diff --git a/src/built_in_functions/collections.rs b/src/built_in_functions/collections.rs
deleted file mode 100644
index a70f376..0000000
--- a/src/built_in_functions/collections.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct Length;
-
-impl BuiltInFunction for Length {
-    fn name(&self) -> &'static str {
-        "length"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 1, arguments.len())?;
-
-        let length = arguments.first().unwrap().as_list()?.items().len();
-
-        Ok(Value::Integer(length as i64))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::List(Box::new(Type::Any))],
-            return_type: Box::new(Type::Integer),
-        }
-    }
-}
diff --git a/src/built_in_functions/commands.rs b/src/built_in_functions/commands.rs
deleted file mode 100644
index d0b850a..0000000
--- a/src/built_in_functions/commands.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use std::process::Command;
-
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct Raw;
-
-impl BuiltInFunction for Raw {
-    fn name(&self) -> &'static str {
-        "raw"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 2, arguments.len())?;
-
-        let program = arguments.first().unwrap().as_string()?;
-        let command_arguments = arguments.get(1).unwrap().as_list()?;
-        let mut command = Command::new(program);
-
-        for argument in command_arguments.items().iter() {
-            command.arg(argument.as_string()?);
-        }
-
-        let output = command.spawn()?.wait_with_output()?.stdout;
-
-        Ok(Value::String(String::from_utf8(output)?))
-    }
-
-    fn r#type(&self) -> crate::Type {
-        Type::Function {
-            parameter_types: vec![Type::String, Type::List(Box::new(Type::String))],
-            return_type: Box::new(Type::String),
-        }
-    }
-}
-
-pub struct Sh;
-
-impl BuiltInFunction for Sh {
-    fn name(&self) -> &'static str {
-        "sh"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        let command_text = arguments.first().unwrap().as_string()?;
-        let mut command = Command::new("sh");
-
-        command.arg("-c");
-        command.arg(command_text);
-
-        let extra_command_text = arguments.get(1).unwrap_or_default().as_option()?;
-
-        if let Some(text) = extra_command_text {
-            command.args(["--", text.as_string()?]);
-        }
-
-        let output = command.spawn()?.wait_with_output()?.stdout;
-
-        Ok(Value::String(String::from_utf8(output)?))
-    }
-
-    fn r#type(&self) -> crate::Type {
-        Type::Function {
-            parameter_types: vec![Type::String, Type::Option(Box::new(Type::String))],
-            return_type: Box::new(Type::String),
-        }
-    }
-}
diff --git a/src/built_in_functions/data_formats.rs b/src/built_in_functions/data_formats.rs
deleted file mode 100644
index fa7caf4..0000000
--- a/src/built_in_functions/data_formats.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct FromJson;
-
-impl BuiltInFunction for FromJson {
-    fn name(&self) -> &'static str {
-        "from_json"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 1, arguments.len())?;
-
-        let json_string = arguments.first().unwrap().as_string()?;
-        let value = serde_json::from_str(json_string)?;
-
-        Ok(value)
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::String],
-            return_type: Box::new(Type::Any),
-        }
-    }
-}
-
-pub struct ToJson;
-
-impl BuiltInFunction for ToJson {
-    fn name(&self) -> &'static str {
-        "to_json"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 1, arguments.len())?;
-
-        let value = arguments.first().unwrap();
-        let json_string = serde_json::to_string(&value)?;
-
-        Ok(Value::String(json_string))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Any],
-            return_type: Box::new(Type::String),
-        }
-    }
-}
diff --git a/src/built_in_functions/fs.rs b/src/built_in_functions/fs.rs
deleted file mode 100644
index 28e8fe9..0000000
--- a/src/built_in_functions/fs.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use std::{
-    fs::{read_dir, read_to_string, write, File},
-    io::Write as IoWrite,
-    path::PathBuf,
-};
-
-use crate::{BuiltInFunction, List, Map, Result, Type, Value};
-
-pub struct Read;
-
-impl BuiltInFunction for Read {
-    fn name(&self) -> &'static str {
-        "read"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        let path_string = arguments.first().unwrap_or_default().as_string()?;
-        let path = PathBuf::from(path_string);
-
-        if path.is_dir() {
-            let files = List::new();
-
-            for entry in read_dir(&path)? {
-                let entry = entry?;
-                let file_data = Map::new();
-
-                let name = entry.file_name().to_string_lossy().to_string();
-                let metadata = entry.metadata()?;
-                let created = metadata.created()?.elapsed()?.as_secs() as i64;
-                let modified = metadata.modified()?.elapsed()?.as_secs() as i64;
-
-                file_data.set("name".to_string(), Value::String(name), None)?;
-                file_data.set("created".to_string(), Value::Integer(created), None)?;
-                file_data.set("modified".to_string(), Value::Integer(modified), None)?;
-
-                files.items_mut().push(Value::Map(file_data));
-            }
-
-            return Ok(Value::List(files));
-        }
-
-        let file_content = read_to_string(path)?;
-
-        Ok(Value::String(file_content))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::String],
-            return_type: Box::new(Type::String),
-        }
-    }
-}
-
-pub struct Write;
-
-impl BuiltInFunction for Write {
-    fn name(&self) -> &'static str {
-        "write"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        let file_content = arguments.first().unwrap_or_default().as_string()?;
-        let path = arguments.get(1).unwrap_or_default().as_string()?;
-
-        write(path, file_content)?;
-
-        Ok(Value::none())
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::String],
-            return_type: Box::new(Type::None),
-        }
-    }
-}
-
-pub struct Append;
-
-impl BuiltInFunction for Append {
-    fn name(&self) -> &'static str {
-        "append"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        let file_content = arguments.get(0).unwrap_or_default().as_string()?;
-        let path = arguments.get(1).unwrap_or_default().as_string()?;
-
-        File::options()
-            .append(true)
-            .create(true)
-            .open(path)?
-            .write_all(file_content.as_bytes())?;
-
-        Ok(Value::none())
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::String, Type::String],
-            return_type: Box::new(Type::None),
-        }
-    }
-}
diff --git a/src/built_in_functions/map.rs b/src/built_in_functions/map.rs
deleted file mode 100644
index 27ed3cd..0000000
--- a/src/built_in_functions/map.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Functions related to [Map][crate::Map] values.
-
-use crate::{BuiltInFunction, List, Map, Result, Type, Value};
-
-pub struct Keys;
-
-impl BuiltInFunction for Keys {
-    fn name(&self) -> &'static str {
-        "keys"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        let map = arguments.first().unwrap_or_default().as_map()?;
-        let variables = map.variables()?;
-        let mut keys = Vec::with_capacity(variables.len());
-
-        for (key, _) in variables.iter() {
-            keys.push(Value::String(key.clone()))
-        }
-
-        Ok(Value::List(List::with_items(keys)))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Map],
-            return_type: Box::new(Type::List(Box::new(Type::String))),
-        }
-    }
-}
diff --git a/src/built_in_functions/mod.rs b/src/built_in_functions/mod.rs
index 7f67740..d7fa829 100644
--- a/src/built_in_functions/mod.rs
+++ b/src/built_in_functions/mod.rs
@@ -1,48 +1,90 @@
-/// Built-in functions that are available to all Dust programs.
-use crate::{Map, Result, Type, Value};
+use std::{
+    fmt::{self, Display, Formatter},
+    fs::read_to_string,
+};
 
-mod assert;
-mod collections;
-mod commands;
-mod data_formats;
-mod fs;
-mod network;
-mod option;
-mod output;
-mod packages;
-mod random;
-mod r#type;
+use rand::random;
+use serde::{Deserialize, Serialize};
 
-/// All built-in functions recognized by the interpreter.
-///
-/// This is the public interface to access built-in functions by iterating over
-/// the references it holds.
-pub const BUILT_IN_FUNCTIONS: [&dyn BuiltInFunction; 21] = [
-    &assert::Assert,
-    &assert::AssertEqual,
-    &collections::Length,
-    &commands::Raw,
-    &commands::Sh,
-    &data_formats::FromJson,
-    &data_formats::ToJson,
-    &fs::Read,
-    &fs::Write,
-    &fs::Append,
-    &network::Download,
-    &option::EitherOr,
-    &option::IsNone,
-    &option::IsSome,
-    &output::Output,
-    &packages::InstallPackages,
-    &random::Random,
-    &random::RandomBoolean,
-    &random::RandomFloat,
-    &random::RandomInteger,
-    &r#type::TypeFunction,
-];
+use crate::{Error, Map, Result, Type, Value};
 
-pub trait BuiltInFunction {
-    fn name(&self) -> &'static str;
-    fn run(&self, arguments: &[Value], context: &Map) -> Result<Value>;
-    fn r#type(&self) -> Type;
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+pub enum BuiltInFunction {
+    AssertEqual,
+    FsRead,
+    Output,
+    RandomBoolean,
+    Length,
+}
+
+impl BuiltInFunction {
+    pub fn name(&self) -> &'static str {
+        match self {
+            BuiltInFunction::AssertEqual => "assert_equal",
+            BuiltInFunction::FsRead => "fs_read",
+            BuiltInFunction::Output => "output",
+            BuiltInFunction::RandomBoolean => "boolean",
+            BuiltInFunction::Length => "length",
+        }
+    }
+
+    pub fn r#type(&self) -> Type {
+        match self {
+            BuiltInFunction::AssertEqual => Type::function(vec![Type::Any, Type::Any], Type::None),
+            BuiltInFunction::FsRead => Type::function(vec![Type::String], Type::String),
+            BuiltInFunction::Output => Type::function(vec![Type::Any], Type::None),
+            BuiltInFunction::RandomBoolean => Type::function(vec![], Type::Boolean),
+            BuiltInFunction::Length => {
+                Type::function(vec![Type::list_of(Type::Any)], Type::Integer)
+            }
+        }
+    }
+
+    pub fn call(&self, arguments: &[Value], _source: &str, _outer_context: &Map) -> Result<Value> {
+        match self {
+            BuiltInFunction::AssertEqual => {
+                Error::expect_argument_amount(self, 2, arguments.len())?;
+
+                let left = arguments.get(0).unwrap();
+                let right = arguments.get(1).unwrap();
+
+                Ok(Value::Boolean(left == right))
+            }
+            BuiltInFunction::FsRead => {
+                Error::expect_argument_amount(self, 1, arguments.len())?;
+
+                let path = arguments.first().unwrap().as_string()?;
+                let file_content = read_to_string(path)?;
+
+                Ok(Value::String(file_content))
+            }
+            BuiltInFunction::Output => {
+                Error::expect_argument_amount(self, 1, arguments.len())?;
+
+                let value = arguments.first().unwrap();
+
+                println!("{value}");
+
+                Ok(Value::none())
+            }
+            BuiltInFunction::RandomBoolean => {
+                Error::expect_argument_amount(self, 0, arguments.len())?;
+
+                Ok(Value::Boolean(random()))
+            }
+            BuiltInFunction::Length => {
+                Error::expect_argument_amount(self, 1, arguments.len())?;
+
+                let list_len = arguments.first().unwrap().as_list()?.items().len() as i64;
+
+                Ok(Value::Integer(list_len))
+            }
+        }
+    }
+}
+
+impl Display for BuiltInFunction {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.r#type())
+    }
 }
diff --git a/src/built_in_functions/network.rs b/src/built_in_functions/network.rs
deleted file mode 100644
index 6b50190..0000000
--- a/src/built_in_functions/network.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use reqwest::blocking::get;
-
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct Download;
-
-impl BuiltInFunction for Download {
-    fn name(&self) -> &'static str {
-        "download"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 1, arguments.len())?;
-
-        let url = arguments.first().unwrap().as_string()?;
-        let response = get(url)?;
-
-        Ok(Value::String(response.text()?))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::String],
-            return_type: Box::new(Type::String),
-        }
-    }
-}
diff --git a/src/built_in_functions/option.rs b/src/built_in_functions/option.rs
deleted file mode 100644
index ae03c0d..0000000
--- a/src/built_in_functions/option.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use crate::{BuiltInFunction, Map, Result, Type, Value};
-
-pub struct EitherOr;
-
-impl BuiltInFunction for EitherOr {
-    fn name(&self) -> &'static str {
-        "either_or"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        let option = arguments.first().unwrap_or_default().as_option()?;
-        let value = if let Some(value) = option {
-            *value.clone()
-        } else {
-            arguments.get(1).unwrap_or_default().clone()
-        };
-
-        Ok(value)
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Option(Box::new(Type::Any)), Type::Any],
-            return_type: Box::new(Type::Boolean),
-        }
-    }
-}
-
-pub struct IsNone;
-
-impl BuiltInFunction for IsNone {
-    fn name(&self) -> &'static str {
-        "is_none"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        let option = arguments.first().unwrap_or_default().as_option()?;
-
-        Ok(Value::Boolean(option.is_none()))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Option(Box::new(Type::Any))],
-            return_type: Box::new(Type::Boolean),
-        }
-    }
-}
-
-pub struct IsSome;
-
-impl BuiltInFunction for IsSome {
-    fn name(&self) -> &'static str {
-        "is_some"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        let option = arguments.first().unwrap_or_default().as_option()?;
-
-        Ok(Value::Boolean(option.is_some()))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Option(Box::new(Type::Any))],
-            return_type: Box::new(Type::Boolean),
-        }
-    }
-}
diff --git a/src/built_in_functions/output.rs b/src/built_in_functions/output.rs
deleted file mode 100644
index beffc06..0000000
--- a/src/built_in_functions/output.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct Output;
-
-impl BuiltInFunction for Output {
-    fn name(&self) -> &'static str {
-        "output"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 1, arguments.len())?;
-
-        let value = arguments.first().unwrap();
-
-        println!("{value}");
-
-        Ok(Value::default())
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Any],
-            return_type: Box::new(Type::None),
-        }
-    }
-}
diff --git a/src/built_in_functions/packages.rs b/src/built_in_functions/packages.rs
deleted file mode 100644
index 4a468ef..0000000
--- a/src/built_in_functions/packages.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-use std::process::Command;
-
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct InstallPackages;
-
-impl BuiltInFunction for InstallPackages {
-    fn name(&self) -> &'static str {
-        "install_packages"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 1, arguments.len())?;
-
-        let mut command = Command::new("sudo");
-        let argument_list = arguments.first().unwrap().as_list()?;
-
-        command.args(["dnf", "-y", "install"]);
-
-        for argument in argument_list.items().iter() {
-            command.arg(argument.as_string()?);
-        }
-
-        command.spawn()?.wait()?;
-
-        Ok(Value::none())
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::List(Box::new(Type::String))],
-            return_type: Box::new(Type::None),
-        }
-    }
-}
diff --git a/src/built_in_functions/random.rs b/src/built_in_functions/random.rs
deleted file mode 100644
index f66400b..0000000
--- a/src/built_in_functions/random.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use rand::{random, thread_rng, Rng};
-
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct Random;
-
-impl BuiltInFunction for Random {
-    fn name(&self) -> &'static str {
-        "random"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 1, arguments.len())?;
-
-        let list = arguments.first().unwrap().as_list()?;
-        let items = list.items();
-        let random_index = thread_rng().gen_range(0..items.len());
-        let random_argument = items.get(random_index).unwrap();
-
-        Ok(random_argument.clone())
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::List(Box::new(Type::Any))],
-            return_type: Box::new(Type::Any),
-        }
-    }
-}
-
-pub struct RandomInteger;
-
-impl BuiltInFunction for RandomInteger {
-    fn name(&self) -> &'static str {
-        "random_integer"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 0, arguments.len())?;
-
-        Ok(Value::Integer(random()))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: Vec::with_capacity(0),
-            return_type: Box::new(Type::Integer),
-        }
-    }
-}
-
-pub struct RandomFloat;
-
-impl BuiltInFunction for RandomFloat {
-    fn name(&self) -> &'static str {
-        "random_float"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 0, arguments.len())?;
-
-        Ok(Value::Float(random()))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: Vec::with_capacity(0),
-            return_type: Box::new(Type::Float),
-        }
-    }
-}
-
-pub struct RandomBoolean;
-
-impl BuiltInFunction for RandomBoolean {
-    fn name(&self) -> &'static str {
-        "random_boolean"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 0, arguments.len())?;
-
-        Ok(Value::Boolean(random()))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: Vec::with_capacity(0),
-            return_type: Box::new(Type::Boolean),
-        }
-    }
-}
diff --git a/src/built_in_functions/type.rs b/src/built_in_functions/type.rs
deleted file mode 100644
index ac7b34e..0000000
--- a/src/built_in_functions/type.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use crate::{BuiltInFunction, Error, Map, Result, Type, Value};
-
-pub struct TypeFunction;
-
-impl BuiltInFunction for TypeFunction {
-    fn name(&self) -> &'static str {
-        "type"
-    }
-
-    fn run(&self, arguments: &[Value], _context: &Map) -> Result<Value> {
-        Error::expect_argument_amount(self, 1, arguments.len())?;
-
-        let type_text = arguments.first().unwrap().r#type().to_string();
-
-        Ok(Value::String(type_text))
-    }
-
-    fn r#type(&self) -> Type {
-        Type::Function {
-            parameter_types: vec![Type::Any],
-            return_type: Box::new(Type::String),
-        }
-    }
-}
diff --git a/src/error.rs b/src/error.rs
index cb4220a..4df18a1 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -199,8 +199,8 @@ impl Error {
         }
     }
 
-    pub fn expect_argument_amount<F: BuiltInFunction>(
-        function: &F,
+    pub fn expect_argument_amount(
+        function: &BuiltInFunction,
         expected: usize,
         actual: usize,
     ) -> Result<()> {
diff --git a/src/lib.rs b/src/lib.rs
index 29fb246..0568d84 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,10 +5,15 @@
 //! interpreting Dust code. Most of the language's features are implemented in the [tools] module.
 pub use crate::{
     abstract_tree::*,
-    built_in_functions::{BuiltInFunction, BUILT_IN_FUNCTIONS},
+    built_in_functions::BuiltInFunction,
     error::*,
     interpret::*,
-    value::{function::Function, list::List, map::Map, Value},
+    value::{
+        function::{ContextDefinedFunction, Function},
+        list::List,
+        map::Map,
+        BuiltInValue, Value,
+    },
 };
 
 mod abstract_tree;
diff --git a/src/value/function.rs b/src/value/function.rs
index 20fc2f2..3e302e8 100644
--- a/src/value/function.rs
+++ b/src/value/function.rs
@@ -1,17 +1,127 @@
 use std::fmt::{self, Display, Formatter};
 
 use serde::{Deserialize, Serialize};
+use tree_sitter::Node;
 
-use crate::{AbstractTree, Block, Identifier, Map, Result, Type, Value};
+use crate::{
+    AbstractTree, Block, BuiltInFunction, Error, Identifier, Map, Result, Type, TypeDefinition,
+    Value,
+};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Function {
+pub enum Function {
+    BuiltIn(BuiltInFunction),
+    ContextDefined(ContextDefinedFunction),
+}
+
+impl Display for Function {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Function::BuiltIn(inner) => write!(f, "{inner}"),
+            Function::ContextDefined(inner) => write!(f, "{inner}"),
+        }
+    }
+}
+
+impl Function {
+    pub fn call(&self, arguments: &[Value], source: &str, outer_context: &Map) -> Result<Value> {
+        match self {
+            Function::BuiltIn(built_in_function) => {
+                built_in_function.call(arguments, source, outer_context)
+            }
+            Function::ContextDefined(context_defined_function) => {
+                context_defined_function.call(arguments, source, outer_context)
+            }
+        }
+    }
+
+    pub fn r#type(&self) -> Type {
+        match self {
+            Function::BuiltIn(built_in_function) => built_in_function.r#type(),
+            Function::ContextDefined(context_defined_function) => {
+                context_defined_function.r#type().clone()
+            }
+        }
+    }
+}
+
+impl AbstractTree for Function {
+    fn from_syntax_node(source: &str, node: Node, context: &Map) -> Result<Self> {
+        Error::expect_syntax_node(source, "function", node)?;
+
+        let child_count = node.child_count();
+        let mut parameters = Vec::new();
+        let mut parameter_types = Vec::new();
+
+        for index in 1..child_count - 3 {
+            let child = node.child(index).unwrap();
+
+            if child.kind() == "identifier" {
+                let identifier = Identifier::from_syntax_node(source, child, context)?;
+
+                parameters.push(identifier);
+            }
+
+            if child.kind() == "type_definition" {
+                let type_definition = TypeDefinition::from_syntax_node(source, child, context)?;
+
+                parameter_types.push(type_definition.take_inner());
+            }
+        }
+
+        let function_context = Map::clone_from(context)?;
+
+        for (parameter_name, parameter_type) in parameters.iter().zip(parameter_types.iter()) {
+            function_context.set(
+                parameter_name.inner().clone(),
+                Value::none(),
+                Some(parameter_type.clone()),
+            )?;
+        }
+
+        let return_type_node = node.child(child_count - 2).unwrap();
+        let return_type = TypeDefinition::from_syntax_node(source, return_type_node, context)?;
+
+        let body_node = node.child(child_count - 1).unwrap();
+        let body = Block::from_syntax_node(source, body_node, &function_context)?;
+
+        return_type
+            .inner()
+            .check(&body.expected_type(&function_context)?)
+            .map_err(|error| error.at_node(body_node, source))?;
+
+        let r#type = Type::Function {
+            parameter_types,
+            return_type: Box::new(return_type.take_inner()),
+        };
+
+        Ok(Self::ContextDefined(ContextDefinedFunction::new(
+            parameters,
+            body,
+            Some(r#type),
+        )))
+    }
+
+    fn run(&self, _source: &str, _context: &Map) -> Result<Value> {
+        Ok(Value::Function(self.clone()))
+    }
+
+    fn expected_type(&self, _context: &Map) -> Result<Type> {
+        match self {
+            Function::BuiltIn(built_in) => Ok(built_in.r#type()),
+            Function::ContextDefined(context_defined) => Ok(context_defined.r#type().clone()),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ContextDefinedFunction {
     parameters: Vec<Identifier>,
     body: Block,
     r#type: Type,
 }
 
-impl Function {
+impl ContextDefinedFunction {
     pub fn new(parameters: Vec<Identifier>, body: Block, r#type: Option<Type>) -> Self {
         let r#type = r#type.unwrap_or(Type::Function {
             parameter_types: vec![Type::Any; parameters.len()],
@@ -63,7 +173,7 @@ impl Function {
     }
 }
 
-impl Display for Function {
+impl Display for ContextDefinedFunction {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "(")?;
 
diff --git a/src/value/map.rs b/src/value/map.rs
index 0d67ab2..11f69d9 100644
--- a/src/value/map.rs
+++ b/src/value/map.rs
@@ -8,7 +8,7 @@ use std::{
     collections::BTreeMap,
     fmt::{self, Display, Formatter},
     marker::PhantomData,
-    sync::{Arc, RwLock, RwLockReadGuard},
+    sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard},
 };
 
 use crate::{value::Value, Result, Type};
@@ -46,6 +46,10 @@ impl Map {
         Ok(self.variables.read()?)
     }
 
+    pub fn variables_mut(&self) -> Result<RwLockWriteGuard<BTreeMap<String, (Value, Type)>>> {
+        Ok(self.variables.write()?)
+    }
+
     pub fn set(
         &self,
         key: String,
diff --git a/src/value/mod.rs b/src/value/mod.rs
index a0e3224..9cc3692 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},
-    interpret_with_context, AbstractTree, Function, List, Map, Type,
+    AbstractTree, BuiltInFunction, Function, List, Map, Type,
 };
 
 use serde::{
@@ -14,6 +14,7 @@ use tree_sitter::Node;
 use std::{
     cmp::Ordering,
     convert::TryFrom,
+    env::args,
     fmt::{self, Display, Formatter},
     marker::PhantomData,
     ops::{Add, AddAssign, Div, Mul, Rem, Sub, SubAssign},
@@ -24,36 +25,70 @@ pub mod function;
 pub mod list;
 pub mod map;
 
-static STD: OnceLock<Value> = OnceLock::new();
+static ARGS: OnceLock<Value> = OnceLock::new();
+static RANDOM: OnceLock<Value> = OnceLock::new();
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 pub enum BuiltInValue {
-    Std,
+    Args,
+    AssertEqual,
+    Length,
+    Output,
+    Random,
 }
 
 impl BuiltInValue {
     fn r#type(&self) -> Type {
         match self {
-            BuiltInValue::Std => Type::Map,
+            BuiltInValue::Args => Type::list_of(Type::String),
+            BuiltInValue::AssertEqual => BuiltInFunction::AssertEqual.r#type(),
+            BuiltInValue::Length => BuiltInFunction::Length.r#type(),
+            BuiltInValue::Output => BuiltInFunction::Output.r#type(),
+            BuiltInValue::Random => Type::Map,
         }
     }
 
     fn get(&self) -> &Value {
-        STD.get_or_init(|| {
-            let std_source = "foobar = () <str> { 'foobar' }";
-            let std_context = Map::new();
+        match self {
+            BuiltInValue::Args => ARGS.get_or_init(|| {
+                let args = args().map(|arg| Value::String(arg.to_string())).collect();
 
-            interpret_with_context(std_source, std_context.clone()).unwrap();
+                Value::List(List::with_items(args))
+            }),
+            BuiltInValue::AssertEqual => {
+                &Value::Function(Function::BuiltIn(BuiltInFunction::AssertEqual))
+            }
+            BuiltInValue::Length => &Value::Function(Function::BuiltIn(BuiltInFunction::Length)),
+            BuiltInValue::Output => &Value::Function(Function::BuiltIn(BuiltInFunction::Output)),
+            BuiltInValue::Random => RANDOM.get_or_init(|| {
+                let random_context = Map::new();
 
-            Value::Map(std_context)
-        })
+                {
+                    let mut variables = random_context.variables_mut().unwrap();
+
+                    for built_in_function in [BuiltInFunction::RandomBoolean] {
+                        let key = built_in_function.name().to_string();
+                        let value = Value::Function(Function::BuiltIn(built_in_function));
+                        let r#type = built_in_function.r#type();
+
+                        variables.insert(key, (value, r#type));
+                    }
+                }
+
+                Value::Map(random_context)
+            }),
+        }
     }
 }
 
 impl AbstractTree for BuiltInValue {
     fn from_syntax_node(_source: &str, node: Node, _context: &Map) -> Result<Self> {
         let built_in_value = match node.kind() {
-            "std" => BuiltInValue::Std,
+            "args" => BuiltInValue::Args,
+            "assert_equal" => BuiltInValue::AssertEqual,
+            "length" => BuiltInValue::Length,
+            "output" => BuiltInValue::Output,
+            "random" => BuiltInValue::Random,
             _ => todo!(),
         };
 
@@ -65,9 +100,7 @@ impl AbstractTree for BuiltInValue {
     }
 
     fn expected_type(&self, _context: &Map) -> Result<Type> {
-        match self {
-            BuiltInValue::Std => Ok(Type::Map),
-        }
+        Ok(self.r#type())
     }
 }
 
@@ -86,7 +119,6 @@ pub enum Value {
     Integer(i64),
     Boolean(bool),
     Option(Option<Box<Value>>),
-    BuiltIn(BuiltInValue),
 }
 
 impl Default for Value {
@@ -132,7 +164,6 @@ impl Value {
                     Type::None
                 }
             }
-            Value::BuiltIn(built_in_value) => built_in_value.r#type(),
         };
 
         r#type
@@ -471,8 +502,6 @@ impl PartialOrd for Value {
 impl Ord for Value {
     fn cmp(&self, other: &Self) -> Ordering {
         match (self, other) {
-            (Value::BuiltIn(left), Value::BuiltIn(right)) => left.cmp(right),
-            (Value::BuiltIn(_), _) => Ordering::Greater,
             (Value::String(left), Value::String(right)) => left.cmp(right),
             (Value::String(_), _) => Ordering::Greater,
             (Value::Float(left), Value::Float(right)) => left.total_cmp(right),
@@ -524,7 +553,6 @@ impl Serialize for Value {
             Value::Option(inner) => inner.serialize(serializer),
             Value::Map(inner) => inner.serialize(serializer),
             Value::Function(inner) => inner.serialize(serializer),
-            Value::BuiltIn(inner) => inner.serialize(serializer),
         }
     }
 }
@@ -552,7 +580,6 @@ impl Display for Value {
             }
             Value::Map(map) => write!(f, "{map}"),
             Value::Function(function) => write!(f, "{function}"),
-            Value::BuiltIn(_) => todo!(),
         }
     }
 }
diff --git a/tests/interpret.rs b/tests/interpret.rs
index 1a3fdea..42d0990 100644
--- a/tests/interpret.rs
+++ b/tests/interpret.rs
@@ -183,6 +183,11 @@ mod value {
         let result = interpret("() <int> { 1 }");
         let value = result.unwrap();
         let function = value.as_function().unwrap();
+        let function = if let Function::ContextDefined(function) = function {
+            function
+        } else {
+            panic!("Something is wrong with this test...");
+        };
 
         assert_eq!(&Vec::<Identifier>::with_capacity(0), function.parameters());
         assert_eq!(&Type::Integer, function.return_type());
@@ -190,6 +195,11 @@ mod value {
         let result = interpret("(x <bool>) <bool> { true }");
         let value = result.unwrap();
         let function = value.as_function().unwrap();
+        let function = if let Function::ContextDefined(function) = function {
+            function
+        } else {
+            panic!("Something is wrong with this test...");
+        };
 
         assert_eq!(
             &vec![Identifier::new("x".to_string())],
@@ -503,3 +513,15 @@ mod blocks {
         );
     }
 }
+
+mod std {
+    use dust_lang::*;
+
+    #[test]
+    fn load_std() {
+        assert_eq!(
+            interpret("std:read"),
+            Ok(Value::Function(Function::BuiltIn(BuiltInFunction::FsRead)))
+        );
+    }
+}
diff --git a/tree-sitter-dust/corpus/async.txt b/tree-sitter-dust/corpus/async.txt
index ff3b175..33e56c1 100644
--- a/tree-sitter-dust/corpus/async.txt
+++ b/tree-sitter-dust/corpus/async.txt
@@ -13,8 +13,8 @@ async { output ('Whaddup') }
         (expression
           (function_call
             (function_expression
-              (identifier
-                (built_in_function)))
+              (value
+                (built_in_value)))
             (expression
               (value
                 (string)))))))))
diff --git a/tree-sitter-dust/corpus/blocks.txt b/tree-sitter-dust/corpus/blocks.txt
index 3437663..970c046 100644
--- a/tree-sitter-dust/corpus/blocks.txt
+++ b/tree-sitter-dust/corpus/blocks.txt
@@ -15,8 +15,8 @@ Simple Block
         (expression
           (function_call
             (function_expression
-              (identifier
-                (built_in_function)))
+              (value
+                (built_in_value)))
             (expression
               (value
                 (integer)))))))))
diff --git a/tree-sitter-dust/corpus/for.txt b/tree-sitter-dust/corpus/for.txt
index 2dfa5ba..59e9808 100644
--- a/tree-sitter-dust/corpus/for.txt
+++ b/tree-sitter-dust/corpus/for.txt
@@ -29,8 +29,8 @@ for i in [1, 2, 3] {
           (expression
             (function_call
               (function_expression
-                (identifier
-                  (built_in_function)))
+                (value
+                  (built_in_value)))
               (expression
                 (identifier)))))))))
 
@@ -63,7 +63,7 @@ for list in list_of_lists {
                 (expression
                   (function_call
                     (function_expression
-                      (identifier
-                        (built_in_function)))
+                      (value
+                        (built_in_value)))
                     (expression
                       (identifier))))))))))))
diff --git a/tree-sitter-dust/corpus/functions.txt b/tree-sitter-dust/corpus/functions.txt
index 121384d..1530c92 100644
--- a/tree-sitter-dust/corpus/functions.txt
+++ b/tree-sitter-dust/corpus/functions.txt
@@ -129,16 +129,17 @@ Anonymous Function Call
     (expression
       (function_call
         (function_expression
-          (function
-            (identifier)
-            (type_definition
-              (type))
-            (type_definition
-              (type))
-            (block
-              (statement
-                (expression
-                  (identifier))))))
+          (value
+            (function
+              (identifier)
+              (type_definition
+                (type))
+              (type_definition
+                (type))
+              (block
+                (statement
+                  (expression
+                    (identifier)))))))
         (expression
           (value
             (string)))))))
@@ -222,13 +223,11 @@ from_json(read('file.json'))
     (expression
       (function_call
         (function_expression
-          (identifier
-            (built_in_function)))
+          (identifier))
         (expression
           (function_call
             (function_expression
-              (identifier
-                (built_in_function)))
+              (identifier))
             (expression
               (value
                 (string)))))))))
diff --git a/tree-sitter-dust/corpus/logic.txt b/tree-sitter-dust/corpus/logic.txt
index 9126f86..183dcc3 100644
--- a/tree-sitter-dust/corpus/logic.txt
+++ b/tree-sitter-dust/corpus/logic.txt
@@ -65,8 +65,8 @@ Complex Logic Sequence
                 (expression
                   (function_call
                     (function_expression
-                      (identifier
-                        (built_in_function)))
+                      (value
+                        (built_in_value)))
                     (expression
                       (identifier))))
                 (logic_operator)
@@ -79,8 +79,8 @@ Complex Logic Sequence
                 (expression
                   (function_call
                     (function_expression
-                      (identifier
-                        (built_in_function)))
+                      (value
+                        (built_in_value)))
                     (expression
                       (identifier))))
                 (logic_operator)
@@ -93,8 +93,8 @@ Complex Logic Sequence
             (expression
               (function_call
                 (function_expression
-                  (identifier
-                    (built_in_function)))
+                  (value
+                    (built_in_value)))
                 (expression
                   (identifier))))
             (logic_operator)
diff --git a/tree-sitter-dust/corpus/while.txt b/tree-sitter-dust/corpus/while.txt
index dfe0e24..af3e732 100644
--- a/tree-sitter-dust/corpus/while.txt
+++ b/tree-sitter-dust/corpus/while.txt
@@ -19,8 +19,8 @@ while true {
           (expression
             (function_call
               (function_expression
-                (identifier
-                  (built_in_function)))
+                (value
+                  (built_in_value)))
               (expression
                 (value
                   (string))))))))))
diff --git a/tree-sitter-dust/corpus/yield.txt b/tree-sitter-dust/corpus/yield.txt
index 1f02cf1..636a67e 100644
--- a/tree-sitter-dust/corpus/yield.txt
+++ b/tree-sitter-dust/corpus/yield.txt
@@ -14,8 +14,8 @@ Simple Yield
           (value
             (integer)))
         (function_expression
-          (identifier
-            (built_in_function)))))))
+          (value
+            (built_in_value)))))))
 
 ================================================================================
 Yield Chain
diff --git a/tree-sitter-dust/grammar.js b/tree-sitter-dust/grammar.js
index 4185daf..558df6e 100644
--- a/tree-sitter-dust/grammar.js
+++ b/tree-sitter-dust/grammar.js
@@ -1,7 +1,7 @@
 module.exports = grammar({
   name: 'dust',
 
-  word: $ => $._identifier_pattern,
+  word: $ => $.identifier,
 
   extras: $ => [/\s/, $._comment],
 
@@ -71,12 +71,6 @@ module.exports = grammar({
       ),
 
     identifier: $ =>
-      choice(
-        $._identifier_pattern,
-        $.built_in_function,
-      ),
-
-    _identifier_pattern: $ =>
       /[_a-zA-Z]+[_a-zA-Z0-9]*[_a-zA-Z]?/,
 
     value: $ =>
@@ -406,11 +400,10 @@ module.exports = grammar({
       prec(
         2,
         choice(
-          $.built_in_value,
-          $.function,
           $.function_call,
           $.identifier,
           $.index,
+          $.value,
           $.yield,
         ),
       ),
@@ -442,30 +435,14 @@ module.exports = grammar({
         ),
       ),
 
-    built_in_function: $ =>
+    built_in_value: $ =>
       choice(
-        'assert',
+        'args',
         'assert_equal',
-        'bash',
-        'download',
-        'either_or',
-        'fish',
-        'from_json',
-        'is_none',
-        'is_some',
+        'env',
         'length',
-        'metadata',
         'output',
-        'output_error',
         'random',
-        'random_boolean',
-        'random_float',
-        'random_integer',
-        'read',
-        'to_json',
-        'write',
       ),
-
-    built_in_value: $ => choice('std'),
   },
 });
diff --git a/tree-sitter-dust/src/grammar.json b/tree-sitter-dust/src/grammar.json
index c5e091e..1106b16 100644
--- a/tree-sitter-dust/src/grammar.json
+++ b/tree-sitter-dust/src/grammar.json
@@ -1,6 +1,6 @@
 {
   "name": "dust",
-  "word": "_identifier_pattern",
+  "word": "identifier",
   "rules": {
     "root": {
       "type": "PREC",
@@ -203,19 +203,6 @@
       ]
     },
     "identifier": {
-      "type": "CHOICE",
-      "members": [
-        {
-          "type": "SYMBOL",
-          "name": "_identifier_pattern"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "built_in_function"
-        }
-      ]
-    },
-    "_identifier_pattern": {
       "type": "PATTERN",
       "value": "[_a-zA-Z]+[_a-zA-Z0-9]*[_a-zA-Z]?"
     },
@@ -1304,14 +1291,6 @@
       "content": {
         "type": "CHOICE",
         "members": [
-          {
-            "type": "SYMBOL",
-            "name": "built_in_value"
-          },
-          {
-            "type": "SYMBOL",
-            "name": "function"
-          },
           {
             "type": "SYMBOL",
             "name": "function_call"
@@ -1324,6 +1303,10 @@
             "type": "SYMBOL",
             "name": "index"
           },
+          {
+            "type": "SYMBOL",
+            "name": "value"
+          },
           {
             "type": "SYMBOL",
             "name": "yield"
@@ -1410,12 +1393,12 @@
         ]
       }
     },
-    "built_in_function": {
+    "built_in_value": {
       "type": "CHOICE",
       "members": [
         {
           "type": "STRING",
-          "value": "assert"
+          "value": "args"
         },
         {
           "type": "STRING",
@@ -1423,84 +1406,19 @@
         },
         {
           "type": "STRING",
-          "value": "bash"
-        },
-        {
-          "type": "STRING",
-          "value": "download"
-        },
-        {
-          "type": "STRING",
-          "value": "either_or"
-        },
-        {
-          "type": "STRING",
-          "value": "fish"
-        },
-        {
-          "type": "STRING",
-          "value": "from_json"
-        },
-        {
-          "type": "STRING",
-          "value": "is_none"
-        },
-        {
-          "type": "STRING",
-          "value": "is_some"
+          "value": "env"
         },
         {
           "type": "STRING",
           "value": "length"
         },
-        {
-          "type": "STRING",
-          "value": "metadata"
-        },
         {
           "type": "STRING",
           "value": "output"
         },
-        {
-          "type": "STRING",
-          "value": "output_error"
-        },
         {
           "type": "STRING",
           "value": "random"
-        },
-        {
-          "type": "STRING",
-          "value": "random_boolean"
-        },
-        {
-          "type": "STRING",
-          "value": "random_float"
-        },
-        {
-          "type": "STRING",
-          "value": "random_integer"
-        },
-        {
-          "type": "STRING",
-          "value": "read"
-        },
-        {
-          "type": "STRING",
-          "value": "to_json"
-        },
-        {
-          "type": "STRING",
-          "value": "write"
-        }
-      ]
-    },
-    "built_in_value": {
-      "type": "CHOICE",
-      "members": [
-        {
-          "type": "STRING",
-          "value": "std"
         }
       ]
     }
diff --git a/tree-sitter-dust/src/node-types.json b/tree-sitter-dust/src/node-types.json
index 88627a0..1b77063 100644
--- a/tree-sitter-dust/src/node-types.json
+++ b/tree-sitter-dust/src/node-types.json
@@ -51,11 +51,6 @@
     "named": true,
     "fields": {}
   },
-  {
-    "type": "built_in_function",
-    "named": true,
-    "fields": {}
-  },
   {
     "type": "built_in_value",
     "named": true,
@@ -207,14 +202,6 @@
       "multiple": false,
       "required": true,
       "types": [
-        {
-          "type": "built_in_value",
-          "named": true
-        },
-        {
-          "type": "function",
-          "named": true
-        },
         {
           "type": "function_call",
           "named": true
@@ -228,22 +215,11 @@
           "named": true
         },
         {
-          "type": "yield",
+          "type": "value",
           "named": true
-        }
-      ]
-    }
-  },
-  {
-    "type": "identifier",
-    "named": true,
-    "fields": {},
-    "children": {
-      "multiple": false,
-      "required": false,
-      "types": [
+        },
         {
-          "type": "built_in_function",
+          "type": "yield",
           "named": true
         }
       ]
@@ -777,7 +753,7 @@
     "named": false
   },
   {
-    "type": "assert",
+    "type": "args",
     "named": false
   },
   {
@@ -792,22 +768,10 @@
     "type": "async for",
     "named": false
   },
-  {
-    "type": "bash",
-    "named": false
-  },
   {
     "type": "bool",
     "named": false
   },
-  {
-    "type": "download",
-    "named": false
-  },
-  {
-    "type": "either_or",
-    "named": false
-  },
   {
     "type": "else",
     "named": false
@@ -817,11 +781,11 @@
     "named": false
   },
   {
-    "type": "false",
+    "type": "env",
     "named": false
   },
   {
-    "type": "fish",
+    "type": "false",
     "named": false
   },
   {
@@ -837,8 +801,8 @@
     "named": false
   },
   {
-    "type": "from_json",
-    "named": false
+    "type": "identifier",
+    "named": true
   },
   {
     "type": "if",
@@ -856,14 +820,6 @@
     "type": "integer",
     "named": true
   },
-  {
-    "type": "is_none",
-    "named": false
-  },
-  {
-    "type": "is_some",
-    "named": false
-  },
   {
     "type": "length",
     "named": false
@@ -876,10 +832,6 @@
     "type": "match",
     "named": false
   },
-  {
-    "type": "metadata",
-    "named": false
-  },
   {
     "type": "none",
     "named": false
@@ -896,30 +848,10 @@
     "type": "output",
     "named": false
   },
-  {
-    "type": "output_error",
-    "named": false
-  },
   {
     "type": "random",
     "named": false
   },
-  {
-    "type": "random_boolean",
-    "named": false
-  },
-  {
-    "type": "random_float",
-    "named": false
-  },
-  {
-    "type": "random_integer",
-    "named": false
-  },
-  {
-    "type": "read",
-    "named": false
-  },
   {
     "type": "return",
     "named": false
@@ -928,10 +860,6 @@
     "type": "some",
     "named": false
   },
-  {
-    "type": "std",
-    "named": false
-  },
   {
     "type": "str",
     "named": false
@@ -940,10 +868,6 @@
     "type": "string",
     "named": true
   },
-  {
-    "type": "to_json",
-    "named": false
-  },
   {
     "type": "true",
     "named": false
@@ -952,10 +876,6 @@
     "type": "while",
     "named": false
   },
-  {
-    "type": "write",
-    "named": false
-  },
   {
     "type": "{",
     "named": false
diff --git a/tree-sitter-dust/src/parser.c b/tree-sitter-dust/src/parser.c
index 0602cdf..dd4f76f 100644
--- a/tree-sitter-dust/src/parser.c
+++ b/tree-sitter-dust/src/parser.c
@@ -6,18 +6,18 @@
 #endif
 
 #define LANGUAGE_VERSION 14
-#define STATE_COUNT 462
-#define LARGE_STATE_COUNT 84
-#define SYMBOL_COUNT 122
+#define STATE_COUNT 446
+#define LARGE_STATE_COUNT 27
+#define SYMBOL_COUNT 105
 #define ALIAS_COUNT 0
-#define TOKEN_COUNT 77
+#define TOKEN_COUNT 62
 #define EXTERNAL_TOKEN_COUNT 0
 #define FIELD_COUNT 0
 #define MAX_ALIAS_SEQUENCE_LENGTH 6
 #define PRODUCTION_ID_COUNT 1
 
 enum {
-  sym__identifier_pattern = 1,
+  sym_identifier = 1,
   sym__comment = 2,
   anon_sym_SEMI = 3,
   anon_sym_LPAREN = 4,
@@ -72,77 +72,60 @@ enum {
   anon_sym_str = 53,
   anon_sym_DASH_GT = 54,
   anon_sym_option = 55,
-  anon_sym_assert = 56,
+  anon_sym_args = 56,
   anon_sym_assert_equal = 57,
-  anon_sym_bash = 58,
-  anon_sym_download = 59,
-  anon_sym_either_or = 60,
-  anon_sym_fish = 61,
-  anon_sym_from_json = 62,
-  anon_sym_is_none = 63,
-  anon_sym_is_some = 64,
-  anon_sym_length = 65,
-  anon_sym_metadata = 66,
-  anon_sym_output = 67,
-  anon_sym_output_error = 68,
-  anon_sym_random = 69,
-  anon_sym_random_boolean = 70,
-  anon_sym_random_float = 71,
-  anon_sym_random_integer = 72,
-  anon_sym_read = 73,
-  anon_sym_to_json = 74,
-  anon_sym_write = 75,
-  anon_sym_std = 76,
-  sym_root = 77,
-  sym_statement = 78,
-  sym_expression = 79,
-  sym__expression_kind = 80,
-  aux_sym__expression_list = 81,
-  sym_block = 82,
-  sym_identifier = 83,
-  sym_value = 84,
-  sym_boolean = 85,
-  sym_list = 86,
-  sym_map = 87,
-  sym_option = 88,
-  sym_index = 89,
-  sym_index_expression = 90,
-  sym_math = 91,
-  sym_math_operator = 92,
-  sym_logic = 93,
-  sym_logic_operator = 94,
-  sym_assignment = 95,
-  sym_index_assignment = 96,
-  sym_assignment_operator = 97,
-  sym_if_else = 98,
-  sym_if = 99,
-  sym_else_if = 100,
-  sym_else = 101,
-  sym_match = 102,
-  sym_while = 103,
-  sym_for = 104,
-  sym_return = 105,
-  sym_type_definition = 106,
-  sym_type = 107,
-  sym_function = 108,
-  sym_function_expression = 109,
-  sym__function_expression_kind = 110,
-  sym_function_call = 111,
-  sym_yield = 112,
-  sym_built_in_function = 113,
-  sym_built_in_value = 114,
-  aux_sym_root_repeat1 = 115,
-  aux_sym_list_repeat1 = 116,
-  aux_sym_map_repeat1 = 117,
-  aux_sym_if_else_repeat1 = 118,
-  aux_sym_match_repeat1 = 119,
-  aux_sym_type_repeat1 = 120,
-  aux_sym_function_repeat1 = 121,
+  anon_sym_env = 58,
+  anon_sym_length = 59,
+  anon_sym_output = 60,
+  anon_sym_random = 61,
+  sym_root = 62,
+  sym_statement = 63,
+  sym_expression = 64,
+  sym__expression_kind = 65,
+  aux_sym__expression_list = 66,
+  sym_block = 67,
+  sym_value = 68,
+  sym_boolean = 69,
+  sym_list = 70,
+  sym_map = 71,
+  sym_option = 72,
+  sym_index = 73,
+  sym_index_expression = 74,
+  sym_math = 75,
+  sym_math_operator = 76,
+  sym_logic = 77,
+  sym_logic_operator = 78,
+  sym_assignment = 79,
+  sym_index_assignment = 80,
+  sym_assignment_operator = 81,
+  sym_if_else = 82,
+  sym_if = 83,
+  sym_else_if = 84,
+  sym_else = 85,
+  sym_match = 86,
+  sym_while = 87,
+  sym_for = 88,
+  sym_return = 89,
+  sym_type_definition = 90,
+  sym_type = 91,
+  sym_function = 92,
+  sym_function_expression = 93,
+  sym__function_expression_kind = 94,
+  sym_function_call = 95,
+  sym_yield = 96,
+  sym_built_in_value = 97,
+  aux_sym_root_repeat1 = 98,
+  aux_sym_list_repeat1 = 99,
+  aux_sym_map_repeat1 = 100,
+  aux_sym_if_else_repeat1 = 101,
+  aux_sym_match_repeat1 = 102,
+  aux_sym_type_repeat1 = 103,
+  aux_sym_function_repeat1 = 104,
 };
 
 static const char * const ts_symbol_names[] = {
   [ts_builtin_sym_end] = "end",
-  [sym__identifier_pattern] = "_identifier_pattern",
+  [sym_identifier] = "identifier",
   [sym__comment] = "_comment",
   [anon_sym_SEMI] = ";",
   [anon_sym_LPAREN] = "(",
@@ -197,34 +180,18 @@ static const char * const ts_symbol_names[] = {
   [anon_sym_str] = "str",
   [anon_sym_DASH_GT] = "->",
   [anon_sym_option] = "option",
-  [anon_sym_assert] = "assert",
+  [anon_sym_args] = "args",
   [anon_sym_assert_equal] = "assert_equal",
-  [anon_sym_bash] = "bash",
-  [anon_sym_download] = "download",
-  [anon_sym_either_or] = "either_or",
-  [anon_sym_fish] = "fish",
-  [anon_sym_from_json] = "from_json",
-  [anon_sym_is_none] = "is_none",
-  [anon_sym_is_some] = "is_some",
+  [anon_sym_env] = "env",
   [anon_sym_length] = "length",
-  [anon_sym_metadata] = "metadata",
   [anon_sym_output] = "output",
-  [anon_sym_output_error] = "output_error",
   [anon_sym_random] = "random",
-  [anon_sym_random_boolean] = "random_boolean",
-  [anon_sym_random_float] = "random_float",
-  [anon_sym_random_integer] = "random_integer",
-  [anon_sym_read] = "read",
-  [anon_sym_to_json] = "to_json",
-  [anon_sym_write] = "write",
-  [anon_sym_std] = "std",
   [sym_root] = "root",
   [sym_statement] = "statement",
   [sym_expression] = "expression",
   [sym__expression_kind] = "_expression_kind",
   [aux_sym__expression_list] = "_expression_list",
   [sym_block] = "block",
-  [sym_identifier] = "identifier",
   [sym_value] = "value",
   [sym_boolean] = "boolean",
   [sym_list] = "list",
@@ -254,7 +221,6 @@ static const char * const ts_symbol_names[] = {
   [sym__function_expression_kind] = "_function_expression_kind",
   [sym_function_call] = "function_call",
   [sym_yield] = "yield",
-  [sym_built_in_function] = "built_in_function",
   [sym_built_in_value] = "built_in_value",
   [aux_sym_root_repeat1] = "root_repeat1",
   [aux_sym_list_repeat1] = "list_repeat1",
@@ -267,7 +233,7 @@ static const char * const ts_symbol_names[] = {
 
 static const TSSymbol ts_symbol_map[] = {
   [ts_builtin_sym_end] = ts_builtin_sym_end,
-  [sym__identifier_pattern] = sym__identifier_pattern,
+  [sym_identifier] = sym_identifier,
   [sym__comment] = sym__comment,
   [anon_sym_SEMI] = anon_sym_SEMI,
   [anon_sym_LPAREN] = anon_sym_LPAREN,
@@ -322,34 +288,18 @@ static const TSSymbol ts_symbol_map[] = {
   [anon_sym_str] = anon_sym_str,
   [anon_sym_DASH_GT] = anon_sym_DASH_GT,
   [anon_sym_option] = anon_sym_option,
-  [anon_sym_assert] = anon_sym_assert,
+  [anon_sym_args] = anon_sym_args,
   [anon_sym_assert_equal] = anon_sym_assert_equal,
-  [anon_sym_bash] = anon_sym_bash,
-  [anon_sym_download] = anon_sym_download,
-  [anon_sym_either_or] = anon_sym_either_or,
-  [anon_sym_fish] = anon_sym_fish,
-  [anon_sym_from_json] = anon_sym_from_json,
-  [anon_sym_is_none] = anon_sym_is_none,
-  [anon_sym_is_some] = anon_sym_is_some,
+  [anon_sym_env] = anon_sym_env,
   [anon_sym_length] = anon_sym_length,
-  [anon_sym_metadata] = anon_sym_metadata,
   [anon_sym_output] = anon_sym_output,
-  [anon_sym_output_error] = anon_sym_output_error,
   [anon_sym_random] = anon_sym_random,
-  [anon_sym_random_boolean] = anon_sym_random_boolean,
-  [anon_sym_random_float] = anon_sym_random_float,
-  [anon_sym_random_integer] = anon_sym_random_integer,
-  [anon_sym_read] = anon_sym_read,
-  [anon_sym_to_json] = anon_sym_to_json,
-  [anon_sym_write] = anon_sym_write,
-  [anon_sym_std] = anon_sym_std,
   [sym_root] = sym_root,
   [sym_statement] = sym_statement,
   [sym_expression] = sym_expression,
   [sym__expression_kind] = sym__expression_kind,
   [aux_sym__expression_list] = aux_sym__expression_list,
   [sym_block] = sym_block,
-  [sym_identifier] = sym_identifier,
   [sym_value] = sym_value,
   [sym_boolean] = sym_boolean,
   [sym_list] = sym_list,
@@ -379,7 +329,6 @@ static const TSSymbol ts_symbol_map[] = {
   [sym__function_expression_kind] = sym__function_expression_kind,
   [sym_function_call] = sym_function_call,
   [sym_yield] = sym_yield,
-  [sym_built_in_function] = sym_built_in_function,
   [sym_built_in_value] = sym_built_in_value,
   [aux_sym_root_repeat1] = aux_sym_root_repeat1,
   [aux_sym_list_repeat1] = aux_sym_list_repeat1,
@@ -395,8 +344,8 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = false,
     .named = true,
   },
-  [sym__identifier_pattern] = {
-    .visible = false,
+  [sym_identifier] = {
+    .visible = true,
     .named = true,
   },
   [sym__comment] = {
@@ -615,7 +564,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = false,
   },
-  [anon_sym_assert] = {
+  [anon_sym_args] = {
     .visible = true,
     .named = false,
   },
@@ -623,31 +572,7 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = false,
   },
-  [anon_sym_bash] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_download] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_either_or] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_fish] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_from_json] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_is_none] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_is_some] = {
+  [anon_sym_env] = {
     .visible = true,
     .named = false,
   },
@@ -655,50 +580,14 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = false,
   },
-  [anon_sym_metadata] = {
-    .visible = true,
-    .named = false,
-  },
   [anon_sym_output] = {
     .visible = true,
     .named = false,
   },
-  [anon_sym_output_error] = {
-    .visible = true,
-    .named = false,
-  },
   [anon_sym_random] = {
     .visible = true,
     .named = false,
   },
-  [anon_sym_random_boolean] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_random_float] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_random_integer] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_read] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_to_json] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_write] = {
-    .visible = true,
-    .named = false,
-  },
-  [anon_sym_std] = {
-    .visible = true,
-    .named = false,
-  },
   [sym_root] = {
     .visible = true,
     .named = true,
@@ -723,10 +612,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = true,
   },
-  [sym_identifier] = {
-    .visible = true,
-    .named = true,
-  },
   [sym_value] = {
     .visible = true,
     .named = true,
@@ -843,10 +728,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = {
     .visible = true,
     .named = true,
   },
-  [sym_built_in_function] = {
-    .visible = true,
-    .named = true,
-  },
   [sym_built_in_value] = {
     .visible = true,
     .named = true,
@@ -893,55 +774,55 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = {
   [0] = 0,
   [1] = 1,
   [2] = 2,
-  [3] = 3,
-  [4] = 3,
-  [5] = 3,
+  [3] = 2,
+  [4] = 2,
+  [5] = 5,
   [6] = 6,
   [7] = 7,
   [8] = 8,
   [9] = 9,
-  [10] = 7,
+  [10] = 6,
   [11] = 8,
-  [12] = 6,
-  [13] = 7,
+  [12] = 7,
+  [13] = 8,
   [14] = 7,
   [15] = 6,
   [16] = 9,
-  [17] = 6,
-  [18] = 8,
+  [17] = 7,
+  [18] = 9,
   [19] = 8,
-  [20] = 7,
+  [20] = 8,
   [21] = 9,
-  [22] = 6,
-  [23] = 8,
-  [24] = 24,
-  [25] = 9,
-  [26] = 9,
+  [22] = 7,
+  [23] = 6,
+  [24] = 9,
+  [25] = 6,
+  [26] = 26,
   [27] = 27,
   [28] = 28,
   [29] = 29,
-  [30] = 30,
-  [31] = 30,
+  [30] = 28,
+  [31] = 27,
   [32] = 28,
   [33] = 33,
   [34] = 34,
   [35] = 35,
-  [36] = 33,
-  [37] = 34,
-  [38] = 28,
-  [39] = 30,
-  [40] = 40,
-  [41] = 34,
-  [42] = 42,
-  [43] = 33,
+  [36] = 35,
+  [37] = 29,
+  [38] = 38,
+  [39] = 39,
+  [40] = 35,
+  [41] = 29,
+  [42] = 27,
+  [43] = 43,
   [44] = 44,
   [45] = 45,
   [46] = 46,
-  [47] = 46,
+  [47] = 45,
   [48] = 48,
-  [49] = 44,
-  [50] = 50,
-  [51] = 45,
+  [49] = 46,
+  [50] = 44,
+  [51] = 51,
   [52] = 52,
   [53] = 53,
   [54] = 54,
@@ -961,7 +842,7 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = {
   [68] = 68,
   [69] = 69,
   [70] = 70,
-  [71] = 71,
+  [71] = 52,
   [72] = 72,
   [73] = 73,
   [74] = 74,
@@ -970,388 +851,372 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = {
   [77] = 77,
   [78] = 78,
   [79] = 79,
-  [80] = 80,
-  [81] = 73,
+  [80] = 45,
+  [81] = 46,
   [82] = 82,
-  [83] = 83,
-  [84] = 45,
-  [85] = 44,
+  [83] = 82,
+  [84] = 44,
+  [85] = 45,
   [86] = 46,
-  [87] = 87,
-  [88] = 45,
-  [89] = 87,
+  [87] = 45,
+  [88] = 46,
+  [89] = 75,
   [90] = 44,
-  [91] = 72,
-  [92] = 68,
-  [93] = 45,
-  [94] = 44,
-  [95] = 46,
-  [96] = 82,
-  [97] = 67,
-  [98] = 71,
-  [99] = 66,
-  [100] = 53,
+  [91] = 51,
+  [92] = 52,
+  [93] = 74,
+  [94] = 54,
+  [95] = 62,
+  [96] = 60,
+  [97] = 61,
+  [98] = 63,
+  [99] = 52,
+  [100] = 72,
   [101] = 70,
-  [102] = 48,
-  [103] = 79,
-  [104] = 62,
-  [105] = 73,
-  [106] = 57,
-  [107] = 58,
-  [108] = 59,
-  [109] = 60,
-  [110] = 61,
-  [111] = 69,
-  [112] = 73,
-  [113] = 50,
-  [114] = 72,
-  [115] = 74,
-  [116] = 55,
-  [117] = 76,
-  [118] = 75,
-  [119] = 83,
-  [120] = 64,
-  [121] = 80,
-  [122] = 54,
-  [123] = 68,
-  [124] = 78,
-  [125] = 63,
-  [126] = 77,
-  [127] = 52,
+  [102] = 69,
+  [103] = 58,
+  [104] = 59,
+  [105] = 79,
+  [106] = 66,
+  [107] = 57,
+  [108] = 56,
+  [109] = 73,
+  [110] = 67,
+  [111] = 53,
+  [112] = 55,
+  [113] = 64,
+  [114] = 75,
+  [115] = 77,
+  [116] = 68,
+  [117] = 78,
+  [118] = 48,
+  [119] = 65,
+  [120] = 45,
+  [121] = 46,
+  [122] = 122,
+  [123] = 122,
+  [124] = 124,
+  [125] = 75,
+  [126] = 126,
+  [127] = 127,
   [128] = 128,
-  [129] = 56,
-  [130] = 128,
+  [129] = 128,
+  [130] = 82,
   [131] = 131,
-  [132] = 132,
+  [132] = 82,
   [133] = 133,
-  [134] = 134,
-  [135] = 135,
+  [134] = 133,
+  [135] = 133,
   [136] = 133,
-  [137] = 44,
-  [138] = 45,
-  [139] = 132,
+  [137] = 131,
+  [138] = 138,
+  [139] = 139,
   [140] = 140,
-  [141] = 141,
-  [142] = 142,
-  [143] = 143,
-  [144] = 141,
+  [141] = 140,
+  [142] = 133,
+  [143] = 139,
+  [144] = 140,
   [145] = 145,
-  [146] = 132,
-  [147] = 135,
-  [148] = 141,
-  [149] = 140,
-  [150] = 133,
-  [151] = 134,
-  [152] = 143,
-  [153] = 143,
-  [154] = 132,
-  [155] = 140,
-  [156] = 132,
-  [157] = 132,
-  [158] = 135,
+  [146] = 127,
+  [147] = 127,
+  [148] = 128,
+  [149] = 133,
+  [150] = 145,
+  [151] = 145,
+  [152] = 152,
+  [153] = 126,
+  [154] = 126,
+  [155] = 139,
+  [156] = 156,
+  [157] = 157,
+  [158] = 158,
   [159] = 159,
-  [160] = 134,
-  [161] = 145,
-  [162] = 68,
-  [163] = 72,
-  [164] = 164,
-  [165] = 87,
+  [160] = 160,
+  [161] = 159,
+  [162] = 162,
+  [163] = 163,
+  [164] = 163,
+  [165] = 159,
   [166] = 166,
-  [167] = 167,
-  [168] = 87,
-  [169] = 166,
-  [170] = 167,
-  [171] = 166,
-  [172] = 167,
+  [167] = 160,
+  [168] = 168,
+  [169] = 169,
+  [170] = 169,
+  [171] = 159,
+  [172] = 172,
   [173] = 166,
-  [174] = 166,
-  [175] = 175,
-  [176] = 176,
-  [177] = 164,
-  [178] = 178,
-  [179] = 175,
-  [180] = 164,
-  [181] = 166,
-  [182] = 167,
-  [183] = 183,
-  [184] = 164,
-  [185] = 183,
-  [186] = 166,
-  [187] = 178,
-  [188] = 164,
-  [189] = 164,
-  [190] = 167,
+  [174] = 158,
+  [175] = 158,
+  [176] = 172,
+  [177] = 162,
+  [178] = 169,
+  [179] = 168,
+  [180] = 159,
+  [181] = 158,
+  [182] = 166,
+  [183] = 159,
+  [184] = 158,
+  [185] = 169,
+  [186] = 158,
+  [187] = 166,
+  [188] = 166,
+  [189] = 166,
+  [190] = 158,
   [191] = 166,
-  [192] = 164,
-  [193] = 176,
-  [194] = 164,
-  [195] = 167,
-  [196] = 166,
-  [197] = 178,
-  [198] = 198,
-  [199] = 167,
-  [200] = 166,
-  [201] = 178,
-  [202] = 167,
-  [203] = 203,
+  [192] = 158,
+  [193] = 166,
+  [194] = 194,
+  [195] = 159,
+  [196] = 194,
+  [197] = 158,
+  [198] = 194,
+  [199] = 158,
+  [200] = 168,
+  [201] = 166,
+  [202] = 158,
+  [203] = 159,
   [204] = 166,
-  [205] = 167,
-  [206] = 198,
-  [207] = 203,
-  [208] = 208,
-  [209] = 208,
+  [205] = 159,
+  [206] = 159,
+  [207] = 158,
+  [208] = 166,
+  [209] = 163,
   [210] = 166,
-  [211] = 167,
-  [212] = 175,
-  [213] = 176,
-  [214] = 164,
-  [215] = 164,
-  [216] = 167,
-  [217] = 183,
-  [218] = 164,
-  [219] = 167,
+  [211] = 159,
+  [212] = 212,
+  [213] = 213,
+  [214] = 214,
+  [215] = 78,
+  [216] = 45,
+  [217] = 56,
+  [218] = 44,
+  [219] = 77,
   [220] = 220,
   [221] = 221,
   [222] = 46,
-  [223] = 44,
-  [224] = 45,
-  [225] = 71,
-  [226] = 64,
-  [227] = 63,
+  [223] = 61,
+  [224] = 72,
+  [225] = 45,
+  [226] = 67,
+  [227] = 46,
   [228] = 62,
-  [229] = 76,
-  [230] = 72,
-  [231] = 55,
-  [232] = 61,
-  [233] = 74,
-  [234] = 77,
-  [235] = 79,
-  [236] = 78,
-  [237] = 80,
-  [238] = 69,
-  [239] = 67,
-  [240] = 45,
-  [241] = 60,
-  [242] = 68,
-  [243] = 70,
-  [244] = 53,
-  [245] = 50,
-  [246] = 59,
-  [247] = 58,
+  [229] = 52,
+  [230] = 53,
+  [231] = 66,
+  [232] = 57,
+  [233] = 55,
+  [234] = 54,
+  [235] = 60,
+  [236] = 64,
+  [237] = 75,
+  [238] = 77,
+  [239] = 59,
+  [240] = 63,
+  [241] = 58,
+  [242] = 70,
+  [243] = 79,
+  [244] = 69,
+  [245] = 56,
+  [246] = 44,
+  [247] = 51,
   [248] = 73,
-  [249] = 54,
-  [250] = 46,
-  [251] = 83,
-  [252] = 57,
-  [253] = 44,
-  [254] = 66,
-  [255] = 75,
-  [256] = 82,
-  [257] = 48,
+  [249] = 78,
+  [250] = 74,
+  [251] = 68,
+  [252] = 252,
+  [253] = 253,
+  [254] = 254,
+  [255] = 255,
+  [256] = 256,
+  [257] = 52,
   [258] = 258,
-  [259] = 73,
+  [259] = 259,
   [260] = 260,
   [261] = 261,
-  [262] = 52,
+  [262] = 262,
   [263] = 263,
-  [264] = 72,
-  [265] = 66,
-  [266] = 68,
-  [267] = 82,
-  [268] = 268,
-  [269] = 53,
-  [270] = 56,
-  [271] = 44,
-  [272] = 272,
-  [273] = 45,
-  [274] = 272,
-  [275] = 272,
-  [276] = 272,
-  [277] = 272,
-  [278] = 272,
-  [279] = 272,
-  [280] = 280,
-  [281] = 281,
-  [282] = 282,
-  [283] = 283,
-  [284] = 284,
-  [285] = 285,
-  [286] = 286,
-  [287] = 287,
-  [288] = 288,
-  [289] = 289,
-  [290] = 284,
-  [291] = 291,
-  [292] = 292,
-  [293] = 258,
-  [294] = 260,
-  [295] = 261,
-  [296] = 87,
-  [297] = 87,
-  [298] = 298,
-  [299] = 268,
-  [300] = 263,
-  [301] = 53,
-  [302] = 66,
+  [264] = 264,
+  [265] = 261,
+  [266] = 266,
+  [267] = 212,
+  [268] = 266,
+  [269] = 266,
+  [270] = 213,
+  [271] = 266,
+  [272] = 266,
+  [273] = 266,
+  [274] = 266,
+  [275] = 214,
+  [276] = 48,
+  [277] = 65,
+  [278] = 75,
+  [279] = 279,
+  [280] = 77,
+  [281] = 78,
+  [282] = 56,
+  [283] = 220,
+  [284] = 45,
+  [285] = 221,
+  [286] = 46,
+  [287] = 253,
+  [288] = 256,
+  [289] = 261,
+  [290] = 264,
+  [291] = 254,
+  [292] = 261,
+  [293] = 260,
+  [294] = 252,
+  [295] = 259,
+  [296] = 255,
+  [297] = 263,
+  [298] = 262,
+  [299] = 258,
+  [300] = 46,
+  [301] = 45,
+  [302] = 302,
   [303] = 82,
-  [304] = 287,
-  [305] = 291,
-  [306] = 284,
-  [307] = 282,
-  [308] = 292,
-  [309] = 284,
-  [310] = 286,
-  [311] = 289,
-  [312] = 280,
-  [313] = 281,
-  [314] = 288,
-  [315] = 285,
-  [316] = 283,
-  [317] = 317,
-  [318] = 318,
-  [319] = 319,
+  [304] = 82,
+  [305] = 44,
+  [306] = 45,
+  [307] = 307,
+  [308] = 308,
+  [309] = 309,
+  [310] = 46,
+  [311] = 311,
+  [312] = 312,
+  [313] = 44,
+  [314] = 309,
+  [315] = 312,
+  [316] = 308,
+  [317] = 307,
+  [318] = 312,
+  [319] = 309,
   [320] = 320,
   [321] = 321,
-  [322] = 322,
-  [323] = 258,
-  [324] = 260,
-  [325] = 325,
+  [322] = 75,
+  [323] = 323,
+  [324] = 52,
+  [325] = 58,
   [326] = 326,
-  [327] = 327,
-  [328] = 327,
-  [329] = 329,
-  [330] = 329,
-  [331] = 327,
-  [332] = 329,
-  [333] = 333,
+  [327] = 45,
+  [328] = 328,
+  [329] = 328,
+  [330] = 330,
+  [331] = 326,
+  [332] = 326,
+  [333] = 46,
   [334] = 334,
-  [335] = 334,
-  [336] = 334,
-  [337] = 337,
-  [338] = 338,
-  [339] = 339,
-  [340] = 337,
-  [341] = 341,
-  [342] = 337,
+  [335] = 335,
+  [336] = 336,
+  [337] = 336,
+  [338] = 336,
+  [339] = 336,
+  [340] = 336,
+  [341] = 336,
+  [342] = 336,
   [343] = 343,
-  [344] = 344,
-  [345] = 345,
-  [346] = 44,
-  [347] = 45,
-  [348] = 46,
-  [349] = 349,
-  [350] = 350,
-  [351] = 46,
-  [352] = 352,
-  [353] = 352,
-  [354] = 349,
-  [355] = 349,
+  [344] = 336,
+  [345] = 336,
+  [346] = 343,
+  [347] = 347,
+  [348] = 348,
+  [349] = 343,
+  [350] = 336,
+  [351] = 336,
+  [352] = 336,
+  [353] = 343,
+  [354] = 354,
+  [355] = 354,
   [356] = 356,
-  [357] = 352,
-  [358] = 356,
-  [359] = 45,
-  [360] = 44,
-  [361] = 350,
+  [357] = 354,
+  [358] = 358,
+  [359] = 359,
+  [360] = 360,
+  [361] = 361,
   [362] = 362,
-  [363] = 83,
-  [364] = 68,
-  [365] = 73,
-  [366] = 72,
+  [363] = 363,
+  [364] = 364,
+  [365] = 365,
+  [366] = 366,
   [367] = 367,
-  [368] = 367,
-  [369] = 367,
+  [368] = 368,
+  [369] = 369,
   [370] = 370,
-  [371] = 45,
-  [372] = 44,
-  [373] = 370,
+  [371] = 213,
+  [372] = 212,
+  [373] = 373,
   [374] = 374,
-  [375] = 375,
-  [376] = 376,
-  [377] = 375,
-  [378] = 375,
-  [379] = 379,
-  [380] = 375,
-  [381] = 381,
-  [382] = 375,
-  [383] = 375,
-  [384] = 376,
-  [385] = 376,
-  [386] = 375,
-  [387] = 375,
-  [388] = 376,
-  [389] = 375,
-  [390] = 375,
-  [391] = 375,
-  [392] = 375,
-  [393] = 393,
+  [375] = 374,
+  [376] = 374,
+  [377] = 377,
+  [378] = 378,
+  [379] = 378,
+  [380] = 380,
+  [381] = 378,
+  [382] = 382,
+  [383] = 383,
+  [384] = 384,
+  [385] = 383,
+  [386] = 384,
+  [387] = 380,
+  [388] = 388,
+  [389] = 383,
+  [390] = 390,
+  [391] = 384,
+  [392] = 382,
+  [393] = 380,
   [394] = 394,
   [395] = 395,
   [396] = 396,
-  [397] = 393,
+  [397] = 382,
   [398] = 398,
-  [399] = 393,
+  [399] = 399,
   [400] = 400,
   [401] = 401,
-  [402] = 402,
+  [402] = 399,
   [403] = 403,
   [404] = 404,
-  [405] = 405,
+  [405] = 399,
   [406] = 406,
   [407] = 407,
-  [408] = 408,
-  [409] = 409,
-  [410] = 410,
-  [411] = 410,
-  [412] = 410,
-  [413] = 413,
-  [414] = 414,
-  [415] = 414,
+  [408] = 400,
+  [409] = 401,
+  [410] = 403,
+  [411] = 400,
+  [412] = 412,
+  [413] = 401,
+  [414] = 403,
+  [415] = 415,
   [416] = 416,
   [417] = 417,
-  [418] = 416,
+  [418] = 418,
   [419] = 419,
-  [420] = 417,
-  [421] = 417,
+  [420] = 415,
+  [421] = 421,
   [422] = 416,
-  [423] = 414,
+  [423] = 415,
   [424] = 424,
-  [425] = 424,
+  [425] = 418,
   [426] = 426,
-  [427] = 426,
-  [428] = 428,
-  [429] = 424,
-  [430] = 430,
-  [431] = 428,
-  [432] = 428,
-  [433] = 426,
+  [427] = 427,
+  [428] = 416,
+  [429] = 418,
+  [430] = 415,
+  [431] = 416,
+  [432] = 432,
+  [433] = 433,
   [434] = 434,
-  [435] = 435,
-  [436] = 436,
-  [437] = 437,
-  [438] = 435,
-  [439] = 436,
-  [440] = 436,
-  [441] = 435,
-  [442] = 442,
-  [443] = 436,
-  [444] = 435,
-  [445] = 445,
-  [446] = 442,
-  [447] = 447,
-  [448] = 435,
-  [449] = 449,
-  [450] = 450,
-  [451] = 451,
-  [452] = 436,
-  [453] = 447,
-  [454] = 435,
-  [455] = 455,
-  [456] = 456,
-  [457] = 445,
-  [458] = 442,
-  [459] = 435,
-  [460] = 445,
-  [461] = 447,
+  [435] = 415,
+  [436] = 416,
+  [437] = 427,
+  [438] = 415,
+  [439] = 427,
+  [440] = 440,
+  [441] = 433,
+  [442] = 415,
+  [443] = 432,
+  [444] = 433,
+  [445] = 432,
 };
 
 static bool ts_lex(TSLexer *lexer, TSStateId state) {
@@ -1359,509 +1224,513 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) {
   eof = lexer->eof(lexer);
   switch (state) {
     case 0:
-      if (eof) ADVANCE(25);
+      if (eof) ADVANCE(26);
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '"') ADVANCE(6);
-      if (lookahead == '#') ADVANCE(20);
-      if (lookahead == '%') ADVANCE(60);
+      if (lookahead == '#') ADVANCE(21);
+      if (lookahead == '%') ADVANCE(61);
       if (lookahead == '&') ADVANCE(8);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(29);
-      if (lookahead == ')') ADVANCE(30);
-      if (lookahead == '*') ADVANCE(58);
-      if (lookahead == '+') ADVANCE(54);
-      if (lookahead == ',') ADVANCE(31);
-      if (lookahead == '-') ADVANCE(57);
+      if (lookahead == '(') ADVANCE(30);
+      if (lookahead == ')') ADVANCE(31);
+      if (lookahead == '*') ADVANCE(59);
+      if (lookahead == '+') ADVANCE(55);
+      if (lookahead == ',') ADVANCE(32);
+      if (lookahead == '-') ADVANCE(58);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(59);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
-      if (lookahead == ':') ADVANCE(51);
-      if (lookahead == ';') ADVANCE(28);
-      if (lookahead == '<') ADVANCE(67);
-      if (lookahead == '=') ADVANCE(50);
-      if (lookahead == '>') ADVANCE(66);
-      if (lookahead == '[') ADVANCE(47);
-      if (lookahead == ']') ADVANCE(48);
-      if (lookahead == '`') ADVANCE(14);
-      if (lookahead == 'a') ADVANCE(40);
-      if (lookahead == 'e') ADVANCE(38);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(21);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '/') ADVANCE(60);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(45);
+      if (lookahead == ':') ADVANCE(52);
+      if (lookahead == ';') ADVANCE(29);
+      if (lookahead == '<') ADVANCE(68);
+      if (lookahead == '=') ADVANCE(51);
+      if (lookahead == '>') ADVANCE(67);
+      if (lookahead == '[') ADVANCE(48);
+      if (lookahead == ']') ADVANCE(49);
+      if (lookahead == '`') ADVANCE(15);
+      if (lookahead == 'a') ADVANCE(41);
+      if (lookahead == 'e') ADVANCE(39);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(22);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(0)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 1:
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '"') ADVANCE(6);
-      if (lookahead == '#') ADVANCE(20);
-      if (lookahead == '%') ADVANCE(60);
+      if (lookahead == '#') ADVANCE(21);
+      if (lookahead == '%') ADVANCE(61);
       if (lookahead == '&') ADVANCE(8);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(29);
-      if (lookahead == ')') ADVANCE(30);
-      if (lookahead == '*') ADVANCE(58);
-      if (lookahead == '+') ADVANCE(54);
-      if (lookahead == ',') ADVANCE(31);
-      if (lookahead == '-') ADVANCE(57);
+      if (lookahead == '(') ADVANCE(30);
+      if (lookahead == ')') ADVANCE(31);
+      if (lookahead == '*') ADVANCE(59);
+      if (lookahead == '+') ADVANCE(55);
+      if (lookahead == ',') ADVANCE(32);
+      if (lookahead == '-') ADVANCE(58);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(59);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
-      if (lookahead == ':') ADVANCE(51);
-      if (lookahead == ';') ADVANCE(28);
-      if (lookahead == '<') ADVANCE(67);
-      if (lookahead == '=') ADVANCE(49);
-      if (lookahead == '>') ADVANCE(66);
-      if (lookahead == '[') ADVANCE(47);
-      if (lookahead == ']') ADVANCE(48);
-      if (lookahead == '`') ADVANCE(14);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(21);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '/') ADVANCE(60);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(45);
+      if (lookahead == ':') ADVANCE(52);
+      if (lookahead == ';') ADVANCE(29);
+      if (lookahead == '<') ADVANCE(68);
+      if (lookahead == '=') ADVANCE(50);
+      if (lookahead == '>') ADVANCE(67);
+      if (lookahead == '[') ADVANCE(48);
+      if (lookahead == ']') ADVANCE(49);
+      if (lookahead == '`') ADVANCE(15);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(22);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(1)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 2:
       if (lookahead == '!') ADVANCE(11);
-      if (lookahead == '#') ADVANCE(20);
-      if (lookahead == '%') ADVANCE(60);
+      if (lookahead == '#') ADVANCE(21);
+      if (lookahead == '%') ADVANCE(61);
       if (lookahead == '&') ADVANCE(8);
-      if (lookahead == '(') ADVANCE(29);
-      if (lookahead == ')') ADVANCE(30);
-      if (lookahead == '*') ADVANCE(58);
-      if (lookahead == '+') ADVANCE(54);
-      if (lookahead == ',') ADVANCE(31);
-      if (lookahead == '-') ADVANCE(55);
+      if (lookahead == '(') ADVANCE(30);
+      if (lookahead == ')') ADVANCE(31);
+      if (lookahead == '*') ADVANCE(59);
+      if (lookahead == '+') ADVANCE(55);
+      if (lookahead == ',') ADVANCE(32);
+      if (lookahead == '-') ADVANCE(56);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(59);
-      if (lookahead == ':') ADVANCE(51);
-      if (lookahead == ';') ADVANCE(28);
-      if (lookahead == '<') ADVANCE(67);
-      if (lookahead == '=') ADVANCE(50);
-      if (lookahead == '>') ADVANCE(66);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(21);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '/') ADVANCE(60);
+      if (lookahead == ':') ADVANCE(52);
+      if (lookahead == ';') ADVANCE(29);
+      if (lookahead == '<') ADVANCE(68);
+      if (lookahead == '=') ADVANCE(51);
+      if (lookahead == '>') ADVANCE(67);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(22);
+      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(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 3:
       if (lookahead == '!') ADVANCE(11);
-      if (lookahead == '#') ADVANCE(20);
-      if (lookahead == '%') ADVANCE(60);
+      if (lookahead == '#') ADVANCE(21);
+      if (lookahead == '%') ADVANCE(61);
       if (lookahead == '&') ADVANCE(8);
-      if (lookahead == '(') ADVANCE(29);
-      if (lookahead == ')') ADVANCE(30);
-      if (lookahead == '*') ADVANCE(58);
-      if (lookahead == '+') ADVANCE(53);
-      if (lookahead == ',') ADVANCE(31);
-      if (lookahead == '-') ADVANCE(56);
-      if (lookahead == '/') ADVANCE(59);
-      if (lookahead == ':') ADVANCE(51);
-      if (lookahead == ';') ADVANCE(28);
-      if (lookahead == '<') ADVANCE(67);
+      if (lookahead == '(') ADVANCE(30);
+      if (lookahead == ')') ADVANCE(31);
+      if (lookahead == '*') ADVANCE(59);
+      if (lookahead == '+') ADVANCE(54);
+      if (lookahead == ',') ADVANCE(32);
+      if (lookahead == '-') ADVANCE(57);
+      if (lookahead == '/') ADVANCE(60);
+      if (lookahead == ':') ADVANCE(52);
+      if (lookahead == ';') ADVANCE(29);
+      if (lookahead == '<') ADVANCE(68);
       if (lookahead == '=') ADVANCE(12);
-      if (lookahead == '>') ADVANCE(66);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(21);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '>') ADVANCE(67);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(22);
+      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(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 4:
       if (lookahead == '!') ADVANCE(11);
-      if (lookahead == '#') ADVANCE(20);
-      if (lookahead == '%') ADVANCE(60);
+      if (lookahead == '#') ADVANCE(21);
+      if (lookahead == '%') ADVANCE(61);
       if (lookahead == '&') ADVANCE(8);
-      if (lookahead == '(') ADVANCE(29);
-      if (lookahead == '*') ADVANCE(58);
-      if (lookahead == '+') ADVANCE(54);
-      if (lookahead == ',') ADVANCE(31);
-      if (lookahead == '-') ADVANCE(55);
-      if (lookahead == '/') ADVANCE(59);
-      if (lookahead == ':') ADVANCE(51);
-      if (lookahead == ';') ADVANCE(28);
-      if (lookahead == '<') ADVANCE(67);
-      if (lookahead == '=') ADVANCE(49);
-      if (lookahead == '>') ADVANCE(66);
-      if (lookahead == '|') ADVANCE(21);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '(') ADVANCE(30);
+      if (lookahead == '*') ADVANCE(59);
+      if (lookahead == '+') ADVANCE(55);
+      if (lookahead == ',') ADVANCE(32);
+      if (lookahead == '-') ADVANCE(56);
+      if (lookahead == '/') ADVANCE(60);
+      if (lookahead == ':') ADVANCE(52);
+      if (lookahead == ';') ADVANCE(29);
+      if (lookahead == '<') ADVANCE(68);
+      if (lookahead == '=') ADVANCE(50);
+      if (lookahead == '>') ADVANCE(67);
+      if (lookahead == '|') ADVANCE(22);
+      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(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 5:
       if (lookahead == '"') ADVANCE(6);
-      if (lookahead == '#') ADVANCE(20);
+      if (lookahead == '#') ADVANCE(21);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(29);
-      if (lookahead == '*') ADVANCE(58);
-      if (lookahead == ',') ADVANCE(31);
-      if (lookahead == '-') ADVANCE(22);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
-      if (lookahead == ';') ADVANCE(28);
-      if (lookahead == '>') ADVANCE(65);
-      if (lookahead == '[') ADVANCE(47);
-      if (lookahead == '`') ADVANCE(14);
-      if (lookahead == 'e') ADVANCE(38);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '(') ADVANCE(30);
+      if (lookahead == '*') ADVANCE(59);
+      if (lookahead == ',') ADVANCE(32);
+      if (lookahead == '-') ADVANCE(23);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(45);
+      if (lookahead == ';') ADVANCE(29);
+      if (lookahead == '=') ADVANCE(14);
+      if (lookahead == '>') ADVANCE(66);
+      if (lookahead == '[') ADVANCE(48);
+      if (lookahead == '`') ADVANCE(15);
+      if (lookahead == 'e') ADVANCE(39);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(5)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 6:
-      if (lookahead == '"') ADVANCE(46);
+      if (lookahead == '"') ADVANCE(47);
       if (lookahead != 0) ADVANCE(6);
       END_STATE();
     case 7:
-      if (lookahead == '#') ADVANCE(20);
-      if (lookahead == '(') ADVANCE(29);
-      if (lookahead == ')') ADVANCE(30);
-      if (lookahead == ',') ADVANCE(31);
+      if (lookahead == '#') ADVANCE(21);
+      if (lookahead == '(') ADVANCE(30);
+      if (lookahead == ')') ADVANCE(31);
+      if (lookahead == ',') ADVANCE(32);
       if (lookahead == '-') ADVANCE(13);
-      if (lookahead == '>') ADVANCE(65);
-      if (lookahead == '[') ADVANCE(47);
-      if (lookahead == ']') ADVANCE(48);
+      if (lookahead == '>') ADVANCE(66);
+      if (lookahead == '[') ADVANCE(48);
+      if (lookahead == ']') ADVANCE(49);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
           lookahead == ' ') SKIP(7)
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 8:
-      if (lookahead == '&') ADVANCE(63);
+      if (lookahead == '&') ADVANCE(64);
       END_STATE();
     case 9:
-      if (lookahead == '\'') ADVANCE(46);
+      if (lookahead == '\'') ADVANCE(47);
       if (lookahead != 0) ADVANCE(9);
       END_STATE();
     case 10:
-      if (lookahead == '.') ADVANCE(52);
+      if (lookahead == '.') ADVANCE(53);
       END_STATE();
     case 11:
-      if (lookahead == '=') ADVANCE(62);
+      if (lookahead == '=') ADVANCE(63);
       END_STATE();
     case 12:
-      if (lookahead == '=') ADVANCE(61);
-      if (lookahead == '>') ADVANCE(73);
+      if (lookahead == '=') ADVANCE(62);
+      if (lookahead == '>') ADVANCE(74);
       END_STATE();
     case 13:
-      if (lookahead == '>') ADVANCE(75);
+      if (lookahead == '>') ADVANCE(76);
       END_STATE();
     case 14:
-      if (lookahead == '`') ADVANCE(46);
-      if (lookahead != 0) ADVANCE(14);
+      if (lookahead == '>') ADVANCE(74);
       END_STATE();
     case 15:
-      if (lookahead == 'f') ADVANCE(18);
+      if (lookahead == '`') ADVANCE(47);
+      if (lookahead != 0) ADVANCE(15);
       END_STATE();
     case 16:
-      if (lookahead == 'f') ADVANCE(72);
+      if (lookahead == 'f') ADVANCE(19);
       END_STATE();
     case 17:
-      if (lookahead == 'i') ADVANCE(16);
+      if (lookahead == 'f') ADVANCE(73);
       END_STATE();
     case 18:
-      if (lookahead == 'o') ADVANCE(19);
+      if (lookahead == 'i') ADVANCE(17);
       END_STATE();
     case 19:
-      if (lookahead == 'r') ADVANCE(74);
+      if (lookahead == 'o') ADVANCE(20);
       END_STATE();
     case 20:
-      if (lookahead == '|') ADVANCE(27);
-      if (lookahead == '\n' ||
-          lookahead == '#') ADVANCE(26);
-      if (lookahead != 0) ADVANCE(20);
+      if (lookahead == 'r') ADVANCE(75);
       END_STATE();
     case 21:
-      if (lookahead == '|') ADVANCE(64);
+      if (lookahead == '|') ADVANCE(28);
+      if (lookahead == '\n' ||
+          lookahead == '#') ADVANCE(27);
+      if (lookahead != 0) ADVANCE(21);
       END_STATE();
     case 22:
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
+      if (lookahead == '|') ADVANCE(65);
       END_STATE();
     case 23:
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(45);
       END_STATE();
     case 24:
-      if (eof) ADVANCE(25);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(46);
+      END_STATE();
+    case 25:
+      if (eof) ADVANCE(26);
       if (lookahead == '!') ADVANCE(11);
       if (lookahead == '"') ADVANCE(6);
-      if (lookahead == '#') ADVANCE(20);
-      if (lookahead == '%') ADVANCE(60);
+      if (lookahead == '#') ADVANCE(21);
+      if (lookahead == '%') ADVANCE(61);
       if (lookahead == '&') ADVANCE(8);
       if (lookahead == '\'') ADVANCE(9);
-      if (lookahead == '(') ADVANCE(29);
-      if (lookahead == '*') ADVANCE(58);
-      if (lookahead == '+') ADVANCE(54);
-      if (lookahead == '-') ADVANCE(57);
+      if (lookahead == '(') ADVANCE(30);
+      if (lookahead == '*') ADVANCE(59);
+      if (lookahead == '+') ADVANCE(55);
+      if (lookahead == '-') ADVANCE(58);
       if (lookahead == '.') ADVANCE(10);
-      if (lookahead == '/') ADVANCE(59);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
-      if (lookahead == ':') ADVANCE(51);
-      if (lookahead == ';') ADVANCE(28);
-      if (lookahead == '<') ADVANCE(67);
-      if (lookahead == '=') ADVANCE(49);
-      if (lookahead == '>') ADVANCE(66);
-      if (lookahead == '[') ADVANCE(47);
-      if (lookahead == '`') ADVANCE(14);
-      if (lookahead == 'a') ADVANCE(40);
-      if (lookahead == '{') ADVANCE(32);
-      if (lookahead == '|') ADVANCE(21);
-      if (lookahead == '}') ADVANCE(33);
+      if (lookahead == '/') ADVANCE(60);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(45);
+      if (lookahead == ':') ADVANCE(52);
+      if (lookahead == ';') ADVANCE(29);
+      if (lookahead == '<') ADVANCE(68);
+      if (lookahead == '=') ADVANCE(50);
+      if (lookahead == '>') ADVANCE(67);
+      if (lookahead == '[') ADVANCE(48);
+      if (lookahead == '`') ADVANCE(15);
+      if (lookahead == 'a') ADVANCE(41);
+      if (lookahead == '{') ADVANCE(33);
+      if (lookahead == '|') ADVANCE(22);
+      if (lookahead == '}') ADVANCE(34);
       if (lookahead == '\t' ||
           lookahead == '\n' ||
           lookahead == '\r' ||
-          lookahead == ' ') SKIP(24)
+          lookahead == ' ') SKIP(25)
       if (('A' <= lookahead && lookahead <= 'Z') ||
-          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(43);
-      END_STATE();
-    case 25:
-      ACCEPT_TOKEN(ts_builtin_sym_end);
+          ('_' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 26:
-      ACCEPT_TOKEN(sym__comment);
+      ACCEPT_TOKEN(ts_builtin_sym_end);
       END_STATE();
     case 27:
       ACCEPT_TOKEN(sym__comment);
-      if (lookahead == '|') ADVANCE(27);
-      if (lookahead == '\n' ||
-          lookahead == '#') ADVANCE(26);
-      if (lookahead != 0) ADVANCE(20);
       END_STATE();
     case 28:
-      ACCEPT_TOKEN(anon_sym_SEMI);
+      ACCEPT_TOKEN(sym__comment);
+      if (lookahead == '|') ADVANCE(28);
+      if (lookahead == '\n' ||
+          lookahead == '#') ADVANCE(27);
+      if (lookahead != 0) ADVANCE(21);
       END_STATE();
     case 29:
-      ACCEPT_TOKEN(anon_sym_LPAREN);
+      ACCEPT_TOKEN(anon_sym_SEMI);
       END_STATE();
     case 30:
-      ACCEPT_TOKEN(anon_sym_RPAREN);
+      ACCEPT_TOKEN(anon_sym_LPAREN);
       END_STATE();
     case 31:
-      ACCEPT_TOKEN(anon_sym_COMMA);
+      ACCEPT_TOKEN(anon_sym_RPAREN);
       END_STATE();
     case 32:
-      ACCEPT_TOKEN(anon_sym_LBRACE);
+      ACCEPT_TOKEN(anon_sym_COMMA);
       END_STATE();
     case 33:
-      ACCEPT_TOKEN(anon_sym_RBRACE);
+      ACCEPT_TOKEN(anon_sym_LBRACE);
       END_STATE();
     case 34:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == ' ') ADVANCE(17);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
-      if (('A' <= lookahead && lookahead <= 'Z') ||
-          lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+      ACCEPT_TOKEN(anon_sym_RBRACE);
       END_STATE();
     case 35:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == ' ') ADVANCE(15);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == ' ') ADVANCE(18);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 36:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == 'c') ADVANCE(35);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == ' ') ADVANCE(16);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 37:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == 'e') ADVANCE(34);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == 'c') ADVANCE(36);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 38:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == 'l') ADVANCE(41);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == 'e') ADVANCE(35);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 39:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == 'n') ADVANCE(36);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == 'l') ADVANCE(42);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 40:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == 's') ADVANCE(42);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == 'n') ADVANCE(37);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 41:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == 's') ADVANCE(37);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == 's') ADVANCE(43);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 42:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (lookahead == 'y') ADVANCE(39);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == 's') ADVANCE(38);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 43:
-      ACCEPT_TOKEN(sym__identifier_pattern);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(43);
+      ACCEPT_TOKEN(sym_identifier);
+      if (lookahead == 'y') ADVANCE(40);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
       if (('A' <= lookahead && lookahead <= 'Z') ||
           lookahead == '_' ||
-          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(43);
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 44:
-      ACCEPT_TOKEN(sym_integer);
-      if (lookahead == '.') ADVANCE(23);
+      ACCEPT_TOKEN(sym_identifier);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
+      if (('A' <= lookahead && lookahead <= 'Z') ||
+          lookahead == '_' ||
+          ('a' <= lookahead && lookahead <= 'z')) ADVANCE(44);
       END_STATE();
     case 45:
-      ACCEPT_TOKEN(sym_float);
+      ACCEPT_TOKEN(sym_integer);
+      if (lookahead == '.') ADVANCE(24);
       if (('0' <= lookahead && lookahead <= '9')) ADVANCE(45);
       END_STATE();
     case 46:
-      ACCEPT_TOKEN(sym_string);
+      ACCEPT_TOKEN(sym_float);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(46);
       END_STATE();
     case 47:
-      ACCEPT_TOKEN(anon_sym_LBRACK);
+      ACCEPT_TOKEN(sym_string);
       END_STATE();
     case 48:
-      ACCEPT_TOKEN(anon_sym_RBRACK);
+      ACCEPT_TOKEN(anon_sym_LBRACK);
       END_STATE();
     case 49:
-      ACCEPT_TOKEN(anon_sym_EQ);
-      if (lookahead == '=') ADVANCE(61);
+      ACCEPT_TOKEN(anon_sym_RBRACK);
       END_STATE();
     case 50:
       ACCEPT_TOKEN(anon_sym_EQ);
-      if (lookahead == '=') ADVANCE(61);
-      if (lookahead == '>') ADVANCE(73);
+      if (lookahead == '=') ADVANCE(62);
       END_STATE();
     case 51:
-      ACCEPT_TOKEN(anon_sym_COLON);
+      ACCEPT_TOKEN(anon_sym_EQ);
+      if (lookahead == '=') ADVANCE(62);
+      if (lookahead == '>') ADVANCE(74);
       END_STATE();
     case 52:
-      ACCEPT_TOKEN(anon_sym_DOT_DOT);
+      ACCEPT_TOKEN(anon_sym_COLON);
       END_STATE();
     case 53:
-      ACCEPT_TOKEN(anon_sym_PLUS);
+      ACCEPT_TOKEN(anon_sym_DOT_DOT);
       END_STATE();
     case 54:
       ACCEPT_TOKEN(anon_sym_PLUS);
-      if (lookahead == '=') ADVANCE(70);
       END_STATE();
     case 55:
-      ACCEPT_TOKEN(anon_sym_DASH);
+      ACCEPT_TOKEN(anon_sym_PLUS);
       if (lookahead == '=') ADVANCE(71);
-      if (lookahead == '>') ADVANCE(75);
       END_STATE();
     case 56:
       ACCEPT_TOKEN(anon_sym_DASH);
-      if (lookahead == '>') ADVANCE(75);
+      if (lookahead == '=') ADVANCE(72);
+      if (lookahead == '>') ADVANCE(76);
       END_STATE();
     case 57:
       ACCEPT_TOKEN(anon_sym_DASH);
-      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(44);
-      if (lookahead == '=') ADVANCE(71);
-      if (lookahead == '>') ADVANCE(75);
+      if (lookahead == '>') ADVANCE(76);
       END_STATE();
     case 58:
-      ACCEPT_TOKEN(anon_sym_STAR);
+      ACCEPT_TOKEN(anon_sym_DASH);
+      if (('0' <= lookahead && lookahead <= '9')) ADVANCE(45);
+      if (lookahead == '=') ADVANCE(72);
+      if (lookahead == '>') ADVANCE(76);
       END_STATE();
     case 59:
-      ACCEPT_TOKEN(anon_sym_SLASH);
+      ACCEPT_TOKEN(anon_sym_STAR);
       END_STATE();
     case 60:
-      ACCEPT_TOKEN(anon_sym_PERCENT);
+      ACCEPT_TOKEN(anon_sym_SLASH);
       END_STATE();
     case 61:
-      ACCEPT_TOKEN(anon_sym_EQ_EQ);
+      ACCEPT_TOKEN(anon_sym_PERCENT);
       END_STATE();
     case 62:
-      ACCEPT_TOKEN(anon_sym_BANG_EQ);
+      ACCEPT_TOKEN(anon_sym_EQ_EQ);
       END_STATE();
     case 63:
-      ACCEPT_TOKEN(anon_sym_AMP_AMP);
+      ACCEPT_TOKEN(anon_sym_BANG_EQ);
       END_STATE();
     case 64:
-      ACCEPT_TOKEN(anon_sym_PIPE_PIPE);
+      ACCEPT_TOKEN(anon_sym_AMP_AMP);
       END_STATE();
     case 65:
-      ACCEPT_TOKEN(anon_sym_GT);
+      ACCEPT_TOKEN(anon_sym_PIPE_PIPE);
       END_STATE();
     case 66:
       ACCEPT_TOKEN(anon_sym_GT);
-      if (lookahead == '=') ADVANCE(68);
       END_STATE();
     case 67:
-      ACCEPT_TOKEN(anon_sym_LT);
+      ACCEPT_TOKEN(anon_sym_GT);
       if (lookahead == '=') ADVANCE(69);
       END_STATE();
     case 68:
-      ACCEPT_TOKEN(anon_sym_GT_EQ);
+      ACCEPT_TOKEN(anon_sym_LT);
+      if (lookahead == '=') ADVANCE(70);
       END_STATE();
     case 69:
-      ACCEPT_TOKEN(anon_sym_LT_EQ);
+      ACCEPT_TOKEN(anon_sym_GT_EQ);
       END_STATE();
     case 70:
-      ACCEPT_TOKEN(anon_sym_PLUS_EQ);
+      ACCEPT_TOKEN(anon_sym_LT_EQ);
       END_STATE();
     case 71:
-      ACCEPT_TOKEN(anon_sym_DASH_EQ);
+      ACCEPT_TOKEN(anon_sym_PLUS_EQ);
       END_STATE();
     case 72:
-      ACCEPT_TOKEN(anon_sym_elseif);
+      ACCEPT_TOKEN(anon_sym_DASH_EQ);
       END_STATE();
     case 73:
-      ACCEPT_TOKEN(anon_sym_EQ_GT);
+      ACCEPT_TOKEN(anon_sym_elseif);
       END_STATE();
     case 74:
-      ACCEPT_TOKEN(anon_sym_asyncfor);
+      ACCEPT_TOKEN(anon_sym_EQ_GT);
       END_STATE();
     case 75:
+      ACCEPT_TOKEN(anon_sym_asyncfor);
+      END_STATE();
+    case 76:
       ACCEPT_TOKEN(anon_sym_DASH_GT);
       END_STATE();
     default:
@@ -1876,593 +1745,335 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) {
     case 0:
       if (lookahead == 'a') ADVANCE(1);
       if (lookahead == 'b') ADVANCE(2);
-      if (lookahead == 'd') ADVANCE(3);
-      if (lookahead == 'e') ADVANCE(4);
-      if (lookahead == 'f') ADVANCE(5);
-      if (lookahead == 'i') ADVANCE(6);
-      if (lookahead == 'l') ADVANCE(7);
-      if (lookahead == 'm') ADVANCE(8);
-      if (lookahead == 'n') ADVANCE(9);
-      if (lookahead == 'o') ADVANCE(10);
-      if (lookahead == 'r') ADVANCE(11);
-      if (lookahead == 's') ADVANCE(12);
-      if (lookahead == 't') ADVANCE(13);
-      if (lookahead == 'w') ADVANCE(14);
+      if (lookahead == 'e') ADVANCE(3);
+      if (lookahead == 'f') ADVANCE(4);
+      if (lookahead == 'i') ADVANCE(5);
+      if (lookahead == 'l') ADVANCE(6);
+      if (lookahead == 'm') ADVANCE(7);
+      if (lookahead == 'n') ADVANCE(8);
+      if (lookahead == 'o') ADVANCE(9);
+      if (lookahead == 'r') ADVANCE(10);
+      if (lookahead == 's') ADVANCE(11);
+      if (lookahead == 't') 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(15);
+      if (lookahead == 'n') ADVANCE(14);
+      if (lookahead == 'r') ADVANCE(15);
       if (lookahead == 's') ADVANCE(16);
       END_STATE();
     case 2:
-      if (lookahead == 'a') ADVANCE(17);
-      if (lookahead == 'o') ADVANCE(18);
+      if (lookahead == 'o') ADVANCE(17);
       END_STATE();
     case 3:
-      if (lookahead == 'o') ADVANCE(19);
+      if (lookahead == 'l') ADVANCE(18);
+      if (lookahead == 'n') ADVANCE(19);
       END_STATE();
     case 4:
-      if (lookahead == 'i') ADVANCE(20);
+      if (lookahead == 'a') ADVANCE(20);
       if (lookahead == 'l') ADVANCE(21);
+      if (lookahead == 'o') ADVANCE(22);
       END_STATE();
     case 5:
-      if (lookahead == 'a') ADVANCE(22);
-      if (lookahead == 'i') ADVANCE(23);
-      if (lookahead == 'l') ADVANCE(24);
-      if (lookahead == 'o') ADVANCE(25);
-      if (lookahead == 'r') ADVANCE(26);
+      if (lookahead == 'f') ADVANCE(23);
+      if (lookahead == 'n') ADVANCE(24);
       END_STATE();
     case 6:
-      if (lookahead == 'f') ADVANCE(27);
-      if (lookahead == 'n') ADVANCE(28);
-      if (lookahead == 's') ADVANCE(29);
+      if (lookahead == 'e') ADVANCE(25);
       END_STATE();
     case 7:
-      if (lookahead == 'e') ADVANCE(30);
+      if (lookahead == 'a') ADVANCE(26);
       END_STATE();
     case 8:
+      if (lookahead == 'o') ADVANCE(27);
+      if (lookahead == 'u') ADVANCE(28);
+      END_STATE();
+    case 9:
+      if (lookahead == 'p') ADVANCE(29);
+      if (lookahead == 'u') ADVANCE(30);
+      END_STATE();
+    case 10:
       if (lookahead == 'a') ADVANCE(31);
       if (lookahead == 'e') ADVANCE(32);
       END_STATE();
-    case 9:
-      if (lookahead == 'o') ADVANCE(33);
-      if (lookahead == 'u') ADVANCE(34);
-      END_STATE();
-    case 10:
-      if (lookahead == 'p') ADVANCE(35);
-      if (lookahead == 'u') ADVANCE(36);
-      END_STATE();
     case 11:
-      if (lookahead == 'a') ADVANCE(37);
-      if (lookahead == 'e') ADVANCE(38);
+      if (lookahead == 'o') ADVANCE(33);
+      if (lookahead == 't') ADVANCE(34);
       END_STATE();
     case 12:
-      if (lookahead == 'o') ADVANCE(39);
-      if (lookahead == 't') ADVANCE(40);
+      if (lookahead == 'r') ADVANCE(35);
       END_STATE();
     case 13:
-      if (lookahead == 'o') ADVANCE(41);
-      if (lookahead == 'r') ADVANCE(42);
+      if (lookahead == 'h') ADVANCE(36);
       END_STATE();
     case 14:
-      if (lookahead == 'h') ADVANCE(43);
-      if (lookahead == 'r') ADVANCE(44);
+      if (lookahead == 'y') ADVANCE(37);
       END_STATE();
     case 15:
-      if (lookahead == 'y') ADVANCE(45);
+      if (lookahead == 'g') ADVANCE(38);
       END_STATE();
     case 16:
-      if (lookahead == 's') ADVANCE(46);
-      if (lookahead == 'y') ADVANCE(47);
+      if (lookahead == 's') ADVANCE(39);
+      if (lookahead == 'y') ADVANCE(40);
       END_STATE();
     case 17:
-      if (lookahead == 's') ADVANCE(48);
+      if (lookahead == 'o') ADVANCE(41);
       END_STATE();
     case 18:
-      if (lookahead == 'o') ADVANCE(49);
+      if (lookahead == 's') ADVANCE(42);
       END_STATE();
     case 19:
-      if (lookahead == 'w') ADVANCE(50);
+      if (lookahead == 'v') ADVANCE(43);
       END_STATE();
     case 20:
-      if (lookahead == 't') ADVANCE(51);
+      if (lookahead == 'l') ADVANCE(44);
       END_STATE();
     case 21:
-      if (lookahead == 's') ADVANCE(52);
+      if (lookahead == 'o') ADVANCE(45);
       END_STATE();
     case 22:
-      if (lookahead == 'l') ADVANCE(53);
+      if (lookahead == 'r') ADVANCE(46);
       END_STATE();
     case 23:
-      if (lookahead == 's') ADVANCE(54);
-      END_STATE();
-    case 24:
-      if (lookahead == 'o') ADVANCE(55);
-      END_STATE();
-    case 25:
-      if (lookahead == 'r') ADVANCE(56);
-      END_STATE();
-    case 26:
-      if (lookahead == 'o') ADVANCE(57);
-      END_STATE();
-    case 27:
       ACCEPT_TOKEN(anon_sym_if);
       END_STATE();
-    case 28:
+    case 24:
       ACCEPT_TOKEN(anon_sym_in);
-      if (lookahead == 't') ADVANCE(58);
+      if (lookahead == 't') ADVANCE(47);
+      END_STATE();
+    case 25:
+      if (lookahead == 'n') ADVANCE(48);
+      END_STATE();
+    case 26:
+      if (lookahead == 'p') ADVANCE(49);
+      if (lookahead == 't') ADVANCE(50);
+      END_STATE();
+    case 27:
+      if (lookahead == 'n') ADVANCE(51);
+      END_STATE();
+    case 28:
+      if (lookahead == 'm') ADVANCE(52);
       END_STATE();
     case 29:
-      if (lookahead == '_') ADVANCE(59);
+      if (lookahead == 't') ADVANCE(53);
       END_STATE();
     case 30:
-      if (lookahead == 'n') ADVANCE(60);
+      if (lookahead == 't') ADVANCE(54);
       END_STATE();
     case 31:
-      if (lookahead == 'p') ADVANCE(61);
-      if (lookahead == 't') ADVANCE(62);
+      if (lookahead == 'n') ADVANCE(55);
       END_STATE();
     case 32:
-      if (lookahead == 't') ADVANCE(63);
+      if (lookahead == 't') ADVANCE(56);
       END_STATE();
     case 33:
-      if (lookahead == 'n') ADVANCE(64);
+      if (lookahead == 'm') ADVANCE(57);
       END_STATE();
     case 34:
-      if (lookahead == 'm') ADVANCE(65);
+      if (lookahead == 'r') ADVANCE(58);
       END_STATE();
     case 35:
-      if (lookahead == 't') ADVANCE(66);
+      if (lookahead == 'u') ADVANCE(59);
       END_STATE();
     case 36:
-      if (lookahead == 't') ADVANCE(67);
+      if (lookahead == 'i') ADVANCE(60);
       END_STATE();
     case 37:
-      if (lookahead == 'n') ADVANCE(68);
-      END_STATE();
-    case 38:
-      if (lookahead == 'a') ADVANCE(69);
-      if (lookahead == 't') ADVANCE(70);
-      END_STATE();
-    case 39:
-      if (lookahead == 'm') ADVANCE(71);
-      END_STATE();
-    case 40:
-      if (lookahead == 'd') ADVANCE(72);
-      if (lookahead == 'r') ADVANCE(73);
-      END_STATE();
-    case 41:
-      if (lookahead == '_') ADVANCE(74);
-      END_STATE();
-    case 42:
-      if (lookahead == 'u') ADVANCE(75);
-      END_STATE();
-    case 43:
-      if (lookahead == 'i') ADVANCE(76);
-      END_STATE();
-    case 44:
-      if (lookahead == 'i') ADVANCE(77);
-      END_STATE();
-    case 45:
       ACCEPT_TOKEN(anon_sym_any);
       END_STATE();
+    case 38:
+      if (lookahead == 's') ADVANCE(61);
+      END_STATE();
+    case 39:
+      if (lookahead == 'e') ADVANCE(62);
+      END_STATE();
+    case 40:
+      if (lookahead == 'n') ADVANCE(63);
+      END_STATE();
+    case 41:
+      if (lookahead == 'l') ADVANCE(64);
+      END_STATE();
+    case 42:
+      if (lookahead == 'e') ADVANCE(65);
+      END_STATE();
+    case 43:
+      ACCEPT_TOKEN(anon_sym_env);
+      END_STATE();
+    case 44:
+      if (lookahead == 's') ADVANCE(66);
+      END_STATE();
+    case 45:
+      if (lookahead == 'a') ADVANCE(67);
+      END_STATE();
     case 46:
-      if (lookahead == 'e') ADVANCE(78);
-      END_STATE();
-    case 47:
-      if (lookahead == 'n') ADVANCE(79);
-      END_STATE();
-    case 48:
-      if (lookahead == 'h') ADVANCE(80);
-      END_STATE();
-    case 49:
-      if (lookahead == 'l') ADVANCE(81);
-      END_STATE();
-    case 50:
-      if (lookahead == 'n') ADVANCE(82);
-      END_STATE();
-    case 51:
-      if (lookahead == 'h') ADVANCE(83);
-      END_STATE();
-    case 52:
-      if (lookahead == 'e') ADVANCE(84);
-      END_STATE();
-    case 53:
-      if (lookahead == 's') ADVANCE(85);
-      END_STATE();
-    case 54:
-      if (lookahead == 'h') ADVANCE(86);
-      END_STATE();
-    case 55:
-      if (lookahead == 'a') ADVANCE(87);
-      END_STATE();
-    case 56:
       ACCEPT_TOKEN(anon_sym_for);
       END_STATE();
-    case 57:
-      if (lookahead == 'm') ADVANCE(88);
-      END_STATE();
-    case 58:
+    case 47:
       ACCEPT_TOKEN(anon_sym_int);
       END_STATE();
-    case 59:
-      if (lookahead == 'n') ADVANCE(89);
-      if (lookahead == 's') ADVANCE(90);
+    case 48:
+      if (lookahead == 'g') ADVANCE(68);
       END_STATE();
-    case 60:
-      if (lookahead == 'g') ADVANCE(91);
-      END_STATE();
-    case 61:
+    case 49:
       ACCEPT_TOKEN(anon_sym_map);
       END_STATE();
-    case 62:
-      if (lookahead == 'c') ADVANCE(92);
+    case 50:
+      if (lookahead == 'c') ADVANCE(69);
       END_STATE();
-    case 63:
-      if (lookahead == 'a') ADVANCE(93);
+    case 51:
+      if (lookahead == 'e') ADVANCE(70);
       END_STATE();
-    case 64:
-      if (lookahead == 'e') ADVANCE(94);
-      END_STATE();
-    case 65:
+    case 52:
       ACCEPT_TOKEN(anon_sym_num);
       END_STATE();
-    case 66:
-      if (lookahead == 'i') ADVANCE(95);
+    case 53:
+      if (lookahead == 'i') ADVANCE(71);
       END_STATE();
-    case 67:
-      if (lookahead == 'p') ADVANCE(96);
+    case 54:
+      if (lookahead == 'p') ADVANCE(72);
       END_STATE();
-    case 68:
-      if (lookahead == 'd') ADVANCE(97);
+    case 55:
+      if (lookahead == 'd') ADVANCE(73);
       END_STATE();
-    case 69:
-      if (lookahead == 'd') ADVANCE(98);
+    case 56:
+      if (lookahead == 'u') ADVANCE(74);
       END_STATE();
-    case 70:
-      if (lookahead == 'u') ADVANCE(99);
+    case 57:
+      if (lookahead == 'e') ADVANCE(75);
       END_STATE();
-    case 71:
-      if (lookahead == 'e') ADVANCE(100);
-      END_STATE();
-    case 72:
-      ACCEPT_TOKEN(anon_sym_std);
-      END_STATE();
-    case 73:
+    case 58:
       ACCEPT_TOKEN(anon_sym_str);
       END_STATE();
-    case 74:
-      if (lookahead == 'j') ADVANCE(101);
+    case 59:
+      if (lookahead == 'e') ADVANCE(76);
       END_STATE();
-    case 75:
-      if (lookahead == 'e') ADVANCE(102);
+    case 60:
+      if (lookahead == 'l') ADVANCE(77);
       END_STATE();
-    case 76:
-      if (lookahead == 'l') ADVANCE(103);
+    case 61:
+      ACCEPT_TOKEN(anon_sym_args);
       END_STATE();
-    case 77:
-      if (lookahead == 't') ADVANCE(104);
+    case 62:
+      if (lookahead == 'r') ADVANCE(78);
       END_STATE();
-    case 78:
-      if (lookahead == 'r') ADVANCE(105);
+    case 63:
+      if (lookahead == 'c') ADVANCE(79);
       END_STATE();
-    case 79:
-      if (lookahead == 'c') ADVANCE(106);
-      END_STATE();
-    case 80:
-      ACCEPT_TOKEN(anon_sym_bash);
-      END_STATE();
-    case 81:
+    case 64:
       ACCEPT_TOKEN(anon_sym_bool);
       END_STATE();
-    case 82:
-      if (lookahead == 'l') ADVANCE(107);
-      END_STATE();
-    case 83:
-      if (lookahead == 'e') ADVANCE(108);
-      END_STATE();
-    case 84:
+    case 65:
       ACCEPT_TOKEN(anon_sym_else);
       END_STATE();
-    case 85:
-      if (lookahead == 'e') ADVANCE(109);
+    case 66:
+      if (lookahead == 'e') ADVANCE(80);
       END_STATE();
-    case 86:
-      ACCEPT_TOKEN(anon_sym_fish);
+    case 67:
+      if (lookahead == 't') ADVANCE(81);
       END_STATE();
-    case 87:
-      if (lookahead == 't') ADVANCE(110);
+    case 68:
+      if (lookahead == 't') ADVANCE(82);
       END_STATE();
-    case 88:
-      if (lookahead == '_') ADVANCE(111);
+    case 69:
+      if (lookahead == 'h') ADVANCE(83);
       END_STATE();
-    case 89:
-      if (lookahead == 'o') ADVANCE(112);
-      END_STATE();
-    case 90:
-      if (lookahead == 'o') ADVANCE(113);
-      END_STATE();
-    case 91:
-      if (lookahead == 't') ADVANCE(114);
-      END_STATE();
-    case 92:
-      if (lookahead == 'h') ADVANCE(115);
-      END_STATE();
-    case 93:
-      if (lookahead == 'd') ADVANCE(116);
-      END_STATE();
-    case 94:
+    case 70:
       ACCEPT_TOKEN(anon_sym_none);
       END_STATE();
-    case 95:
-      if (lookahead == 'o') ADVANCE(117);
+    case 71:
+      if (lookahead == 'o') ADVANCE(84);
       END_STATE();
-    case 96:
-      if (lookahead == 'u') ADVANCE(118);
+    case 72:
+      if (lookahead == 'u') ADVANCE(85);
       END_STATE();
-    case 97:
-      if (lookahead == 'o') ADVANCE(119);
+    case 73:
+      if (lookahead == 'o') ADVANCE(86);
       END_STATE();
-    case 98:
-      ACCEPT_TOKEN(anon_sym_read);
+    case 74:
+      if (lookahead == 'r') ADVANCE(87);
       END_STATE();
-    case 99:
-      if (lookahead == 'r') ADVANCE(120);
-      END_STATE();
-    case 100:
+    case 75:
       ACCEPT_TOKEN(anon_sym_some);
       END_STATE();
-    case 101:
-      if (lookahead == 's') ADVANCE(121);
-      END_STATE();
-    case 102:
+    case 76:
       ACCEPT_TOKEN(anon_sym_true);
       END_STATE();
-    case 103:
-      if (lookahead == 'e') ADVANCE(122);
+    case 77:
+      if (lookahead == 'e') ADVANCE(88);
       END_STATE();
-    case 104:
-      if (lookahead == 'e') ADVANCE(123);
+    case 78:
+      if (lookahead == 't') ADVANCE(89);
       END_STATE();
-    case 105:
-      if (lookahead == 't') ADVANCE(124);
-      END_STATE();
-    case 106:
+    case 79:
       ACCEPT_TOKEN(anon_sym_async);
       END_STATE();
-    case 107:
-      if (lookahead == 'o') ADVANCE(125);
-      END_STATE();
-    case 108:
-      if (lookahead == 'r') ADVANCE(126);
-      END_STATE();
-    case 109:
+    case 80:
       ACCEPT_TOKEN(anon_sym_false);
       END_STATE();
-    case 110:
+    case 81:
       ACCEPT_TOKEN(anon_sym_float);
       END_STATE();
-    case 111:
-      if (lookahead == 'j') ADVANCE(127);
+    case 82:
+      if (lookahead == 'h') ADVANCE(90);
       END_STATE();
-    case 112:
-      if (lookahead == 'n') ADVANCE(128);
-      END_STATE();
-    case 113:
-      if (lookahead == 'm') ADVANCE(129);
-      END_STATE();
-    case 114:
-      if (lookahead == 'h') ADVANCE(130);
-      END_STATE();
-    case 115:
+    case 83:
       ACCEPT_TOKEN(anon_sym_match);
       END_STATE();
-    case 116:
-      if (lookahead == 'a') ADVANCE(131);
+    case 84:
+      if (lookahead == 'n') ADVANCE(91);
       END_STATE();
-    case 117:
-      if (lookahead == 'n') ADVANCE(132);
+    case 85:
+      if (lookahead == 't') ADVANCE(92);
       END_STATE();
-    case 118:
-      if (lookahead == 't') ADVANCE(133);
+    case 86:
+      if (lookahead == 'm') ADVANCE(93);
       END_STATE();
-    case 119:
-      if (lookahead == 'm') ADVANCE(134);
+    case 87:
+      if (lookahead == 'n') ADVANCE(94);
       END_STATE();
-    case 120:
-      if (lookahead == 'n') ADVANCE(135);
-      END_STATE();
-    case 121:
-      if (lookahead == 'o') ADVANCE(136);
-      END_STATE();
-    case 122:
+    case 88:
       ACCEPT_TOKEN(anon_sym_while);
       END_STATE();
-    case 123:
-      ACCEPT_TOKEN(anon_sym_write);
+    case 89:
+      if (lookahead == '_') ADVANCE(95);
       END_STATE();
-    case 124:
-      ACCEPT_TOKEN(anon_sym_assert);
-      if (lookahead == '_') ADVANCE(137);
-      END_STATE();
-    case 125:
-      if (lookahead == 'a') ADVANCE(138);
-      END_STATE();
-    case 126:
-      if (lookahead == '_') ADVANCE(139);
-      END_STATE();
-    case 127:
-      if (lookahead == 's') ADVANCE(140);
-      END_STATE();
-    case 128:
-      if (lookahead == 'e') ADVANCE(141);
-      END_STATE();
-    case 129:
-      if (lookahead == 'e') ADVANCE(142);
-      END_STATE();
-    case 130:
+    case 90:
       ACCEPT_TOKEN(anon_sym_length);
       END_STATE();
-    case 131:
-      if (lookahead == 't') ADVANCE(143);
-      END_STATE();
-    case 132:
+    case 91:
       ACCEPT_TOKEN(anon_sym_option);
       END_STATE();
-    case 133:
+    case 92:
       ACCEPT_TOKEN(anon_sym_output);
-      if (lookahead == '_') ADVANCE(144);
       END_STATE();
-    case 134:
+    case 93:
       ACCEPT_TOKEN(anon_sym_random);
-      if (lookahead == '_') ADVANCE(145);
       END_STATE();
-    case 135:
+    case 94:
       ACCEPT_TOKEN(anon_sym_return);
       END_STATE();
-    case 136:
-      if (lookahead == 'n') ADVANCE(146);
+    case 95:
+      if (lookahead == 'e') ADVANCE(96);
       END_STATE();
-    case 137:
-      if (lookahead == 'e') ADVANCE(147);
+    case 96:
+      if (lookahead == 'q') ADVANCE(97);
       END_STATE();
-    case 138:
-      if (lookahead == 'd') ADVANCE(148);
+    case 97:
+      if (lookahead == 'u') ADVANCE(98);
       END_STATE();
-    case 139:
-      if (lookahead == 'o') ADVANCE(149);
+    case 98:
+      if (lookahead == 'a') ADVANCE(99);
       END_STATE();
-    case 140:
-      if (lookahead == 'o') ADVANCE(150);
+    case 99:
+      if (lookahead == 'l') ADVANCE(100);
       END_STATE();
-    case 141:
-      ACCEPT_TOKEN(anon_sym_is_none);
-      END_STATE();
-    case 142:
-      ACCEPT_TOKEN(anon_sym_is_some);
-      END_STATE();
-    case 143:
-      if (lookahead == 'a') ADVANCE(151);
-      END_STATE();
-    case 144:
-      if (lookahead == 'e') ADVANCE(152);
-      END_STATE();
-    case 145:
-      if (lookahead == 'b') ADVANCE(153);
-      if (lookahead == 'f') ADVANCE(154);
-      if (lookahead == 'i') ADVANCE(155);
-      END_STATE();
-    case 146:
-      ACCEPT_TOKEN(anon_sym_to_json);
-      END_STATE();
-    case 147:
-      if (lookahead == 'q') ADVANCE(156);
-      END_STATE();
-    case 148:
-      ACCEPT_TOKEN(anon_sym_download);
-      END_STATE();
-    case 149:
-      if (lookahead == 'r') ADVANCE(157);
-      END_STATE();
-    case 150:
-      if (lookahead == 'n') ADVANCE(158);
-      END_STATE();
-    case 151:
-      ACCEPT_TOKEN(anon_sym_metadata);
-      END_STATE();
-    case 152:
-      if (lookahead == 'r') ADVANCE(159);
-      END_STATE();
-    case 153:
-      if (lookahead == 'o') ADVANCE(160);
-      END_STATE();
-    case 154:
-      if (lookahead == 'l') ADVANCE(161);
-      END_STATE();
-    case 155:
-      if (lookahead == 'n') ADVANCE(162);
-      END_STATE();
-    case 156:
-      if (lookahead == 'u') ADVANCE(163);
-      END_STATE();
-    case 157:
-      ACCEPT_TOKEN(anon_sym_either_or);
-      END_STATE();
-    case 158:
-      ACCEPT_TOKEN(anon_sym_from_json);
-      END_STATE();
-    case 159:
-      if (lookahead == 'r') ADVANCE(164);
-      END_STATE();
-    case 160:
-      if (lookahead == 'o') ADVANCE(165);
-      END_STATE();
-    case 161:
-      if (lookahead == 'o') ADVANCE(166);
-      END_STATE();
-    case 162:
-      if (lookahead == 't') ADVANCE(167);
-      END_STATE();
-    case 163:
-      if (lookahead == 'a') ADVANCE(168);
-      END_STATE();
-    case 164:
-      if (lookahead == 'o') ADVANCE(169);
-      END_STATE();
-    case 165:
-      if (lookahead == 'l') ADVANCE(170);
-      END_STATE();
-    case 166:
-      if (lookahead == 'a') ADVANCE(171);
-      END_STATE();
-    case 167:
-      if (lookahead == 'e') ADVANCE(172);
-      END_STATE();
-    case 168:
-      if (lookahead == 'l') ADVANCE(173);
-      END_STATE();
-    case 169:
-      if (lookahead == 'r') ADVANCE(174);
-      END_STATE();
-    case 170:
-      if (lookahead == 'e') ADVANCE(175);
-      END_STATE();
-    case 171:
-      if (lookahead == 't') ADVANCE(176);
-      END_STATE();
-    case 172:
-      if (lookahead == 'g') ADVANCE(177);
-      END_STATE();
-    case 173:
+    case 100:
       ACCEPT_TOKEN(anon_sym_assert_equal);
       END_STATE();
-    case 174:
-      ACCEPT_TOKEN(anon_sym_output_error);
-      END_STATE();
-    case 175:
-      if (lookahead == 'a') ADVANCE(178);
-      END_STATE();
-    case 176:
-      ACCEPT_TOKEN(anon_sym_random_float);
-      END_STATE();
-    case 177:
-      if (lookahead == 'e') ADVANCE(179);
-      END_STATE();
-    case 178:
-      if (lookahead == 'n') ADVANCE(180);
-      END_STATE();
-    case 179:
-      if (lookahead == 'r') ADVANCE(181);
-      END_STATE();
-    case 180:
-      ACCEPT_TOKEN(anon_sym_random_boolean);
-      END_STATE();
-    case 181:
-      ACCEPT_TOKEN(anon_sym_random_integer);
-      END_STATE();
     default:
       return false;
   }
@@ -2470,98 +2081,98 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) {
 
 static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [0] = {.lex_state = 0},
-  [1] = {.lex_state = 24},
-  [2] = {.lex_state = 24},
-  [3] = {.lex_state = 24},
-  [4] = {.lex_state = 24},
-  [5] = {.lex_state = 24},
-  [6] = {.lex_state = 24},
-  [7] = {.lex_state = 24},
-  [8] = {.lex_state = 24},
-  [9] = {.lex_state = 24},
-  [10] = {.lex_state = 24},
-  [11] = {.lex_state = 24},
-  [12] = {.lex_state = 24},
-  [13] = {.lex_state = 24},
-  [14] = {.lex_state = 24},
-  [15] = {.lex_state = 24},
-  [16] = {.lex_state = 24},
-  [17] = {.lex_state = 24},
-  [18] = {.lex_state = 24},
-  [19] = {.lex_state = 24},
-  [20] = {.lex_state = 24},
-  [21] = {.lex_state = 24},
-  [22] = {.lex_state = 24},
-  [23] = {.lex_state = 24},
-  [24] = {.lex_state = 24},
-  [25] = {.lex_state = 24},
-  [26] = {.lex_state = 24},
-  [27] = {.lex_state = 24},
-  [28] = {.lex_state = 24},
-  [29] = {.lex_state = 24},
-  [30] = {.lex_state = 24},
-  [31] = {.lex_state = 24},
-  [32] = {.lex_state = 24},
-  [33] = {.lex_state = 24},
-  [34] = {.lex_state = 24},
-  [35] = {.lex_state = 24},
-  [36] = {.lex_state = 24},
-  [37] = {.lex_state = 24},
-  [38] = {.lex_state = 24},
-  [39] = {.lex_state = 24},
-  [40] = {.lex_state = 24},
-  [41] = {.lex_state = 24},
-  [42] = {.lex_state = 24},
-  [43] = {.lex_state = 24},
-  [44] = {.lex_state = 24},
-  [45] = {.lex_state = 24},
-  [46] = {.lex_state = 24},
-  [47] = {.lex_state = 24},
-  [48] = {.lex_state = 24},
-  [49] = {.lex_state = 24},
-  [50] = {.lex_state = 24},
-  [51] = {.lex_state = 24},
-  [52] = {.lex_state = 24},
-  [53] = {.lex_state = 24},
-  [54] = {.lex_state = 24},
-  [55] = {.lex_state = 24},
-  [56] = {.lex_state = 24},
-  [57] = {.lex_state = 24},
-  [58] = {.lex_state = 24},
-  [59] = {.lex_state = 24},
-  [60] = {.lex_state = 24},
-  [61] = {.lex_state = 24},
-  [62] = {.lex_state = 24},
-  [63] = {.lex_state = 24},
-  [64] = {.lex_state = 24},
-  [65] = {.lex_state = 24},
-  [66] = {.lex_state = 24},
-  [67] = {.lex_state = 24},
-  [68] = {.lex_state = 24},
-  [69] = {.lex_state = 24},
-  [70] = {.lex_state = 24},
-  [71] = {.lex_state = 24},
-  [72] = {.lex_state = 24},
-  [73] = {.lex_state = 24},
-  [74] = {.lex_state = 24},
-  [75] = {.lex_state = 24},
-  [76] = {.lex_state = 24},
-  [77] = {.lex_state = 24},
-  [78] = {.lex_state = 24},
-  [79] = {.lex_state = 24},
-  [80] = {.lex_state = 24},
-  [81] = {.lex_state = 24},
-  [82] = {.lex_state = 24},
-  [83] = {.lex_state = 24},
+  [1] = {.lex_state = 25},
+  [2] = {.lex_state = 25},
+  [3] = {.lex_state = 25},
+  [4] = {.lex_state = 25},
+  [5] = {.lex_state = 25},
+  [6] = {.lex_state = 25},
+  [7] = {.lex_state = 25},
+  [8] = {.lex_state = 25},
+  [9] = {.lex_state = 25},
+  [10] = {.lex_state = 25},
+  [11] = {.lex_state = 25},
+  [12] = {.lex_state = 25},
+  [13] = {.lex_state = 25},
+  [14] = {.lex_state = 25},
+  [15] = {.lex_state = 25},
+  [16] = {.lex_state = 25},
+  [17] = {.lex_state = 25},
+  [18] = {.lex_state = 25},
+  [19] = {.lex_state = 25},
+  [20] = {.lex_state = 25},
+  [21] = {.lex_state = 25},
+  [22] = {.lex_state = 25},
+  [23] = {.lex_state = 25},
+  [24] = {.lex_state = 25},
+  [25] = {.lex_state = 25},
+  [26] = {.lex_state = 25},
+  [27] = {.lex_state = 25},
+  [28] = {.lex_state = 25},
+  [29] = {.lex_state = 25},
+  [30] = {.lex_state = 25},
+  [31] = {.lex_state = 25},
+  [32] = {.lex_state = 25},
+  [33] = {.lex_state = 25},
+  [34] = {.lex_state = 25},
+  [35] = {.lex_state = 25},
+  [36] = {.lex_state = 25},
+  [37] = {.lex_state = 25},
+  [38] = {.lex_state = 25},
+  [39] = {.lex_state = 25},
+  [40] = {.lex_state = 25},
+  [41] = {.lex_state = 25},
+  [42] = {.lex_state = 25},
+  [43] = {.lex_state = 25},
+  [44] = {.lex_state = 25},
+  [45] = {.lex_state = 25},
+  [46] = {.lex_state = 25},
+  [47] = {.lex_state = 25},
+  [48] = {.lex_state = 25},
+  [49] = {.lex_state = 25},
+  [50] = {.lex_state = 25},
+  [51] = {.lex_state = 25},
+  [52] = {.lex_state = 25},
+  [53] = {.lex_state = 25},
+  [54] = {.lex_state = 25},
+  [55] = {.lex_state = 25},
+  [56] = {.lex_state = 25},
+  [57] = {.lex_state = 25},
+  [58] = {.lex_state = 25},
+  [59] = {.lex_state = 25},
+  [60] = {.lex_state = 25},
+  [61] = {.lex_state = 25},
+  [62] = {.lex_state = 25},
+  [63] = {.lex_state = 25},
+  [64] = {.lex_state = 25},
+  [65] = {.lex_state = 25},
+  [66] = {.lex_state = 25},
+  [67] = {.lex_state = 25},
+  [68] = {.lex_state = 25},
+  [69] = {.lex_state = 25},
+  [70] = {.lex_state = 25},
+  [71] = {.lex_state = 25},
+  [72] = {.lex_state = 25},
+  [73] = {.lex_state = 25},
+  [74] = {.lex_state = 25},
+  [75] = {.lex_state = 25},
+  [76] = {.lex_state = 25},
+  [77] = {.lex_state = 25},
+  [78] = {.lex_state = 25},
+  [79] = {.lex_state = 25},
+  [80] = {.lex_state = 25},
+  [81] = {.lex_state = 25},
+  [82] = {.lex_state = 25},
+  [83] = {.lex_state = 25},
   [84] = {.lex_state = 1},
-  [85] = {.lex_state = 24},
+  [85] = {.lex_state = 1},
   [86] = {.lex_state = 1},
-  [87] = {.lex_state = 24},
-  [88] = {.lex_state = 24},
-  [89] = {.lex_state = 24},
+  [87] = {.lex_state = 1},
+  [88] = {.lex_state = 1},
+  [89] = {.lex_state = 25},
   [90] = {.lex_state = 1},
-  [91] = {.lex_state = 24},
-  [92] = {.lex_state = 24},
+  [91] = {.lex_state = 1},
+  [92] = {.lex_state = 1},
   [93] = {.lex_state = 1},
   [94] = {.lex_state = 1},
   [95] = {.lex_state = 1},
@@ -2681,16 +2292,16 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [209] = {.lex_state = 1},
   [210] = {.lex_state = 1},
   [211] = {.lex_state = 1},
-  [212] = {.lex_state = 1},
-  [213] = {.lex_state = 1},
-  [214] = {.lex_state = 1},
-  [215] = {.lex_state = 1},
-  [216] = {.lex_state = 1},
-  [217] = {.lex_state = 1},
-  [218] = {.lex_state = 1},
-  [219] = {.lex_state = 1},
-  [220] = {.lex_state = 1},
-  [221] = {.lex_state = 1},
+  [212] = {.lex_state = 0},
+  [213] = {.lex_state = 0},
+  [214] = {.lex_state = 0},
+  [215] = {.lex_state = 0},
+  [216] = {.lex_state = 2},
+  [217] = {.lex_state = 0},
+  [218] = {.lex_state = 2},
+  [219] = {.lex_state = 0},
+  [220] = {.lex_state = 0},
+  [221] = {.lex_state = 0},
   [222] = {.lex_state = 2},
   [223] = {.lex_state = 2},
   [224] = {.lex_state = 2},
@@ -2721,103 +2332,103 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [249] = {.lex_state = 2},
   [250] = {.lex_state = 2},
   [251] = {.lex_state = 2},
-  [252] = {.lex_state = 2},
-  [253] = {.lex_state = 2},
-  [254] = {.lex_state = 2},
-  [255] = {.lex_state = 2},
-  [256] = {.lex_state = 2},
+  [252] = {.lex_state = 25},
+  [253] = {.lex_state = 25},
+  [254] = {.lex_state = 25},
+  [255] = {.lex_state = 25},
+  [256] = {.lex_state = 25},
   [257] = {.lex_state = 2},
-  [258] = {.lex_state = 0},
-  [259] = {.lex_state = 2},
-  [260] = {.lex_state = 0},
-  [261] = {.lex_state = 0},
-  [262] = {.lex_state = 4},
-  [263] = {.lex_state = 0},
-  [264] = {.lex_state = 3},
-  [265] = {.lex_state = 0},
-  [266] = {.lex_state = 3},
-  [267] = {.lex_state = 0},
-  [268] = {.lex_state = 0},
-  [269] = {.lex_state = 0},
-  [270] = {.lex_state = 4},
-  [271] = {.lex_state = 3},
+  [258] = {.lex_state = 25},
+  [259] = {.lex_state = 25},
+  [260] = {.lex_state = 25},
+  [261] = {.lex_state = 25},
+  [262] = {.lex_state = 25},
+  [263] = {.lex_state = 25},
+  [264] = {.lex_state = 25},
+  [265] = {.lex_state = 25},
+  [266] = {.lex_state = 1},
+  [267] = {.lex_state = 5},
+  [268] = {.lex_state = 1},
+  [269] = {.lex_state = 1},
+  [270] = {.lex_state = 5},
+  [271] = {.lex_state = 1},
   [272] = {.lex_state = 1},
-  [273] = {.lex_state = 3},
+  [273] = {.lex_state = 1},
   [274] = {.lex_state = 1},
-  [275] = {.lex_state = 1},
-  [276] = {.lex_state = 1},
-  [277] = {.lex_state = 1},
-  [278] = {.lex_state = 1},
-  [279] = {.lex_state = 1},
-  [280] = {.lex_state = 24},
-  [281] = {.lex_state = 24},
-  [282] = {.lex_state = 24},
-  [283] = {.lex_state = 24},
-  [284] = {.lex_state = 24},
-  [285] = {.lex_state = 24},
-  [286] = {.lex_state = 24},
-  [287] = {.lex_state = 24},
-  [288] = {.lex_state = 24},
-  [289] = {.lex_state = 24},
-  [290] = {.lex_state = 24},
-  [291] = {.lex_state = 24},
-  [292] = {.lex_state = 24},
-  [293] = {.lex_state = 5},
-  [294] = {.lex_state = 5},
-  [295] = {.lex_state = 5},
-  [296] = {.lex_state = 2},
-  [297] = {.lex_state = 2},
-  [298] = {.lex_state = 24},
-  [299] = {.lex_state = 5},
-  [300] = {.lex_state = 5},
-  [301] = {.lex_state = 5},
-  [302] = {.lex_state = 5},
-  [303] = {.lex_state = 5},
-  [304] = {.lex_state = 1},
-  [305] = {.lex_state = 1},
-  [306] = {.lex_state = 1},
-  [307] = {.lex_state = 1},
-  [308] = {.lex_state = 1},
-  [309] = {.lex_state = 1},
-  [310] = {.lex_state = 1},
+  [275] = {.lex_state = 5},
+  [276] = {.lex_state = 4},
+  [277] = {.lex_state = 4},
+  [278] = {.lex_state = 3},
+  [279] = {.lex_state = 25},
+  [280] = {.lex_state = 5},
+  [281] = {.lex_state = 5},
+  [282] = {.lex_state = 5},
+  [283] = {.lex_state = 5},
+  [284] = {.lex_state = 3},
+  [285] = {.lex_state = 5},
+  [286] = {.lex_state = 3},
+  [287] = {.lex_state = 1},
+  [288] = {.lex_state = 1},
+  [289] = {.lex_state = 1},
+  [290] = {.lex_state = 1},
+  [291] = {.lex_state = 1},
+  [292] = {.lex_state = 1},
+  [293] = {.lex_state = 1},
+  [294] = {.lex_state = 1},
+  [295] = {.lex_state = 1},
+  [296] = {.lex_state = 1},
+  [297] = {.lex_state = 1},
+  [298] = {.lex_state = 1},
+  [299] = {.lex_state = 1},
+  [300] = {.lex_state = 2},
+  [301] = {.lex_state = 2},
+  [302] = {.lex_state = 1},
+  [303] = {.lex_state = 2},
+  [304] = {.lex_state = 2},
+  [305] = {.lex_state = 2},
+  [306] = {.lex_state = 2},
+  [307] = {.lex_state = 2},
+  [308] = {.lex_state = 2},
+  [309] = {.lex_state = 2},
+  [310] = {.lex_state = 2},
   [311] = {.lex_state = 1},
-  [312] = {.lex_state = 1},
-  [313] = {.lex_state = 1},
-  [314] = {.lex_state = 1},
-  [315] = {.lex_state = 1},
-  [316] = {.lex_state = 1},
-  [317] = {.lex_state = 1},
-  [318] = {.lex_state = 1},
-  [319] = {.lex_state = 1},
+  [312] = {.lex_state = 2},
+  [313] = {.lex_state = 2},
+  [314] = {.lex_state = 2},
+  [315] = {.lex_state = 2},
+  [316] = {.lex_state = 2},
+  [317] = {.lex_state = 2},
+  [318] = {.lex_state = 2},
+  [319] = {.lex_state = 2},
   [320] = {.lex_state = 1},
-  [321] = {.lex_state = 1},
-  [322] = {.lex_state = 1},
-  [323] = {.lex_state = 5},
-  [324] = {.lex_state = 5},
-  [325] = {.lex_state = 1},
-  [326] = {.lex_state = 1},
-  [327] = {.lex_state = 1},
-  [328] = {.lex_state = 1},
-  [329] = {.lex_state = 1},
+  [321] = {.lex_state = 2},
+  [322] = {.lex_state = 2},
+  [323] = {.lex_state = 1},
+  [324] = {.lex_state = 2},
+  [325] = {.lex_state = 2},
+  [326] = {.lex_state = 2},
+  [327] = {.lex_state = 2},
+  [328] = {.lex_state = 2},
+  [329] = {.lex_state = 2},
   [330] = {.lex_state = 1},
-  [331] = {.lex_state = 1},
-  [332] = {.lex_state = 1},
-  [333] = {.lex_state = 1},
-  [334] = {.lex_state = 1},
+  [331] = {.lex_state = 2},
+  [332] = {.lex_state = 2},
+  [333] = {.lex_state = 2},
+  [334] = {.lex_state = 3},
   [335] = {.lex_state = 1},
-  [336] = {.lex_state = 1},
-  [337] = {.lex_state = 1},
-  [338] = {.lex_state = 1},
-  [339] = {.lex_state = 1},
-  [340] = {.lex_state = 1},
-  [341] = {.lex_state = 1},
-  [342] = {.lex_state = 1},
-  [343] = {.lex_state = 1},
-  [344] = {.lex_state = 1},
-  [345] = {.lex_state = 1},
+  [336] = {.lex_state = 2},
+  [337] = {.lex_state = 2},
+  [338] = {.lex_state = 2},
+  [339] = {.lex_state = 2},
+  [340] = {.lex_state = 2},
+  [341] = {.lex_state = 2},
+  [342] = {.lex_state = 2},
+  [343] = {.lex_state = 2},
+  [344] = {.lex_state = 2},
+  [345] = {.lex_state = 2},
   [346] = {.lex_state = 2},
-  [347] = {.lex_state = 2},
-  [348] = {.lex_state = 2},
+  [347] = {.lex_state = 7},
+  [348] = {.lex_state = 7},
   [349] = {.lex_state = 2},
   [350] = {.lex_state = 2},
   [351] = {.lex_state = 2},
@@ -2825,118 +2436,102 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = {
   [353] = {.lex_state = 2},
   [354] = {.lex_state = 2},
   [355] = {.lex_state = 2},
-  [356] = {.lex_state = 2},
+  [356] = {.lex_state = 7},
   [357] = {.lex_state = 2},
-  [358] = {.lex_state = 2},
-  [359] = {.lex_state = 2},
-  [360] = {.lex_state = 2},
-  [361] = {.lex_state = 2},
-  [362] = {.lex_state = 2},
-  [363] = {.lex_state = 2},
-  [364] = {.lex_state = 2},
-  [365] = {.lex_state = 2},
-  [366] = {.lex_state = 2},
-  [367] = {.lex_state = 2},
-  [368] = {.lex_state = 2},
-  [369] = {.lex_state = 2},
-  [370] = {.lex_state = 2},
-  [371] = {.lex_state = 2},
-  [372] = {.lex_state = 2},
-  [373] = {.lex_state = 2},
-  [374] = {.lex_state = 3},
-  [375] = {.lex_state = 2},
-  [376] = {.lex_state = 2},
-  [377] = {.lex_state = 2},
-  [378] = {.lex_state = 2},
-  [379] = {.lex_state = 7},
-  [380] = {.lex_state = 2},
-  [381] = {.lex_state = 7},
-  [382] = {.lex_state = 2},
-  [383] = {.lex_state = 2},
-  [384] = {.lex_state = 2},
-  [385] = {.lex_state = 2},
-  [386] = {.lex_state = 2},
-  [387] = {.lex_state = 2},
-  [388] = {.lex_state = 2},
-  [389] = {.lex_state = 2},
-  [390] = {.lex_state = 2},
-  [391] = {.lex_state = 2},
-  [392] = {.lex_state = 2},
-  [393] = {.lex_state = 2},
-  [394] = {.lex_state = 7},
-  [395] = {.lex_state = 7},
-  [396] = {.lex_state = 7},
-  [397] = {.lex_state = 2},
-  [398] = {.lex_state = 7},
-  [399] = {.lex_state = 2},
+  [358] = {.lex_state = 7},
+  [359] = {.lex_state = 7},
+  [360] = {.lex_state = 7},
+  [361] = {.lex_state = 1},
+  [362] = {.lex_state = 1},
+  [363] = {.lex_state = 1},
+  [364] = {.lex_state = 1},
+  [365] = {.lex_state = 1},
+  [366] = {.lex_state = 1},
+  [367] = {.lex_state = 1},
+  [368] = {.lex_state = 1},
+  [369] = {.lex_state = 1},
+  [370] = {.lex_state = 1},
+  [371] = {.lex_state = 5},
+  [372] = {.lex_state = 5},
+  [373] = {.lex_state = 1},
+  [374] = {.lex_state = 25},
+  [375] = {.lex_state = 25},
+  [376] = {.lex_state = 25},
+  [377] = {.lex_state = 25},
+  [378] = {.lex_state = 1},
+  [379] = {.lex_state = 1},
+  [380] = {.lex_state = 1},
+  [381] = {.lex_state = 1},
+  [382] = {.lex_state = 1},
+  [383] = {.lex_state = 1},
+  [384] = {.lex_state = 1},
+  [385] = {.lex_state = 1},
+  [386] = {.lex_state = 1},
+  [387] = {.lex_state = 1},
+  [388] = {.lex_state = 1},
+  [389] = {.lex_state = 1},
+  [390] = {.lex_state = 1},
+  [391] = {.lex_state = 1},
+  [392] = {.lex_state = 1},
+  [393] = {.lex_state = 1},
+  [394] = {.lex_state = 1},
+  [395] = {.lex_state = 1},
+  [396] = {.lex_state = 25},
+  [397] = {.lex_state = 1},
+  [398] = {.lex_state = 1},
+  [399] = {.lex_state = 0},
   [400] = {.lex_state = 1},
-  [401] = {.lex_state = 1},
-  [402] = {.lex_state = 1},
-  [403] = {.lex_state = 1},
-  [404] = {.lex_state = 1},
-  [405] = {.lex_state = 1},
+  [401] = {.lex_state = 0},
+  [402] = {.lex_state = 0},
+  [403] = {.lex_state = 0},
+  [404] = {.lex_state = 0},
+  [405] = {.lex_state = 0},
   [406] = {.lex_state = 1},
   [407] = {.lex_state = 1},
   [408] = {.lex_state = 1},
-  [409] = {.lex_state = 1},
-  [410] = {.lex_state = 24},
-  [411] = {.lex_state = 24},
-  [412] = {.lex_state = 24},
-  [413] = {.lex_state = 24},
-  [414] = {.lex_state = 1},
-  [415] = {.lex_state = 1},
-  [416] = {.lex_state = 1},
-  [417] = {.lex_state = 1},
+  [409] = {.lex_state = 0},
+  [410] = {.lex_state = 0},
+  [411] = {.lex_state = 1},
+  [412] = {.lex_state = 1},
+  [413] = {.lex_state = 0},
+  [414] = {.lex_state = 0},
+  [415] = {.lex_state = 0},
+  [416] = {.lex_state = 0},
+  [417] = {.lex_state = 0},
   [418] = {.lex_state = 1},
-  [419] = {.lex_state = 24},
-  [420] = {.lex_state = 1},
-  [421] = {.lex_state = 1},
-  [422] = {.lex_state = 1},
-  [423] = {.lex_state = 1},
-  [424] = {.lex_state = 0},
-  [425] = {.lex_state = 0},
+  [419] = {.lex_state = 5},
+  [420] = {.lex_state = 0},
+  [421] = {.lex_state = 0},
+  [422] = {.lex_state = 0},
+  [423] = {.lex_state = 0},
+  [424] = {.lex_state = 25},
+  [425] = {.lex_state = 1},
   [426] = {.lex_state = 0},
   [427] = {.lex_state = 0},
   [428] = {.lex_state = 0},
-  [429] = {.lex_state = 0},
+  [429] = {.lex_state = 1},
   [430] = {.lex_state = 0},
   [431] = {.lex_state = 0},
   [432] = {.lex_state = 0},
-  [433] = {.lex_state = 0},
-  [434] = {.lex_state = 3},
+  [433] = {.lex_state = 1},
+  [434] = {.lex_state = 5},
   [435] = {.lex_state = 0},
   [436] = {.lex_state = 0},
   [437] = {.lex_state = 0},
   [438] = {.lex_state = 0},
   [439] = {.lex_state = 0},
   [440] = {.lex_state = 0},
-  [441] = {.lex_state = 0},
+  [441] = {.lex_state = 1},
   [442] = {.lex_state = 0},
   [443] = {.lex_state = 0},
-  [444] = {.lex_state = 0},
+  [444] = {.lex_state = 1},
   [445] = {.lex_state = 0},
-  [446] = {.lex_state = 0},
-  [447] = {.lex_state = 1},
-  [448] = {.lex_state = 0},
-  [449] = {.lex_state = 0},
-  [450] = {.lex_state = 5},
-  [451] = {.lex_state = 0},
-  [452] = {.lex_state = 0},
-  [453] = {.lex_state = 1},
-  [454] = {.lex_state = 0},
-  [455] = {.lex_state = 0},
-  [456] = {.lex_state = 24},
-  [457] = {.lex_state = 0},
-  [458] = {.lex_state = 0},
-  [459] = {.lex_state = 0},
-  [460] = {.lex_state = 0},
-  [461] = {.lex_state = 1},
 };
 
 static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
   [0] = {
     [ts_builtin_sym_end] = ACTIONS(1),
-    [sym__identifier_pattern] = ACTIONS(1),
+    [sym_identifier] = ACTIONS(1),
     [sym__comment] = ACTIONS(3),
     [anon_sym_SEMI] = ACTIONS(1),
     [anon_sym_LPAREN] = ACTIONS(1),
@@ -2991,61 +2586,44 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_str] = ACTIONS(1),
     [anon_sym_DASH_GT] = ACTIONS(1),
     [anon_sym_option] = ACTIONS(1),
-    [anon_sym_assert] = ACTIONS(1),
+    [anon_sym_args] = ACTIONS(1),
     [anon_sym_assert_equal] = ACTIONS(1),
-    [anon_sym_bash] = ACTIONS(1),
-    [anon_sym_download] = ACTIONS(1),
-    [anon_sym_either_or] = ACTIONS(1),
-    [anon_sym_fish] = ACTIONS(1),
-    [anon_sym_from_json] = ACTIONS(1),
-    [anon_sym_is_none] = ACTIONS(1),
-    [anon_sym_is_some] = ACTIONS(1),
+    [anon_sym_env] = ACTIONS(1),
     [anon_sym_length] = ACTIONS(1),
-    [anon_sym_metadata] = ACTIONS(1),
     [anon_sym_output] = ACTIONS(1),
-    [anon_sym_output_error] = ACTIONS(1),
     [anon_sym_random] = ACTIONS(1),
-    [anon_sym_random_boolean] = ACTIONS(1),
-    [anon_sym_random_float] = ACTIONS(1),
-    [anon_sym_random_integer] = ACTIONS(1),
-    [anon_sym_read] = ACTIONS(1),
-    [anon_sym_to_json] = ACTIONS(1),
-    [anon_sym_write] = ACTIONS(1),
-    [anon_sym_std] = ACTIONS(1),
   },
   [1] = {
-    [sym_root] = STATE(455),
-    [sym_statement] = STATE(24),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(24),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_root] = STATE(440),
+    [sym_statement] = STATE(26),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(26),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
@@ -3064,140 +2642,106 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [2] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [ts_builtin_sym_end] = ACTIONS(41),
-    [sym__identifier_pattern] = ACTIONS(43),
+    [sym_statement] = STATE(12),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(12),
+    [aux_sym_map_repeat1] = STATE(393),
+    [sym_identifier] = ACTIONS(39),
     [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(46),
-    [anon_sym_async] = ACTIONS(49),
-    [anon_sym_LBRACE] = ACTIONS(52),
+    [anon_sym_LPAREN] = ACTIONS(7),
+    [anon_sym_async] = ACTIONS(9),
+    [anon_sym_LBRACE] = ACTIONS(11),
     [anon_sym_RBRACE] = ACTIONS(41),
-    [sym_integer] = ACTIONS(55),
-    [sym_float] = ACTIONS(58),
-    [sym_string] = ACTIONS(58),
-    [anon_sym_true] = ACTIONS(61),
-    [anon_sym_false] = ACTIONS(61),
-    [anon_sym_LBRACK] = ACTIONS(64),
-    [anon_sym_none] = ACTIONS(67),
-    [anon_sym_some] = ACTIONS(70),
-    [anon_sym_if] = ACTIONS(73),
-    [anon_sym_match] = ACTIONS(76),
-    [anon_sym_while] = ACTIONS(79),
-    [anon_sym_for] = ACTIONS(82),
-    [anon_sym_asyncfor] = ACTIONS(85),
-    [anon_sym_return] = ACTIONS(88),
-    [anon_sym_assert] = ACTIONS(91),
-    [anon_sym_assert_equal] = ACTIONS(91),
-    [anon_sym_bash] = ACTIONS(91),
-    [anon_sym_download] = ACTIONS(91),
-    [anon_sym_either_or] = ACTIONS(91),
-    [anon_sym_fish] = ACTIONS(91),
-    [anon_sym_from_json] = ACTIONS(91),
-    [anon_sym_is_none] = ACTIONS(91),
-    [anon_sym_is_some] = ACTIONS(91),
-    [anon_sym_length] = ACTIONS(91),
-    [anon_sym_metadata] = ACTIONS(91),
-    [anon_sym_output] = ACTIONS(91),
-    [anon_sym_output_error] = ACTIONS(91),
-    [anon_sym_random] = ACTIONS(91),
-    [anon_sym_random_boolean] = ACTIONS(91),
-    [anon_sym_random_float] = ACTIONS(91),
-    [anon_sym_random_integer] = ACTIONS(91),
-    [anon_sym_read] = ACTIONS(91),
-    [anon_sym_to_json] = ACTIONS(91),
-    [anon_sym_write] = ACTIONS(91),
-    [anon_sym_std] = ACTIONS(94),
+    [sym_integer] = ACTIONS(13),
+    [sym_float] = ACTIONS(15),
+    [sym_string] = ACTIONS(15),
+    [anon_sym_true] = ACTIONS(17),
+    [anon_sym_false] = ACTIONS(17),
+    [anon_sym_LBRACK] = ACTIONS(19),
+    [anon_sym_none] = ACTIONS(21),
+    [anon_sym_some] = ACTIONS(23),
+    [anon_sym_if] = ACTIONS(25),
+    [anon_sym_match] = ACTIONS(27),
+    [anon_sym_while] = ACTIONS(29),
+    [anon_sym_for] = ACTIONS(31),
+    [anon_sym_asyncfor] = ACTIONS(33),
+    [anon_sym_return] = ACTIONS(35),
+    [anon_sym_args] = ACTIONS(37),
+    [anon_sym_assert_equal] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
+    [anon_sym_length] = ACTIONS(37),
+    [anon_sym_output] = ACTIONS(37),
+    [anon_sym_random] = ACTIONS(37),
   },
   [3] = {
-    [sym_statement] = STATE(15),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(65),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(15),
-    [aux_sym_map_repeat1] = STATE(328),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(22),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(22),
+    [aux_sym_map_repeat1] = STATE(380),
+    [sym_identifier] = ACTIONS(39),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(97),
+    [anon_sym_RBRACE] = ACTIONS(43),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3212,66 +2756,49 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [4] = {
-    [sym_statement] = STATE(6),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(65),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(6),
-    [aux_sym_map_repeat1] = STATE(327),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(7),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(7),
+    [aux_sym_map_repeat1] = STATE(387),
+    [sym_identifier] = ACTIONS(39),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(99),
+    [anon_sym_RBRACE] = ACTIONS(45),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3286,139 +2813,105 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [5] = {
-    [sym_statement] = STATE(22),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(65),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(22),
-    [aux_sym_map_repeat1] = STATE(331),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [ts_builtin_sym_end] = ACTIONS(47),
+    [sym_identifier] = ACTIONS(49),
     [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(7),
-    [anon_sym_async] = ACTIONS(9),
-    [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(101),
-    [sym_integer] = ACTIONS(13),
-    [sym_float] = ACTIONS(15),
-    [sym_string] = ACTIONS(15),
-    [anon_sym_true] = ACTIONS(17),
-    [anon_sym_false] = ACTIONS(17),
-    [anon_sym_LBRACK] = ACTIONS(19),
-    [anon_sym_none] = ACTIONS(21),
-    [anon_sym_some] = ACTIONS(23),
-    [anon_sym_if] = ACTIONS(25),
-    [anon_sym_match] = ACTIONS(27),
-    [anon_sym_while] = ACTIONS(29),
-    [anon_sym_for] = ACTIONS(31),
-    [anon_sym_asyncfor] = ACTIONS(33),
-    [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
-    [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
-    [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
-    [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
-    [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
+    [anon_sym_LPAREN] = ACTIONS(52),
+    [anon_sym_async] = ACTIONS(55),
+    [anon_sym_LBRACE] = ACTIONS(58),
+    [anon_sym_RBRACE] = ACTIONS(47),
+    [sym_integer] = ACTIONS(61),
+    [sym_float] = ACTIONS(64),
+    [sym_string] = ACTIONS(64),
+    [anon_sym_true] = ACTIONS(67),
+    [anon_sym_false] = ACTIONS(67),
+    [anon_sym_LBRACK] = ACTIONS(70),
+    [anon_sym_none] = ACTIONS(73),
+    [anon_sym_some] = ACTIONS(76),
+    [anon_sym_if] = ACTIONS(79),
+    [anon_sym_match] = ACTIONS(82),
+    [anon_sym_while] = ACTIONS(85),
+    [anon_sym_for] = ACTIONS(88),
+    [anon_sym_asyncfor] = ACTIONS(91),
+    [anon_sym_return] = ACTIONS(94),
+    [anon_sym_args] = ACTIONS(97),
+    [anon_sym_assert_equal] = ACTIONS(97),
+    [anon_sym_env] = ACTIONS(97),
+    [anon_sym_length] = ACTIONS(97),
+    [anon_sym_output] = ACTIONS(97),
+    [anon_sym_random] = ACTIONS(97),
   },
   [6] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(20),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(20),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(103),
+    [anon_sym_RBRACE] = ACTIONS(100),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3433,65 +2926,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [7] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(105),
+    [anon_sym_RBRACE] = ACTIONS(100),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3506,65 +2982,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [8] = {
-    [sym_statement] = STATE(12),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(12),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(107),
+    [anon_sym_RBRACE] = ACTIONS(102),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3579,65 +3038,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [9] = {
-    [sym_statement] = STATE(13),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(13),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(14),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(14),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(109),
+    [anon_sym_RBRACE] = ACTIONS(104),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3652,65 +3094,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [10] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(13),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(13),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(111),
+    [anon_sym_RBRACE] = ACTIONS(106),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3725,65 +3150,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [11] = {
-    [sym_statement] = STATE(22),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(22),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(101),
+    [anon_sym_RBRACE] = ACTIONS(108),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3798,65 +3206,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [12] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(109),
+    [anon_sym_RBRACE] = ACTIONS(110),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3871,65 +3262,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [13] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(113),
+    [anon_sym_RBRACE] = ACTIONS(112),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -3944,65 +3318,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [14] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(115),
+    [anon_sym_RBRACE] = ACTIONS(114),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4017,65 +3374,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [15] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(11),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(11),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(117),
+    [anon_sym_RBRACE] = ACTIONS(110),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4090,65 +3430,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [16] = {
-    [sym_statement] = STATE(14),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(14),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(22),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(22),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(117),
+    [anon_sym_RBRACE] = ACTIONS(43),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4163,65 +3486,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [17] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(119),
+    [anon_sym_RBRACE] = ACTIONS(106),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4236,65 +3542,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [18] = {
-    [sym_statement] = STATE(17),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(17),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(12),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(12),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(121),
+    [anon_sym_RBRACE] = ACTIONS(41),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4309,65 +3598,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [19] = {
-    [sym_statement] = STATE(15),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(15),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(97),
+    [anon_sym_RBRACE] = ACTIONS(116),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4382,65 +3654,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [20] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(123),
+    [anon_sym_RBRACE] = ACTIONS(118),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4455,65 +3710,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [21] = {
-    [sym_statement] = STATE(10),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(10),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(7),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(7),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(125),
+    [anon_sym_RBRACE] = ACTIONS(45),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4528,65 +3766,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [22] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(125),
+    [anon_sym_RBRACE] = ACTIONS(120),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4601,65 +3822,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [23] = {
-    [sym_statement] = STATE(6),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(6),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(19),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(19),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(99),
+    [anon_sym_RBRACE] = ACTIONS(120),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4674,65 +3878,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [24] = {
-    [sym_statement] = STATE(2),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(2),
-    [ts_builtin_sym_end] = ACTIONS(127),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(17),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(17),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
+    [anon_sym_RBRACE] = ACTIONS(122),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4747,65 +3934,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [25] = {
-    [sym_statement] = STATE(7),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(7),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(8),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(8),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
     [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(103),
+    [anon_sym_RBRACE] = ACTIONS(114),
     [sym_integer] = ACTIONS(13),
     [sym_float] = ACTIONS(15),
     [sym_string] = ACTIONS(15),
@@ -4820,203 +3990,44 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
   },
   [26] = {
-    [sym_statement] = STATE(20),
-    [sym_expression] = STATE(87),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(284),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(284),
-    [sym_index_assignment] = STATE(284),
-    [sym_if_else] = STATE(284),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(284),
-    [sym_while] = STATE(284),
-    [sym_for] = STATE(284),
-    [sym_return] = STATE(284),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [aux_sym_root_repeat1] = STATE(20),
-    [sym__identifier_pattern] = ACTIONS(5),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(7),
-    [anon_sym_async] = ACTIONS(9),
-    [anon_sym_LBRACE] = ACTIONS(11),
-    [anon_sym_RBRACE] = ACTIONS(119),
-    [sym_integer] = ACTIONS(13),
-    [sym_float] = ACTIONS(15),
-    [sym_string] = ACTIONS(15),
-    [anon_sym_true] = ACTIONS(17),
-    [anon_sym_false] = ACTIONS(17),
-    [anon_sym_LBRACK] = ACTIONS(19),
-    [anon_sym_none] = ACTIONS(21),
-    [anon_sym_some] = ACTIONS(23),
-    [anon_sym_if] = ACTIONS(25),
-    [anon_sym_match] = ACTIONS(27),
-    [anon_sym_while] = ACTIONS(29),
-    [anon_sym_for] = ACTIONS(31),
-    [anon_sym_asyncfor] = ACTIONS(33),
-    [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
-    [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
-    [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
-    [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
-    [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
-  },
-  [27] = {
-    [sym_statement] = STATE(317),
-    [sym_expression] = STATE(168),
-    [sym__expression_kind] = STATE(106),
-    [sym_block] = STATE(306),
-    [sym_identifier] = STATE(127),
-    [sym_value] = STATE(125),
-    [sym_boolean] = STATE(110),
-    [sym_list] = STATE(110),
-    [sym_map] = STATE(110),
-    [sym_option] = STATE(110),
-    [sym_index] = STATE(129),
-    [sym_index_expression] = STATE(459),
-    [sym_math] = STATE(106),
-    [sym_logic] = STATE(106),
-    [sym_assignment] = STATE(306),
-    [sym_index_assignment] = STATE(306),
-    [sym_if_else] = STATE(306),
-    [sym_if] = STATE(294),
-    [sym_match] = STATE(306),
-    [sym_while] = STATE(306),
-    [sym_for] = STATE(306),
-    [sym_return] = STATE(306),
-    [sym_function] = STATE(123),
-    [sym_function_expression] = STATE(458),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(119),
-    [sym_yield] = STATE(119),
-    [sym_built_in_function] = STATE(113),
-    [sym_built_in_value] = STATE(123),
-    [sym__identifier_pattern] = ACTIONS(129),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(131),
-    [anon_sym_async] = ACTIONS(133),
-    [anon_sym_LBRACE] = ACTIONS(135),
-    [sym_integer] = ACTIONS(137),
-    [sym_float] = ACTIONS(139),
-    [sym_string] = ACTIONS(139),
-    [anon_sym_true] = ACTIONS(141),
-    [anon_sym_false] = ACTIONS(141),
-    [anon_sym_LBRACK] = ACTIONS(143),
-    [anon_sym_none] = ACTIONS(145),
-    [anon_sym_some] = ACTIONS(147),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(153),
-    [anon_sym_for] = ACTIONS(155),
-    [anon_sym_asyncfor] = ACTIONS(157),
-    [anon_sym_return] = ACTIONS(159),
-    [anon_sym_assert] = ACTIONS(161),
-    [anon_sym_assert_equal] = ACTIONS(161),
-    [anon_sym_bash] = ACTIONS(161),
-    [anon_sym_download] = ACTIONS(161),
-    [anon_sym_either_or] = ACTIONS(161),
-    [anon_sym_fish] = ACTIONS(161),
-    [anon_sym_from_json] = ACTIONS(161),
-    [anon_sym_is_none] = ACTIONS(161),
-    [anon_sym_is_some] = ACTIONS(161),
-    [anon_sym_length] = ACTIONS(161),
-    [anon_sym_metadata] = ACTIONS(161),
-    [anon_sym_output] = ACTIONS(161),
-    [anon_sym_output_error] = ACTIONS(161),
-    [anon_sym_random] = ACTIONS(161),
-    [anon_sym_random_boolean] = ACTIONS(161),
-    [anon_sym_random_float] = ACTIONS(161),
-    [anon_sym_random_integer] = ACTIONS(161),
-    [anon_sym_read] = ACTIONS(161),
-    [anon_sym_to_json] = ACTIONS(161),
-    [anon_sym_write] = ACTIONS(161),
-    [anon_sym_std] = ACTIONS(163),
-  },
-  [28] = {
-    [sym_statement] = STATE(289),
-    [sym_expression] = STATE(89),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(290),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(290),
-    [sym_index_assignment] = STATE(290),
-    [sym_if_else] = STATE(290),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(290),
-    [sym_while] = STATE(290),
-    [sym_for] = STATE(290),
-    [sym_return] = STATE(290),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [sym__identifier_pattern] = ACTIONS(5),
+    [sym_statement] = STATE(5),
+    [sym_expression] = STATE(83),
+    [sym__expression_kind] = STATE(66),
+    [sym_block] = STATE(261),
+    [sym_value] = STATE(75),
+    [sym_boolean] = STATE(67),
+    [sym_list] = STATE(67),
+    [sym_map] = STATE(67),
+    [sym_option] = STATE(67),
+    [sym_index] = STATE(65),
+    [sym_index_expression] = STATE(438),
+    [sym_math] = STATE(66),
+    [sym_logic] = STATE(66),
+    [sym_assignment] = STATE(261),
+    [sym_index_assignment] = STATE(261),
+    [sym_if_else] = STATE(261),
+    [sym_if] = STATE(212),
+    [sym_match] = STATE(261),
+    [sym_while] = STATE(261),
+    [sym_for] = STATE(261),
+    [sym_return] = STATE(261),
+    [sym_function] = STATE(67),
+    [sym_function_expression] = STATE(437),
+    [sym__function_expression_kind] = STATE(59),
+    [sym_function_call] = STATE(58),
+    [sym_yield] = STATE(58),
+    [sym_built_in_value] = STATE(67),
+    [aux_sym_root_repeat1] = STATE(5),
+    [ts_builtin_sym_end] = ACTIONS(124),
+    [sym_identifier] = ACTIONS(5),
     [sym__comment] = ACTIONS(3),
     [anon_sym_LPAREN] = ACTIONS(7),
     [anon_sym_async] = ACTIONS(9),
@@ -5035,9371 +4046,110 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
     [anon_sym_for] = ACTIONS(31),
     [anon_sym_asyncfor] = ACTIONS(33),
     [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
+    [anon_sym_args] = ACTIONS(37),
     [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
+    [anon_sym_env] = ACTIONS(37),
     [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
     [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
     [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
-  },
-  [29] = {
-    [sym_statement] = STATE(338),
-    [sym_expression] = STATE(297),
-    [sym__expression_kind] = STATE(252),
-    [sym_block] = STATE(306),
-    [sym_identifier] = STATE(262),
-    [sym_value] = STATE(227),
-    [sym_boolean] = STATE(232),
-    [sym_list] = STATE(232),
-    [sym_map] = STATE(232),
-    [sym_option] = STATE(232),
-    [sym_index] = STATE(270),
-    [sym_index_expression] = STATE(454),
-    [sym_math] = STATE(252),
-    [sym_logic] = STATE(252),
-    [sym_assignment] = STATE(306),
-    [sym_index_assignment] = STATE(306),
-    [sym_if_else] = STATE(306),
-    [sym_if] = STATE(324),
-    [sym_match] = STATE(306),
-    [sym_while] = STATE(306),
-    [sym_for] = STATE(306),
-    [sym_return] = STATE(306),
-    [sym_function] = STATE(242),
-    [sym_function_expression] = STATE(446),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(251),
-    [sym_yield] = STATE(251),
-    [sym_built_in_function] = STATE(245),
-    [sym_built_in_value] = STATE(242),
-    [sym__identifier_pattern] = ACTIONS(165),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(167),
-    [anon_sym_async] = ACTIONS(169),
-    [anon_sym_LBRACE] = ACTIONS(171),
-    [sym_integer] = ACTIONS(173),
-    [sym_float] = ACTIONS(175),
-    [sym_string] = ACTIONS(175),
-    [anon_sym_true] = ACTIONS(177),
-    [anon_sym_false] = ACTIONS(177),
-    [anon_sym_LBRACK] = ACTIONS(179),
-    [anon_sym_none] = ACTIONS(181),
-    [anon_sym_some] = ACTIONS(183),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(185),
-    [anon_sym_for] = ACTIONS(187),
-    [anon_sym_asyncfor] = ACTIONS(189),
-    [anon_sym_return] = ACTIONS(191),
-    [anon_sym_assert] = ACTIONS(193),
-    [anon_sym_assert_equal] = ACTIONS(193),
-    [anon_sym_bash] = ACTIONS(193),
-    [anon_sym_download] = ACTIONS(193),
-    [anon_sym_either_or] = ACTIONS(193),
-    [anon_sym_fish] = ACTIONS(193),
-    [anon_sym_from_json] = ACTIONS(193),
-    [anon_sym_is_none] = ACTIONS(193),
-    [anon_sym_is_some] = ACTIONS(193),
-    [anon_sym_length] = ACTIONS(193),
-    [anon_sym_metadata] = ACTIONS(193),
-    [anon_sym_output] = ACTIONS(193),
-    [anon_sym_output_error] = ACTIONS(193),
-    [anon_sym_random] = ACTIONS(193),
-    [anon_sym_random_boolean] = ACTIONS(193),
-    [anon_sym_random_float] = ACTIONS(193),
-    [anon_sym_random_integer] = ACTIONS(193),
-    [anon_sym_read] = ACTIONS(193),
-    [anon_sym_to_json] = ACTIONS(193),
-    [anon_sym_write] = ACTIONS(193),
-    [anon_sym_std] = ACTIONS(195),
-  },
-  [30] = {
-    [sym_statement] = STATE(305),
-    [sym_expression] = STATE(296),
-    [sym__expression_kind] = STATE(252),
-    [sym_block] = STATE(309),
-    [sym_identifier] = STATE(262),
-    [sym_value] = STATE(227),
-    [sym_boolean] = STATE(232),
-    [sym_list] = STATE(232),
-    [sym_map] = STATE(232),
-    [sym_option] = STATE(232),
-    [sym_index] = STATE(270),
-    [sym_index_expression] = STATE(454),
-    [sym_math] = STATE(252),
-    [sym_logic] = STATE(252),
-    [sym_assignment] = STATE(309),
-    [sym_index_assignment] = STATE(309),
-    [sym_if_else] = STATE(309),
-    [sym_if] = STATE(324),
-    [sym_match] = STATE(309),
-    [sym_while] = STATE(309),
-    [sym_for] = STATE(309),
-    [sym_return] = STATE(309),
-    [sym_function] = STATE(242),
-    [sym_function_expression] = STATE(446),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(251),
-    [sym_yield] = STATE(251),
-    [sym_built_in_function] = STATE(245),
-    [sym_built_in_value] = STATE(242),
-    [sym__identifier_pattern] = ACTIONS(165),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(167),
-    [anon_sym_async] = ACTIONS(169),
-    [anon_sym_LBRACE] = ACTIONS(171),
-    [sym_integer] = ACTIONS(173),
-    [sym_float] = ACTIONS(175),
-    [sym_string] = ACTIONS(175),
-    [anon_sym_true] = ACTIONS(177),
-    [anon_sym_false] = ACTIONS(177),
-    [anon_sym_LBRACK] = ACTIONS(179),
-    [anon_sym_none] = ACTIONS(181),
-    [anon_sym_some] = ACTIONS(183),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(185),
-    [anon_sym_for] = ACTIONS(187),
-    [anon_sym_asyncfor] = ACTIONS(189),
-    [anon_sym_return] = ACTIONS(191),
-    [anon_sym_assert] = ACTIONS(193),
-    [anon_sym_assert_equal] = ACTIONS(193),
-    [anon_sym_bash] = ACTIONS(193),
-    [anon_sym_download] = ACTIONS(193),
-    [anon_sym_either_or] = ACTIONS(193),
-    [anon_sym_fish] = ACTIONS(193),
-    [anon_sym_from_json] = ACTIONS(193),
-    [anon_sym_is_none] = ACTIONS(193),
-    [anon_sym_is_some] = ACTIONS(193),
-    [anon_sym_length] = ACTIONS(193),
-    [anon_sym_metadata] = ACTIONS(193),
-    [anon_sym_output] = ACTIONS(193),
-    [anon_sym_output_error] = ACTIONS(193),
-    [anon_sym_random] = ACTIONS(193),
-    [anon_sym_random_boolean] = ACTIONS(193),
-    [anon_sym_random_float] = ACTIONS(193),
-    [anon_sym_random_integer] = ACTIONS(193),
-    [anon_sym_read] = ACTIONS(193),
-    [anon_sym_to_json] = ACTIONS(193),
-    [anon_sym_write] = ACTIONS(193),
-    [anon_sym_std] = ACTIONS(195),
-  },
-  [31] = {
-    [sym_statement] = STATE(291),
-    [sym_expression] = STATE(89),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(290),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(290),
-    [sym_index_assignment] = STATE(290),
-    [sym_if_else] = STATE(290),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(290),
-    [sym_while] = STATE(290),
-    [sym_for] = STATE(290),
-    [sym_return] = STATE(290),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [sym__identifier_pattern] = ACTIONS(5),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(7),
-    [anon_sym_async] = ACTIONS(9),
-    [anon_sym_LBRACE] = ACTIONS(11),
-    [sym_integer] = ACTIONS(13),
-    [sym_float] = ACTIONS(15),
-    [sym_string] = ACTIONS(15),
-    [anon_sym_true] = ACTIONS(17),
-    [anon_sym_false] = ACTIONS(17),
-    [anon_sym_LBRACK] = ACTIONS(19),
-    [anon_sym_none] = ACTIONS(21),
-    [anon_sym_some] = ACTIONS(23),
-    [anon_sym_if] = ACTIONS(25),
-    [anon_sym_match] = ACTIONS(27),
-    [anon_sym_while] = ACTIONS(29),
-    [anon_sym_for] = ACTIONS(31),
-    [anon_sym_asyncfor] = ACTIONS(33),
-    [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
-    [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
-    [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
-    [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
-    [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
-  },
-  [32] = {
-    [sym_statement] = STATE(311),
-    [sym_expression] = STATE(165),
-    [sym__expression_kind] = STATE(106),
-    [sym_block] = STATE(309),
-    [sym_identifier] = STATE(127),
-    [sym_value] = STATE(125),
-    [sym_boolean] = STATE(110),
-    [sym_list] = STATE(110),
-    [sym_map] = STATE(110),
-    [sym_option] = STATE(110),
-    [sym_index] = STATE(129),
-    [sym_index_expression] = STATE(459),
-    [sym_math] = STATE(106),
-    [sym_logic] = STATE(106),
-    [sym_assignment] = STATE(309),
-    [sym_index_assignment] = STATE(309),
-    [sym_if_else] = STATE(309),
-    [sym_if] = STATE(294),
-    [sym_match] = STATE(309),
-    [sym_while] = STATE(309),
-    [sym_for] = STATE(309),
-    [sym_return] = STATE(309),
-    [sym_function] = STATE(123),
-    [sym_function_expression] = STATE(458),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(119),
-    [sym_yield] = STATE(119),
-    [sym_built_in_function] = STATE(113),
-    [sym_built_in_value] = STATE(123),
-    [sym__identifier_pattern] = ACTIONS(129),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(131),
-    [anon_sym_async] = ACTIONS(133),
-    [anon_sym_LBRACE] = ACTIONS(135),
-    [sym_integer] = ACTIONS(137),
-    [sym_float] = ACTIONS(139),
-    [sym_string] = ACTIONS(139),
-    [anon_sym_true] = ACTIONS(141),
-    [anon_sym_false] = ACTIONS(141),
-    [anon_sym_LBRACK] = ACTIONS(143),
-    [anon_sym_none] = ACTIONS(145),
-    [anon_sym_some] = ACTIONS(147),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(153),
-    [anon_sym_for] = ACTIONS(155),
-    [anon_sym_asyncfor] = ACTIONS(157),
-    [anon_sym_return] = ACTIONS(159),
-    [anon_sym_assert] = ACTIONS(161),
-    [anon_sym_assert_equal] = ACTIONS(161),
-    [anon_sym_bash] = ACTIONS(161),
-    [anon_sym_download] = ACTIONS(161),
-    [anon_sym_either_or] = ACTIONS(161),
-    [anon_sym_fish] = ACTIONS(161),
-    [anon_sym_from_json] = ACTIONS(161),
-    [anon_sym_is_none] = ACTIONS(161),
-    [anon_sym_is_some] = ACTIONS(161),
-    [anon_sym_length] = ACTIONS(161),
-    [anon_sym_metadata] = ACTIONS(161),
-    [anon_sym_output] = ACTIONS(161),
-    [anon_sym_output_error] = ACTIONS(161),
-    [anon_sym_random] = ACTIONS(161),
-    [anon_sym_random_boolean] = ACTIONS(161),
-    [anon_sym_random_float] = ACTIONS(161),
-    [anon_sym_random_integer] = ACTIONS(161),
-    [anon_sym_read] = ACTIONS(161),
-    [anon_sym_to_json] = ACTIONS(161),
-    [anon_sym_write] = ACTIONS(161),
-    [anon_sym_std] = ACTIONS(163),
-  },
-  [33] = {
-    [sym_statement] = STATE(314),
-    [sym_expression] = STATE(165),
-    [sym__expression_kind] = STATE(106),
-    [sym_block] = STATE(309),
-    [sym_identifier] = STATE(127),
-    [sym_value] = STATE(125),
-    [sym_boolean] = STATE(110),
-    [sym_list] = STATE(110),
-    [sym_map] = STATE(110),
-    [sym_option] = STATE(110),
-    [sym_index] = STATE(129),
-    [sym_index_expression] = STATE(459),
-    [sym_math] = STATE(106),
-    [sym_logic] = STATE(106),
-    [sym_assignment] = STATE(309),
-    [sym_index_assignment] = STATE(309),
-    [sym_if_else] = STATE(309),
-    [sym_if] = STATE(294),
-    [sym_match] = STATE(309),
-    [sym_while] = STATE(309),
-    [sym_for] = STATE(309),
-    [sym_return] = STATE(309),
-    [sym_function] = STATE(123),
-    [sym_function_expression] = STATE(458),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(119),
-    [sym_yield] = STATE(119),
-    [sym_built_in_function] = STATE(113),
-    [sym_built_in_value] = STATE(123),
-    [sym__identifier_pattern] = ACTIONS(129),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(131),
-    [anon_sym_async] = ACTIONS(133),
-    [anon_sym_LBRACE] = ACTIONS(135),
-    [sym_integer] = ACTIONS(137),
-    [sym_float] = ACTIONS(139),
-    [sym_string] = ACTIONS(139),
-    [anon_sym_true] = ACTIONS(141),
-    [anon_sym_false] = ACTIONS(141),
-    [anon_sym_LBRACK] = ACTIONS(143),
-    [anon_sym_none] = ACTIONS(145),
-    [anon_sym_some] = ACTIONS(147),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(153),
-    [anon_sym_for] = ACTIONS(155),
-    [anon_sym_asyncfor] = ACTIONS(157),
-    [anon_sym_return] = ACTIONS(159),
-    [anon_sym_assert] = ACTIONS(161),
-    [anon_sym_assert_equal] = ACTIONS(161),
-    [anon_sym_bash] = ACTIONS(161),
-    [anon_sym_download] = ACTIONS(161),
-    [anon_sym_either_or] = ACTIONS(161),
-    [anon_sym_fish] = ACTIONS(161),
-    [anon_sym_from_json] = ACTIONS(161),
-    [anon_sym_is_none] = ACTIONS(161),
-    [anon_sym_is_some] = ACTIONS(161),
-    [anon_sym_length] = ACTIONS(161),
-    [anon_sym_metadata] = ACTIONS(161),
-    [anon_sym_output] = ACTIONS(161),
-    [anon_sym_output_error] = ACTIONS(161),
-    [anon_sym_random] = ACTIONS(161),
-    [anon_sym_random_boolean] = ACTIONS(161),
-    [anon_sym_random_float] = ACTIONS(161),
-    [anon_sym_random_integer] = ACTIONS(161),
-    [anon_sym_read] = ACTIONS(161),
-    [anon_sym_to_json] = ACTIONS(161),
-    [anon_sym_write] = ACTIONS(161),
-    [anon_sym_std] = ACTIONS(163),
-  },
-  [34] = {
-    [sym_statement] = STATE(307),
-    [sym_expression] = STATE(165),
-    [sym__expression_kind] = STATE(106),
-    [sym_block] = STATE(309),
-    [sym_identifier] = STATE(127),
-    [sym_value] = STATE(125),
-    [sym_boolean] = STATE(110),
-    [sym_list] = STATE(110),
-    [sym_map] = STATE(110),
-    [sym_option] = STATE(110),
-    [sym_index] = STATE(129),
-    [sym_index_expression] = STATE(459),
-    [sym_math] = STATE(106),
-    [sym_logic] = STATE(106),
-    [sym_assignment] = STATE(309),
-    [sym_index_assignment] = STATE(309),
-    [sym_if_else] = STATE(309),
-    [sym_if] = STATE(294),
-    [sym_match] = STATE(309),
-    [sym_while] = STATE(309),
-    [sym_for] = STATE(309),
-    [sym_return] = STATE(309),
-    [sym_function] = STATE(123),
-    [sym_function_expression] = STATE(458),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(119),
-    [sym_yield] = STATE(119),
-    [sym_built_in_function] = STATE(113),
-    [sym_built_in_value] = STATE(123),
-    [sym__identifier_pattern] = ACTIONS(129),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(131),
-    [anon_sym_async] = ACTIONS(133),
-    [anon_sym_LBRACE] = ACTIONS(135),
-    [sym_integer] = ACTIONS(137),
-    [sym_float] = ACTIONS(139),
-    [sym_string] = ACTIONS(139),
-    [anon_sym_true] = ACTIONS(141),
-    [anon_sym_false] = ACTIONS(141),
-    [anon_sym_LBRACK] = ACTIONS(143),
-    [anon_sym_none] = ACTIONS(145),
-    [anon_sym_some] = ACTIONS(147),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(153),
-    [anon_sym_for] = ACTIONS(155),
-    [anon_sym_asyncfor] = ACTIONS(157),
-    [anon_sym_return] = ACTIONS(159),
-    [anon_sym_assert] = ACTIONS(161),
-    [anon_sym_assert_equal] = ACTIONS(161),
-    [anon_sym_bash] = ACTIONS(161),
-    [anon_sym_download] = ACTIONS(161),
-    [anon_sym_either_or] = ACTIONS(161),
-    [anon_sym_fish] = ACTIONS(161),
-    [anon_sym_from_json] = ACTIONS(161),
-    [anon_sym_is_none] = ACTIONS(161),
-    [anon_sym_is_some] = ACTIONS(161),
-    [anon_sym_length] = ACTIONS(161),
-    [anon_sym_metadata] = ACTIONS(161),
-    [anon_sym_output] = ACTIONS(161),
-    [anon_sym_output_error] = ACTIONS(161),
-    [anon_sym_random] = ACTIONS(161),
-    [anon_sym_random_boolean] = ACTIONS(161),
-    [anon_sym_random_float] = ACTIONS(161),
-    [anon_sym_random_integer] = ACTIONS(161),
-    [anon_sym_read] = ACTIONS(161),
-    [anon_sym_to_json] = ACTIONS(161),
-    [anon_sym_write] = ACTIONS(161),
-    [anon_sym_std] = ACTIONS(163),
-  },
-  [35] = {
-    [sym_statement] = STATE(339),
-    [sym_expression] = STATE(297),
-    [sym__expression_kind] = STATE(252),
-    [sym_block] = STATE(306),
-    [sym_identifier] = STATE(262),
-    [sym_value] = STATE(227),
-    [sym_boolean] = STATE(232),
-    [sym_list] = STATE(232),
-    [sym_map] = STATE(232),
-    [sym_option] = STATE(232),
-    [sym_index] = STATE(270),
-    [sym_index_expression] = STATE(454),
-    [sym_math] = STATE(252),
-    [sym_logic] = STATE(252),
-    [sym_assignment] = STATE(306),
-    [sym_index_assignment] = STATE(306),
-    [sym_if_else] = STATE(306),
-    [sym_if] = STATE(324),
-    [sym_match] = STATE(306),
-    [sym_while] = STATE(306),
-    [sym_for] = STATE(306),
-    [sym_return] = STATE(306),
-    [sym_function] = STATE(242),
-    [sym_function_expression] = STATE(446),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(251),
-    [sym_yield] = STATE(251),
-    [sym_built_in_function] = STATE(245),
-    [sym_built_in_value] = STATE(242),
-    [sym__identifier_pattern] = ACTIONS(165),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(167),
-    [anon_sym_async] = ACTIONS(169),
-    [anon_sym_LBRACE] = ACTIONS(171),
-    [sym_integer] = ACTIONS(173),
-    [sym_float] = ACTIONS(175),
-    [sym_string] = ACTIONS(175),
-    [anon_sym_true] = ACTIONS(177),
-    [anon_sym_false] = ACTIONS(177),
-    [anon_sym_LBRACK] = ACTIONS(179),
-    [anon_sym_none] = ACTIONS(181),
-    [anon_sym_some] = ACTIONS(183),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(185),
-    [anon_sym_for] = ACTIONS(187),
-    [anon_sym_asyncfor] = ACTIONS(189),
-    [anon_sym_return] = ACTIONS(191),
-    [anon_sym_assert] = ACTIONS(193),
-    [anon_sym_assert_equal] = ACTIONS(193),
-    [anon_sym_bash] = ACTIONS(193),
-    [anon_sym_download] = ACTIONS(193),
-    [anon_sym_either_or] = ACTIONS(193),
-    [anon_sym_fish] = ACTIONS(193),
-    [anon_sym_from_json] = ACTIONS(193),
-    [anon_sym_is_none] = ACTIONS(193),
-    [anon_sym_is_some] = ACTIONS(193),
-    [anon_sym_length] = ACTIONS(193),
-    [anon_sym_metadata] = ACTIONS(193),
-    [anon_sym_output] = ACTIONS(193),
-    [anon_sym_output_error] = ACTIONS(193),
-    [anon_sym_random] = ACTIONS(193),
-    [anon_sym_random_boolean] = ACTIONS(193),
-    [anon_sym_random_float] = ACTIONS(193),
-    [anon_sym_random_integer] = ACTIONS(193),
-    [anon_sym_read] = ACTIONS(193),
-    [anon_sym_to_json] = ACTIONS(193),
-    [anon_sym_write] = ACTIONS(193),
-    [anon_sym_std] = ACTIONS(195),
-  },
-  [36] = {
-    [sym_statement] = STATE(314),
-    [sym_expression] = STATE(296),
-    [sym__expression_kind] = STATE(252),
-    [sym_block] = STATE(309),
-    [sym_identifier] = STATE(262),
-    [sym_value] = STATE(227),
-    [sym_boolean] = STATE(232),
-    [sym_list] = STATE(232),
-    [sym_map] = STATE(232),
-    [sym_option] = STATE(232),
-    [sym_index] = STATE(270),
-    [sym_index_expression] = STATE(454),
-    [sym_math] = STATE(252),
-    [sym_logic] = STATE(252),
-    [sym_assignment] = STATE(309),
-    [sym_index_assignment] = STATE(309),
-    [sym_if_else] = STATE(309),
-    [sym_if] = STATE(324),
-    [sym_match] = STATE(309),
-    [sym_while] = STATE(309),
-    [sym_for] = STATE(309),
-    [sym_return] = STATE(309),
-    [sym_function] = STATE(242),
-    [sym_function_expression] = STATE(446),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(251),
-    [sym_yield] = STATE(251),
-    [sym_built_in_function] = STATE(245),
-    [sym_built_in_value] = STATE(242),
-    [sym__identifier_pattern] = ACTIONS(165),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(167),
-    [anon_sym_async] = ACTIONS(169),
-    [anon_sym_LBRACE] = ACTIONS(171),
-    [sym_integer] = ACTIONS(173),
-    [sym_float] = ACTIONS(175),
-    [sym_string] = ACTIONS(175),
-    [anon_sym_true] = ACTIONS(177),
-    [anon_sym_false] = ACTIONS(177),
-    [anon_sym_LBRACK] = ACTIONS(179),
-    [anon_sym_none] = ACTIONS(181),
-    [anon_sym_some] = ACTIONS(183),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(185),
-    [anon_sym_for] = ACTIONS(187),
-    [anon_sym_asyncfor] = ACTIONS(189),
-    [anon_sym_return] = ACTIONS(191),
-    [anon_sym_assert] = ACTIONS(193),
-    [anon_sym_assert_equal] = ACTIONS(193),
-    [anon_sym_bash] = ACTIONS(193),
-    [anon_sym_download] = ACTIONS(193),
-    [anon_sym_either_or] = ACTIONS(193),
-    [anon_sym_fish] = ACTIONS(193),
-    [anon_sym_from_json] = ACTIONS(193),
-    [anon_sym_is_none] = ACTIONS(193),
-    [anon_sym_is_some] = ACTIONS(193),
-    [anon_sym_length] = ACTIONS(193),
-    [anon_sym_metadata] = ACTIONS(193),
-    [anon_sym_output] = ACTIONS(193),
-    [anon_sym_output_error] = ACTIONS(193),
-    [anon_sym_random] = ACTIONS(193),
-    [anon_sym_random_boolean] = ACTIONS(193),
-    [anon_sym_random_float] = ACTIONS(193),
-    [anon_sym_random_integer] = ACTIONS(193),
-    [anon_sym_read] = ACTIONS(193),
-    [anon_sym_to_json] = ACTIONS(193),
-    [anon_sym_write] = ACTIONS(193),
-    [anon_sym_std] = ACTIONS(195),
-  },
-  [37] = {
-    [sym_statement] = STATE(307),
-    [sym_expression] = STATE(296),
-    [sym__expression_kind] = STATE(252),
-    [sym_block] = STATE(309),
-    [sym_identifier] = STATE(262),
-    [sym_value] = STATE(227),
-    [sym_boolean] = STATE(232),
-    [sym_list] = STATE(232),
-    [sym_map] = STATE(232),
-    [sym_option] = STATE(232),
-    [sym_index] = STATE(270),
-    [sym_index_expression] = STATE(454),
-    [sym_math] = STATE(252),
-    [sym_logic] = STATE(252),
-    [sym_assignment] = STATE(309),
-    [sym_index_assignment] = STATE(309),
-    [sym_if_else] = STATE(309),
-    [sym_if] = STATE(324),
-    [sym_match] = STATE(309),
-    [sym_while] = STATE(309),
-    [sym_for] = STATE(309),
-    [sym_return] = STATE(309),
-    [sym_function] = STATE(242),
-    [sym_function_expression] = STATE(446),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(251),
-    [sym_yield] = STATE(251),
-    [sym_built_in_function] = STATE(245),
-    [sym_built_in_value] = STATE(242),
-    [sym__identifier_pattern] = ACTIONS(165),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(167),
-    [anon_sym_async] = ACTIONS(169),
-    [anon_sym_LBRACE] = ACTIONS(171),
-    [sym_integer] = ACTIONS(173),
-    [sym_float] = ACTIONS(175),
-    [sym_string] = ACTIONS(175),
-    [anon_sym_true] = ACTIONS(177),
-    [anon_sym_false] = ACTIONS(177),
-    [anon_sym_LBRACK] = ACTIONS(179),
-    [anon_sym_none] = ACTIONS(181),
-    [anon_sym_some] = ACTIONS(183),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(185),
-    [anon_sym_for] = ACTIONS(187),
-    [anon_sym_asyncfor] = ACTIONS(189),
-    [anon_sym_return] = ACTIONS(191),
-    [anon_sym_assert] = ACTIONS(193),
-    [anon_sym_assert_equal] = ACTIONS(193),
-    [anon_sym_bash] = ACTIONS(193),
-    [anon_sym_download] = ACTIONS(193),
-    [anon_sym_either_or] = ACTIONS(193),
-    [anon_sym_fish] = ACTIONS(193),
-    [anon_sym_from_json] = ACTIONS(193),
-    [anon_sym_is_none] = ACTIONS(193),
-    [anon_sym_is_some] = ACTIONS(193),
-    [anon_sym_length] = ACTIONS(193),
-    [anon_sym_metadata] = ACTIONS(193),
-    [anon_sym_output] = ACTIONS(193),
-    [anon_sym_output_error] = ACTIONS(193),
-    [anon_sym_random] = ACTIONS(193),
-    [anon_sym_random_boolean] = ACTIONS(193),
-    [anon_sym_random_float] = ACTIONS(193),
-    [anon_sym_random_integer] = ACTIONS(193),
-    [anon_sym_read] = ACTIONS(193),
-    [anon_sym_to_json] = ACTIONS(193),
-    [anon_sym_write] = ACTIONS(193),
-    [anon_sym_std] = ACTIONS(195),
-  },
-  [38] = {
-    [sym_statement] = STATE(311),
-    [sym_expression] = STATE(296),
-    [sym__expression_kind] = STATE(252),
-    [sym_block] = STATE(309),
-    [sym_identifier] = STATE(262),
-    [sym_value] = STATE(227),
-    [sym_boolean] = STATE(232),
-    [sym_list] = STATE(232),
-    [sym_map] = STATE(232),
-    [sym_option] = STATE(232),
-    [sym_index] = STATE(270),
-    [sym_index_expression] = STATE(454),
-    [sym_math] = STATE(252),
-    [sym_logic] = STATE(252),
-    [sym_assignment] = STATE(309),
-    [sym_index_assignment] = STATE(309),
-    [sym_if_else] = STATE(309),
-    [sym_if] = STATE(324),
-    [sym_match] = STATE(309),
-    [sym_while] = STATE(309),
-    [sym_for] = STATE(309),
-    [sym_return] = STATE(309),
-    [sym_function] = STATE(242),
-    [sym_function_expression] = STATE(446),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(251),
-    [sym_yield] = STATE(251),
-    [sym_built_in_function] = STATE(245),
-    [sym_built_in_value] = STATE(242),
-    [sym__identifier_pattern] = ACTIONS(165),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(167),
-    [anon_sym_async] = ACTIONS(169),
-    [anon_sym_LBRACE] = ACTIONS(171),
-    [sym_integer] = ACTIONS(173),
-    [sym_float] = ACTIONS(175),
-    [sym_string] = ACTIONS(175),
-    [anon_sym_true] = ACTIONS(177),
-    [anon_sym_false] = ACTIONS(177),
-    [anon_sym_LBRACK] = ACTIONS(179),
-    [anon_sym_none] = ACTIONS(181),
-    [anon_sym_some] = ACTIONS(183),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(185),
-    [anon_sym_for] = ACTIONS(187),
-    [anon_sym_asyncfor] = ACTIONS(189),
-    [anon_sym_return] = ACTIONS(191),
-    [anon_sym_assert] = ACTIONS(193),
-    [anon_sym_assert_equal] = ACTIONS(193),
-    [anon_sym_bash] = ACTIONS(193),
-    [anon_sym_download] = ACTIONS(193),
-    [anon_sym_either_or] = ACTIONS(193),
-    [anon_sym_fish] = ACTIONS(193),
-    [anon_sym_from_json] = ACTIONS(193),
-    [anon_sym_is_none] = ACTIONS(193),
-    [anon_sym_is_some] = ACTIONS(193),
-    [anon_sym_length] = ACTIONS(193),
-    [anon_sym_metadata] = ACTIONS(193),
-    [anon_sym_output] = ACTIONS(193),
-    [anon_sym_output_error] = ACTIONS(193),
-    [anon_sym_random] = ACTIONS(193),
-    [anon_sym_random_boolean] = ACTIONS(193),
-    [anon_sym_random_float] = ACTIONS(193),
-    [anon_sym_random_integer] = ACTIONS(193),
-    [anon_sym_read] = ACTIONS(193),
-    [anon_sym_to_json] = ACTIONS(193),
-    [anon_sym_write] = ACTIONS(193),
-    [anon_sym_std] = ACTIONS(195),
-  },
-  [39] = {
-    [sym_statement] = STATE(305),
-    [sym_expression] = STATE(165),
-    [sym__expression_kind] = STATE(106),
-    [sym_block] = STATE(309),
-    [sym_identifier] = STATE(127),
-    [sym_value] = STATE(125),
-    [sym_boolean] = STATE(110),
-    [sym_list] = STATE(110),
-    [sym_map] = STATE(110),
-    [sym_option] = STATE(110),
-    [sym_index] = STATE(129),
-    [sym_index_expression] = STATE(459),
-    [sym_math] = STATE(106),
-    [sym_logic] = STATE(106),
-    [sym_assignment] = STATE(309),
-    [sym_index_assignment] = STATE(309),
-    [sym_if_else] = STATE(309),
-    [sym_if] = STATE(294),
-    [sym_match] = STATE(309),
-    [sym_while] = STATE(309),
-    [sym_for] = STATE(309),
-    [sym_return] = STATE(309),
-    [sym_function] = STATE(123),
-    [sym_function_expression] = STATE(458),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(119),
-    [sym_yield] = STATE(119),
-    [sym_built_in_function] = STATE(113),
-    [sym_built_in_value] = STATE(123),
-    [sym__identifier_pattern] = ACTIONS(129),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(131),
-    [anon_sym_async] = ACTIONS(133),
-    [anon_sym_LBRACE] = ACTIONS(135),
-    [sym_integer] = ACTIONS(137),
-    [sym_float] = ACTIONS(139),
-    [sym_string] = ACTIONS(139),
-    [anon_sym_true] = ACTIONS(141),
-    [anon_sym_false] = ACTIONS(141),
-    [anon_sym_LBRACK] = ACTIONS(143),
-    [anon_sym_none] = ACTIONS(145),
-    [anon_sym_some] = ACTIONS(147),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(153),
-    [anon_sym_for] = ACTIONS(155),
-    [anon_sym_asyncfor] = ACTIONS(157),
-    [anon_sym_return] = ACTIONS(159),
-    [anon_sym_assert] = ACTIONS(161),
-    [anon_sym_assert_equal] = ACTIONS(161),
-    [anon_sym_bash] = ACTIONS(161),
-    [anon_sym_download] = ACTIONS(161),
-    [anon_sym_either_or] = ACTIONS(161),
-    [anon_sym_fish] = ACTIONS(161),
-    [anon_sym_from_json] = ACTIONS(161),
-    [anon_sym_is_none] = ACTIONS(161),
-    [anon_sym_is_some] = ACTIONS(161),
-    [anon_sym_length] = ACTIONS(161),
-    [anon_sym_metadata] = ACTIONS(161),
-    [anon_sym_output] = ACTIONS(161),
-    [anon_sym_output_error] = ACTIONS(161),
-    [anon_sym_random] = ACTIONS(161),
-    [anon_sym_random_boolean] = ACTIONS(161),
-    [anon_sym_random_float] = ACTIONS(161),
-    [anon_sym_random_integer] = ACTIONS(161),
-    [anon_sym_read] = ACTIONS(161),
-    [anon_sym_to_json] = ACTIONS(161),
-    [anon_sym_write] = ACTIONS(161),
-    [anon_sym_std] = ACTIONS(163),
-  },
-  [40] = {
-    [sym_statement] = STATE(338),
-    [sym_expression] = STATE(297),
-    [sym__expression_kind] = STATE(252),
-    [sym_block] = STATE(306),
-    [sym_identifier] = STATE(262),
-    [sym_value] = STATE(227),
-    [sym_boolean] = STATE(232),
-    [sym_list] = STATE(232),
-    [sym_map] = STATE(232),
-    [sym_option] = STATE(232),
-    [sym_index] = STATE(270),
-    [sym_index_expression] = STATE(454),
-    [sym_math] = STATE(252),
-    [sym_logic] = STATE(252),
-    [sym_assignment] = STATE(306),
-    [sym_index_assignment] = STATE(306),
-    [sym_if_else] = STATE(306),
-    [sym_if] = STATE(324),
-    [sym_match] = STATE(306),
-    [sym_while] = STATE(306),
-    [sym_for] = STATE(306),
-    [sym_return] = STATE(306),
-    [sym_function] = STATE(242),
-    [sym_function_expression] = STATE(446),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(251),
-    [sym_yield] = STATE(251),
-    [sym_built_in_function] = STATE(245),
-    [sym_built_in_value] = STATE(242),
-    [sym__identifier_pattern] = ACTIONS(165),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(167),
-    [anon_sym_async] = ACTIONS(169),
-    [anon_sym_LBRACE] = ACTIONS(171),
-    [sym_integer] = ACTIONS(173),
-    [sym_float] = ACTIONS(175),
-    [sym_string] = ACTIONS(175),
-    [anon_sym_true] = ACTIONS(177),
-    [anon_sym_false] = ACTIONS(177),
-    [anon_sym_LBRACK] = ACTIONS(179),
-    [anon_sym_none] = ACTIONS(181),
-    [anon_sym_some] = ACTIONS(183),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(185),
-    [anon_sym_for] = ACTIONS(187),
-    [anon_sym_asyncfor] = ACTIONS(189),
-    [anon_sym_return] = ACTIONS(191),
-    [anon_sym_assert] = ACTIONS(193),
-    [anon_sym_assert_equal] = ACTIONS(193),
-    [anon_sym_bash] = ACTIONS(193),
-    [anon_sym_download] = ACTIONS(193),
-    [anon_sym_either_or] = ACTIONS(193),
-    [anon_sym_fish] = ACTIONS(193),
-    [anon_sym_from_json] = ACTIONS(193),
-    [anon_sym_is_none] = ACTIONS(193),
-    [anon_sym_is_some] = ACTIONS(193),
-    [anon_sym_length] = ACTIONS(193),
-    [anon_sym_metadata] = ACTIONS(193),
-    [anon_sym_output] = ACTIONS(193),
-    [anon_sym_output_error] = ACTIONS(193),
-    [anon_sym_random] = ACTIONS(193),
-    [anon_sym_random_boolean] = ACTIONS(193),
-    [anon_sym_random_float] = ACTIONS(193),
-    [anon_sym_random_integer] = ACTIONS(193),
-    [anon_sym_read] = ACTIONS(193),
-    [anon_sym_to_json] = ACTIONS(193),
-    [anon_sym_write] = ACTIONS(193),
-    [anon_sym_std] = ACTIONS(195),
-  },
-  [41] = {
-    [sym_statement] = STATE(282),
-    [sym_expression] = STATE(89),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(290),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(290),
-    [sym_index_assignment] = STATE(290),
-    [sym_if_else] = STATE(290),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(290),
-    [sym_while] = STATE(290),
-    [sym_for] = STATE(290),
-    [sym_return] = STATE(290),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [sym__identifier_pattern] = ACTIONS(5),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(7),
-    [anon_sym_async] = ACTIONS(9),
-    [anon_sym_LBRACE] = ACTIONS(11),
-    [sym_integer] = ACTIONS(13),
-    [sym_float] = ACTIONS(15),
-    [sym_string] = ACTIONS(15),
-    [anon_sym_true] = ACTIONS(17),
-    [anon_sym_false] = ACTIONS(17),
-    [anon_sym_LBRACK] = ACTIONS(19),
-    [anon_sym_none] = ACTIONS(21),
-    [anon_sym_some] = ACTIONS(23),
-    [anon_sym_if] = ACTIONS(25),
-    [anon_sym_match] = ACTIONS(27),
-    [anon_sym_while] = ACTIONS(29),
-    [anon_sym_for] = ACTIONS(31),
-    [anon_sym_asyncfor] = ACTIONS(33),
-    [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
-    [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
-    [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
-    [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
-    [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
-  },
-  [42] = {
-    [sym_statement] = STATE(339),
-    [sym_expression] = STATE(297),
-    [sym__expression_kind] = STATE(252),
-    [sym_block] = STATE(306),
-    [sym_identifier] = STATE(262),
-    [sym_value] = STATE(227),
-    [sym_boolean] = STATE(232),
-    [sym_list] = STATE(232),
-    [sym_map] = STATE(232),
-    [sym_option] = STATE(232),
-    [sym_index] = STATE(270),
-    [sym_index_expression] = STATE(454),
-    [sym_math] = STATE(252),
-    [sym_logic] = STATE(252),
-    [sym_assignment] = STATE(306),
-    [sym_index_assignment] = STATE(306),
-    [sym_if_else] = STATE(306),
-    [sym_if] = STATE(324),
-    [sym_match] = STATE(306),
-    [sym_while] = STATE(306),
-    [sym_for] = STATE(306),
-    [sym_return] = STATE(306),
-    [sym_function] = STATE(242),
-    [sym_function_expression] = STATE(446),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(251),
-    [sym_yield] = STATE(251),
-    [sym_built_in_function] = STATE(245),
-    [sym_built_in_value] = STATE(242),
-    [sym__identifier_pattern] = ACTIONS(165),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(167),
-    [anon_sym_async] = ACTIONS(169),
-    [anon_sym_LBRACE] = ACTIONS(171),
-    [sym_integer] = ACTIONS(173),
-    [sym_float] = ACTIONS(175),
-    [sym_string] = ACTIONS(175),
-    [anon_sym_true] = ACTIONS(177),
-    [anon_sym_false] = ACTIONS(177),
-    [anon_sym_LBRACK] = ACTIONS(179),
-    [anon_sym_none] = ACTIONS(181),
-    [anon_sym_some] = ACTIONS(183),
-    [anon_sym_if] = ACTIONS(149),
-    [anon_sym_match] = ACTIONS(151),
-    [anon_sym_while] = ACTIONS(185),
-    [anon_sym_for] = ACTIONS(187),
-    [anon_sym_asyncfor] = ACTIONS(189),
-    [anon_sym_return] = ACTIONS(191),
-    [anon_sym_assert] = ACTIONS(193),
-    [anon_sym_assert_equal] = ACTIONS(193),
-    [anon_sym_bash] = ACTIONS(193),
-    [anon_sym_download] = ACTIONS(193),
-    [anon_sym_either_or] = ACTIONS(193),
-    [anon_sym_fish] = ACTIONS(193),
-    [anon_sym_from_json] = ACTIONS(193),
-    [anon_sym_is_none] = ACTIONS(193),
-    [anon_sym_is_some] = ACTIONS(193),
-    [anon_sym_length] = ACTIONS(193),
-    [anon_sym_metadata] = ACTIONS(193),
-    [anon_sym_output] = ACTIONS(193),
-    [anon_sym_output_error] = ACTIONS(193),
-    [anon_sym_random] = ACTIONS(193),
-    [anon_sym_random_boolean] = ACTIONS(193),
-    [anon_sym_random_float] = ACTIONS(193),
-    [anon_sym_random_integer] = ACTIONS(193),
-    [anon_sym_read] = ACTIONS(193),
-    [anon_sym_to_json] = ACTIONS(193),
-    [anon_sym_write] = ACTIONS(193),
-    [anon_sym_std] = ACTIONS(195),
-  },
-  [43] = {
-    [sym_statement] = STATE(288),
-    [sym_expression] = STATE(89),
-    [sym__expression_kind] = STATE(57),
-    [sym_block] = STATE(290),
-    [sym_identifier] = STATE(52),
-    [sym_value] = STATE(63),
-    [sym_boolean] = STATE(61),
-    [sym_list] = STATE(61),
-    [sym_map] = STATE(61),
-    [sym_option] = STATE(61),
-    [sym_index] = STATE(56),
-    [sym_index_expression] = STATE(448),
-    [sym_math] = STATE(57),
-    [sym_logic] = STATE(57),
-    [sym_assignment] = STATE(290),
-    [sym_index_assignment] = STATE(290),
-    [sym_if_else] = STATE(290),
-    [sym_if] = STATE(260),
-    [sym_match] = STATE(290),
-    [sym_while] = STATE(290),
-    [sym_for] = STATE(290),
-    [sym_return] = STATE(290),
-    [sym_function] = STATE(68),
-    [sym_function_expression] = STATE(442),
-    [sym__function_expression_kind] = STATE(54),
-    [sym_function_call] = STATE(83),
-    [sym_yield] = STATE(83),
-    [sym_built_in_function] = STATE(50),
-    [sym_built_in_value] = STATE(68),
-    [sym__identifier_pattern] = ACTIONS(5),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_LPAREN] = ACTIONS(7),
-    [anon_sym_async] = ACTIONS(9),
-    [anon_sym_LBRACE] = ACTIONS(11),
-    [sym_integer] = ACTIONS(13),
-    [sym_float] = ACTIONS(15),
-    [sym_string] = ACTIONS(15),
-    [anon_sym_true] = ACTIONS(17),
-    [anon_sym_false] = ACTIONS(17),
-    [anon_sym_LBRACK] = ACTIONS(19),
-    [anon_sym_none] = ACTIONS(21),
-    [anon_sym_some] = ACTIONS(23),
-    [anon_sym_if] = ACTIONS(25),
-    [anon_sym_match] = ACTIONS(27),
-    [anon_sym_while] = ACTIONS(29),
-    [anon_sym_for] = ACTIONS(31),
-    [anon_sym_asyncfor] = ACTIONS(33),
-    [anon_sym_return] = ACTIONS(35),
-    [anon_sym_assert] = ACTIONS(37),
-    [anon_sym_assert_equal] = ACTIONS(37),
-    [anon_sym_bash] = ACTIONS(37),
-    [anon_sym_download] = ACTIONS(37),
-    [anon_sym_either_or] = ACTIONS(37),
-    [anon_sym_fish] = ACTIONS(37),
-    [anon_sym_from_json] = ACTIONS(37),
-    [anon_sym_is_none] = ACTIONS(37),
-    [anon_sym_is_some] = ACTIONS(37),
-    [anon_sym_length] = ACTIONS(37),
-    [anon_sym_metadata] = ACTIONS(37),
-    [anon_sym_output] = ACTIONS(37),
-    [anon_sym_output_error] = ACTIONS(37),
-    [anon_sym_random] = ACTIONS(37),
-    [anon_sym_random_boolean] = ACTIONS(37),
-    [anon_sym_random_float] = ACTIONS(37),
-    [anon_sym_random_integer] = ACTIONS(37),
-    [anon_sym_read] = ACTIONS(37),
-    [anon_sym_to_json] = ACTIONS(37),
-    [anon_sym_write] = ACTIONS(37),
-    [anon_sym_std] = ACTIONS(39),
-  },
-  [44] = {
-    [sym_math_operator] = STATE(172),
-    [sym_logic_operator] = STATE(166),
-    [ts_builtin_sym_end] = ACTIONS(197),
-    [sym__identifier_pattern] = ACTIONS(199),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(197),
-    [anon_sym_LPAREN] = ACTIONS(197),
-    [anon_sym_async] = ACTIONS(199),
-    [anon_sym_LBRACE] = ACTIONS(197),
-    [anon_sym_RBRACE] = ACTIONS(197),
-    [sym_integer] = ACTIONS(199),
-    [sym_float] = ACTIONS(197),
-    [sym_string] = ACTIONS(197),
-    [anon_sym_true] = ACTIONS(199),
-    [anon_sym_false] = ACTIONS(199),
-    [anon_sym_LBRACK] = ACTIONS(197),
-    [anon_sym_EQ] = ACTIONS(199),
-    [anon_sym_none] = ACTIONS(199),
-    [anon_sym_some] = ACTIONS(199),
-    [anon_sym_COLON] = ACTIONS(197),
-    [anon_sym_DOT_DOT] = ACTIONS(197),
-    [anon_sym_PLUS] = ACTIONS(199),
-    [anon_sym_DASH] = ACTIONS(199),
-    [anon_sym_STAR] = ACTIONS(197),
-    [anon_sym_SLASH] = ACTIONS(197),
-    [anon_sym_PERCENT] = ACTIONS(197),
-    [anon_sym_EQ_EQ] = ACTIONS(197),
-    [anon_sym_BANG_EQ] = ACTIONS(197),
-    [anon_sym_AMP_AMP] = ACTIONS(197),
-    [anon_sym_PIPE_PIPE] = ACTIONS(197),
-    [anon_sym_GT] = ACTIONS(199),
-    [anon_sym_LT] = ACTIONS(199),
-    [anon_sym_GT_EQ] = ACTIONS(197),
-    [anon_sym_LT_EQ] = ACTIONS(197),
-    [anon_sym_PLUS_EQ] = ACTIONS(197),
-    [anon_sym_DASH_EQ] = ACTIONS(197),
-    [anon_sym_if] = ACTIONS(199),
-    [anon_sym_match] = ACTIONS(199),
-    [anon_sym_while] = ACTIONS(199),
-    [anon_sym_for] = ACTIONS(199),
-    [anon_sym_asyncfor] = ACTIONS(197),
-    [anon_sym_return] = ACTIONS(199),
-    [anon_sym_DASH_GT] = ACTIONS(201),
-    [anon_sym_assert] = ACTIONS(199),
-    [anon_sym_assert_equal] = ACTIONS(199),
-    [anon_sym_bash] = ACTIONS(199),
-    [anon_sym_download] = ACTIONS(199),
-    [anon_sym_either_or] = ACTIONS(199),
-    [anon_sym_fish] = ACTIONS(199),
-    [anon_sym_from_json] = ACTIONS(199),
-    [anon_sym_is_none] = ACTIONS(199),
-    [anon_sym_is_some] = ACTIONS(199),
-    [anon_sym_length] = ACTIONS(199),
-    [anon_sym_metadata] = ACTIONS(199),
-    [anon_sym_output] = ACTIONS(199),
-    [anon_sym_output_error] = ACTIONS(199),
-    [anon_sym_random] = ACTIONS(199),
-    [anon_sym_random_boolean] = ACTIONS(199),
-    [anon_sym_random_float] = ACTIONS(199),
-    [anon_sym_random_integer] = ACTIONS(199),
-    [anon_sym_read] = ACTIONS(199),
-    [anon_sym_to_json] = ACTIONS(199),
-    [anon_sym_write] = ACTIONS(199),
-    [anon_sym_std] = ACTIONS(199),
-  },
-  [45] = {
-    [sym_math_operator] = STATE(172),
-    [sym_logic_operator] = STATE(166),
-    [ts_builtin_sym_end] = ACTIONS(203),
-    [sym__identifier_pattern] = ACTIONS(205),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(203),
-    [anon_sym_LPAREN] = ACTIONS(203),
-    [anon_sym_async] = ACTIONS(205),
-    [anon_sym_LBRACE] = ACTIONS(203),
-    [anon_sym_RBRACE] = ACTIONS(203),
-    [sym_integer] = ACTIONS(205),
-    [sym_float] = ACTIONS(203),
-    [sym_string] = ACTIONS(203),
-    [anon_sym_true] = ACTIONS(205),
-    [anon_sym_false] = ACTIONS(205),
-    [anon_sym_LBRACK] = ACTIONS(203),
-    [anon_sym_EQ] = ACTIONS(205),
-    [anon_sym_none] = ACTIONS(205),
-    [anon_sym_some] = ACTIONS(205),
-    [anon_sym_COLON] = ACTIONS(203),
-    [anon_sym_DOT_DOT] = ACTIONS(203),
-    [anon_sym_PLUS] = ACTIONS(205),
-    [anon_sym_DASH] = ACTIONS(205),
-    [anon_sym_STAR] = ACTIONS(203),
-    [anon_sym_SLASH] = ACTIONS(203),
-    [anon_sym_PERCENT] = ACTIONS(203),
-    [anon_sym_EQ_EQ] = ACTIONS(203),
-    [anon_sym_BANG_EQ] = ACTIONS(203),
-    [anon_sym_AMP_AMP] = ACTIONS(203),
-    [anon_sym_PIPE_PIPE] = ACTIONS(203),
-    [anon_sym_GT] = ACTIONS(205),
-    [anon_sym_LT] = ACTIONS(205),
-    [anon_sym_GT_EQ] = ACTIONS(203),
-    [anon_sym_LT_EQ] = ACTIONS(203),
-    [anon_sym_PLUS_EQ] = ACTIONS(203),
-    [anon_sym_DASH_EQ] = ACTIONS(203),
-    [anon_sym_if] = ACTIONS(205),
-    [anon_sym_match] = ACTIONS(205),
-    [anon_sym_while] = ACTIONS(205),
-    [anon_sym_for] = ACTIONS(205),
-    [anon_sym_asyncfor] = ACTIONS(203),
-    [anon_sym_return] = ACTIONS(205),
-    [anon_sym_DASH_GT] = ACTIONS(201),
-    [anon_sym_assert] = ACTIONS(205),
-    [anon_sym_assert_equal] = ACTIONS(205),
-    [anon_sym_bash] = ACTIONS(205),
-    [anon_sym_download] = ACTIONS(205),
-    [anon_sym_either_or] = ACTIONS(205),
-    [anon_sym_fish] = ACTIONS(205),
-    [anon_sym_from_json] = ACTIONS(205),
-    [anon_sym_is_none] = ACTIONS(205),
-    [anon_sym_is_some] = ACTIONS(205),
-    [anon_sym_length] = ACTIONS(205),
-    [anon_sym_metadata] = ACTIONS(205),
-    [anon_sym_output] = ACTIONS(205),
-    [anon_sym_output_error] = ACTIONS(205),
-    [anon_sym_random] = ACTIONS(205),
-    [anon_sym_random_boolean] = ACTIONS(205),
-    [anon_sym_random_float] = ACTIONS(205),
-    [anon_sym_random_integer] = ACTIONS(205),
-    [anon_sym_read] = ACTIONS(205),
-    [anon_sym_to_json] = ACTIONS(205),
-    [anon_sym_write] = ACTIONS(205),
-    [anon_sym_std] = ACTIONS(205),
-  },
-  [46] = {
-    [sym_math_operator] = STATE(172),
-    [sym_logic_operator] = STATE(166),
-    [ts_builtin_sym_end] = ACTIONS(207),
-    [sym__identifier_pattern] = ACTIONS(209),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(207),
-    [anon_sym_LPAREN] = ACTIONS(207),
-    [anon_sym_async] = ACTIONS(209),
-    [anon_sym_LBRACE] = ACTIONS(207),
-    [anon_sym_RBRACE] = ACTIONS(207),
-    [sym_integer] = ACTIONS(209),
-    [sym_float] = ACTIONS(207),
-    [sym_string] = ACTIONS(207),
-    [anon_sym_true] = ACTIONS(209),
-    [anon_sym_false] = ACTIONS(209),
-    [anon_sym_LBRACK] = ACTIONS(207),
-    [anon_sym_EQ] = ACTIONS(209),
-    [anon_sym_none] = ACTIONS(209),
-    [anon_sym_some] = ACTIONS(209),
-    [anon_sym_COLON] = ACTIONS(207),
-    [anon_sym_DOT_DOT] = ACTIONS(207),
-    [anon_sym_PLUS] = ACTIONS(209),
-    [anon_sym_DASH] = ACTIONS(209),
-    [anon_sym_STAR] = ACTIONS(207),
-    [anon_sym_SLASH] = ACTIONS(207),
-    [anon_sym_PERCENT] = ACTIONS(207),
-    [anon_sym_EQ_EQ] = ACTIONS(207),
-    [anon_sym_BANG_EQ] = ACTIONS(207),
-    [anon_sym_AMP_AMP] = ACTIONS(207),
-    [anon_sym_PIPE_PIPE] = ACTIONS(207),
-    [anon_sym_GT] = ACTIONS(209),
-    [anon_sym_LT] = ACTIONS(209),
-    [anon_sym_GT_EQ] = ACTIONS(207),
-    [anon_sym_LT_EQ] = ACTIONS(207),
-    [anon_sym_PLUS_EQ] = ACTIONS(207),
-    [anon_sym_DASH_EQ] = ACTIONS(207),
-    [anon_sym_if] = ACTIONS(209),
-    [anon_sym_match] = ACTIONS(209),
-    [anon_sym_while] = ACTIONS(209),
-    [anon_sym_for] = ACTIONS(209),
-    [anon_sym_asyncfor] = ACTIONS(207),
-    [anon_sym_return] = ACTIONS(209),
-    [anon_sym_DASH_GT] = ACTIONS(207),
-    [anon_sym_assert] = ACTIONS(209),
-    [anon_sym_assert_equal] = ACTIONS(209),
-    [anon_sym_bash] = ACTIONS(209),
-    [anon_sym_download] = ACTIONS(209),
-    [anon_sym_either_or] = ACTIONS(209),
-    [anon_sym_fish] = ACTIONS(209),
-    [anon_sym_from_json] = ACTIONS(209),
-    [anon_sym_is_none] = ACTIONS(209),
-    [anon_sym_is_some] = ACTIONS(209),
-    [anon_sym_length] = ACTIONS(209),
-    [anon_sym_metadata] = ACTIONS(209),
-    [anon_sym_output] = ACTIONS(209),
-    [anon_sym_output_error] = ACTIONS(209),
-    [anon_sym_random] = ACTIONS(209),
-    [anon_sym_random_boolean] = ACTIONS(209),
-    [anon_sym_random_float] = ACTIONS(209),
-    [anon_sym_random_integer] = ACTIONS(209),
-    [anon_sym_read] = ACTIONS(209),
-    [anon_sym_to_json] = ACTIONS(209),
-    [anon_sym_write] = ACTIONS(209),
-    [anon_sym_std] = ACTIONS(209),
-  },
-  [47] = {
-    [sym_math_operator] = STATE(211),
-    [sym_logic_operator] = STATE(210),
-    [ts_builtin_sym_end] = ACTIONS(207),
-    [sym__identifier_pattern] = ACTIONS(209),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(207),
-    [anon_sym_LPAREN] = ACTIONS(207),
-    [anon_sym_async] = ACTIONS(209),
-    [anon_sym_LBRACE] = ACTIONS(207),
-    [anon_sym_RBRACE] = ACTIONS(207),
-    [sym_integer] = ACTIONS(209),
-    [sym_float] = ACTIONS(207),
-    [sym_string] = ACTIONS(207),
-    [anon_sym_true] = ACTIONS(209),
-    [anon_sym_false] = ACTIONS(209),
-    [anon_sym_LBRACK] = ACTIONS(207),
-    [anon_sym_EQ] = ACTIONS(209),
-    [anon_sym_none] = ACTIONS(209),
-    [anon_sym_some] = ACTIONS(209),
-    [anon_sym_COLON] = ACTIONS(207),
-    [anon_sym_PLUS] = ACTIONS(209),
-    [anon_sym_DASH] = ACTIONS(209),
-    [anon_sym_STAR] = ACTIONS(207),
-    [anon_sym_SLASH] = ACTIONS(207),
-    [anon_sym_PERCENT] = ACTIONS(207),
-    [anon_sym_EQ_EQ] = ACTIONS(207),
-    [anon_sym_BANG_EQ] = ACTIONS(207),
-    [anon_sym_AMP_AMP] = ACTIONS(207),
-    [anon_sym_PIPE_PIPE] = ACTIONS(207),
-    [anon_sym_GT] = ACTIONS(209),
-    [anon_sym_LT] = ACTIONS(209),
-    [anon_sym_GT_EQ] = ACTIONS(207),
-    [anon_sym_LT_EQ] = ACTIONS(207),
-    [anon_sym_PLUS_EQ] = ACTIONS(207),
-    [anon_sym_DASH_EQ] = ACTIONS(207),
-    [anon_sym_if] = ACTIONS(209),
-    [anon_sym_match] = ACTIONS(209),
-    [anon_sym_while] = ACTIONS(209),
-    [anon_sym_for] = ACTIONS(209),
-    [anon_sym_asyncfor] = ACTIONS(207),
-    [anon_sym_return] = ACTIONS(209),
-    [anon_sym_DASH_GT] = ACTIONS(207),
-    [anon_sym_assert] = ACTIONS(209),
-    [anon_sym_assert_equal] = ACTIONS(209),
-    [anon_sym_bash] = ACTIONS(209),
-    [anon_sym_download] = ACTIONS(209),
-    [anon_sym_either_or] = ACTIONS(209),
-    [anon_sym_fish] = ACTIONS(209),
-    [anon_sym_from_json] = ACTIONS(209),
-    [anon_sym_is_none] = ACTIONS(209),
-    [anon_sym_is_some] = ACTIONS(209),
-    [anon_sym_length] = ACTIONS(209),
-    [anon_sym_metadata] = ACTIONS(209),
-    [anon_sym_output] = ACTIONS(209),
-    [anon_sym_output_error] = ACTIONS(209),
-    [anon_sym_random] = ACTIONS(209),
-    [anon_sym_random_boolean] = ACTIONS(209),
-    [anon_sym_random_float] = ACTIONS(209),
-    [anon_sym_random_integer] = ACTIONS(209),
-    [anon_sym_read] = ACTIONS(209),
-    [anon_sym_to_json] = ACTIONS(209),
-    [anon_sym_write] = ACTIONS(209),
-    [anon_sym_std] = ACTIONS(209),
-  },
-  [48] = {
-    [ts_builtin_sym_end] = ACTIONS(211),
-    [sym__identifier_pattern] = ACTIONS(213),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(211),
-    [anon_sym_LPAREN] = ACTIONS(211),
-    [anon_sym_async] = ACTIONS(213),
-    [anon_sym_LBRACE] = ACTIONS(211),
-    [anon_sym_RBRACE] = ACTIONS(211),
-    [sym_integer] = ACTIONS(213),
-    [sym_float] = ACTIONS(211),
-    [sym_string] = ACTIONS(211),
-    [anon_sym_true] = ACTIONS(213),
-    [anon_sym_false] = ACTIONS(213),
-    [anon_sym_LBRACK] = ACTIONS(211),
-    [anon_sym_EQ] = ACTIONS(213),
-    [anon_sym_none] = ACTIONS(213),
-    [anon_sym_some] = ACTIONS(213),
-    [anon_sym_COLON] = ACTIONS(211),
-    [anon_sym_DOT_DOT] = ACTIONS(211),
-    [anon_sym_PLUS] = ACTIONS(213),
-    [anon_sym_DASH] = ACTIONS(213),
-    [anon_sym_STAR] = ACTIONS(211),
-    [anon_sym_SLASH] = ACTIONS(211),
-    [anon_sym_PERCENT] = ACTIONS(211),
-    [anon_sym_EQ_EQ] = ACTIONS(211),
-    [anon_sym_BANG_EQ] = ACTIONS(211),
-    [anon_sym_AMP_AMP] = ACTIONS(211),
-    [anon_sym_PIPE_PIPE] = ACTIONS(211),
-    [anon_sym_GT] = ACTIONS(213),
-    [anon_sym_LT] = ACTIONS(213),
-    [anon_sym_GT_EQ] = ACTIONS(211),
-    [anon_sym_LT_EQ] = ACTIONS(211),
-    [anon_sym_PLUS_EQ] = ACTIONS(211),
-    [anon_sym_DASH_EQ] = ACTIONS(211),
-    [anon_sym_if] = ACTIONS(213),
-    [anon_sym_match] = ACTIONS(213),
-    [anon_sym_while] = ACTIONS(213),
-    [anon_sym_for] = ACTIONS(213),
-    [anon_sym_asyncfor] = ACTIONS(211),
-    [anon_sym_in] = ACTIONS(213),
-    [anon_sym_return] = ACTIONS(213),
-    [anon_sym_DASH_GT] = ACTIONS(211),
-    [anon_sym_assert] = ACTIONS(213),
-    [anon_sym_assert_equal] = ACTIONS(213),
-    [anon_sym_bash] = ACTIONS(213),
-    [anon_sym_download] = ACTIONS(213),
-    [anon_sym_either_or] = ACTIONS(213),
-    [anon_sym_fish] = ACTIONS(213),
-    [anon_sym_from_json] = ACTIONS(213),
-    [anon_sym_is_none] = ACTIONS(213),
-    [anon_sym_is_some] = ACTIONS(213),
-    [anon_sym_length] = ACTIONS(213),
-    [anon_sym_metadata] = ACTIONS(213),
-    [anon_sym_output] = ACTIONS(213),
-    [anon_sym_output_error] = ACTIONS(213),
-    [anon_sym_random] = ACTIONS(213),
-    [anon_sym_random_boolean] = ACTIONS(213),
-    [anon_sym_random_float] = ACTIONS(213),
-    [anon_sym_random_integer] = ACTIONS(213),
-    [anon_sym_read] = ACTIONS(213),
-    [anon_sym_to_json] = ACTIONS(213),
-    [anon_sym_write] = ACTIONS(213),
-    [anon_sym_std] = ACTIONS(213),
-  },
-  [49] = {
-    [sym_math_operator] = STATE(211),
-    [sym_logic_operator] = STATE(210),
-    [ts_builtin_sym_end] = ACTIONS(197),
-    [sym__identifier_pattern] = ACTIONS(199),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(197),
-    [anon_sym_LPAREN] = ACTIONS(197),
-    [anon_sym_async] = ACTIONS(199),
-    [anon_sym_LBRACE] = ACTIONS(197),
-    [anon_sym_RBRACE] = ACTIONS(197),
-    [sym_integer] = ACTIONS(199),
-    [sym_float] = ACTIONS(197),
-    [sym_string] = ACTIONS(197),
-    [anon_sym_true] = ACTIONS(199),
-    [anon_sym_false] = ACTIONS(199),
-    [anon_sym_LBRACK] = ACTIONS(197),
-    [anon_sym_EQ] = ACTIONS(199),
-    [anon_sym_none] = ACTIONS(199),
-    [anon_sym_some] = ACTIONS(199),
-    [anon_sym_COLON] = ACTIONS(197),
-    [anon_sym_PLUS] = ACTIONS(199),
-    [anon_sym_DASH] = ACTIONS(199),
-    [anon_sym_STAR] = ACTIONS(197),
-    [anon_sym_SLASH] = ACTIONS(197),
-    [anon_sym_PERCENT] = ACTIONS(197),
-    [anon_sym_EQ_EQ] = ACTIONS(197),
-    [anon_sym_BANG_EQ] = ACTIONS(197),
-    [anon_sym_AMP_AMP] = ACTIONS(197),
-    [anon_sym_PIPE_PIPE] = ACTIONS(197),
-    [anon_sym_GT] = ACTIONS(199),
-    [anon_sym_LT] = ACTIONS(199),
-    [anon_sym_GT_EQ] = ACTIONS(197),
-    [anon_sym_LT_EQ] = ACTIONS(197),
-    [anon_sym_PLUS_EQ] = ACTIONS(197),
-    [anon_sym_DASH_EQ] = ACTIONS(197),
-    [anon_sym_if] = ACTIONS(199),
-    [anon_sym_match] = ACTIONS(199),
-    [anon_sym_while] = ACTIONS(199),
-    [anon_sym_for] = ACTIONS(199),
-    [anon_sym_asyncfor] = ACTIONS(197),
-    [anon_sym_return] = ACTIONS(199),
-    [anon_sym_DASH_GT] = ACTIONS(215),
-    [anon_sym_assert] = ACTIONS(199),
-    [anon_sym_assert_equal] = ACTIONS(199),
-    [anon_sym_bash] = ACTIONS(199),
-    [anon_sym_download] = ACTIONS(199),
-    [anon_sym_either_or] = ACTIONS(199),
-    [anon_sym_fish] = ACTIONS(199),
-    [anon_sym_from_json] = ACTIONS(199),
-    [anon_sym_is_none] = ACTIONS(199),
-    [anon_sym_is_some] = ACTIONS(199),
-    [anon_sym_length] = ACTIONS(199),
-    [anon_sym_metadata] = ACTIONS(199),
-    [anon_sym_output] = ACTIONS(199),
-    [anon_sym_output_error] = ACTIONS(199),
-    [anon_sym_random] = ACTIONS(199),
-    [anon_sym_random_boolean] = ACTIONS(199),
-    [anon_sym_random_float] = ACTIONS(199),
-    [anon_sym_random_integer] = ACTIONS(199),
-    [anon_sym_read] = ACTIONS(199),
-    [anon_sym_to_json] = ACTIONS(199),
-    [anon_sym_write] = ACTIONS(199),
-    [anon_sym_std] = ACTIONS(199),
-  },
-  [50] = {
-    [ts_builtin_sym_end] = ACTIONS(217),
-    [sym__identifier_pattern] = ACTIONS(219),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(217),
-    [anon_sym_LPAREN] = ACTIONS(217),
-    [anon_sym_async] = ACTIONS(219),
-    [anon_sym_LBRACE] = ACTIONS(217),
-    [anon_sym_RBRACE] = ACTIONS(217),
-    [sym_integer] = ACTIONS(219),
-    [sym_float] = ACTIONS(217),
-    [sym_string] = ACTIONS(217),
-    [anon_sym_true] = ACTIONS(219),
-    [anon_sym_false] = ACTIONS(219),
-    [anon_sym_LBRACK] = ACTIONS(217),
-    [anon_sym_EQ] = ACTIONS(219),
-    [anon_sym_none] = ACTIONS(219),
-    [anon_sym_some] = ACTIONS(219),
-    [anon_sym_COLON] = ACTIONS(217),
-    [anon_sym_DOT_DOT] = ACTIONS(217),
-    [anon_sym_PLUS] = ACTIONS(219),
-    [anon_sym_DASH] = ACTIONS(219),
-    [anon_sym_STAR] = ACTIONS(217),
-    [anon_sym_SLASH] = ACTIONS(217),
-    [anon_sym_PERCENT] = ACTIONS(217),
-    [anon_sym_EQ_EQ] = ACTIONS(217),
-    [anon_sym_BANG_EQ] = ACTIONS(217),
-    [anon_sym_AMP_AMP] = ACTIONS(217),
-    [anon_sym_PIPE_PIPE] = ACTIONS(217),
-    [anon_sym_GT] = ACTIONS(219),
-    [anon_sym_LT] = ACTIONS(219),
-    [anon_sym_GT_EQ] = ACTIONS(217),
-    [anon_sym_LT_EQ] = ACTIONS(217),
-    [anon_sym_PLUS_EQ] = ACTIONS(217),
-    [anon_sym_DASH_EQ] = ACTIONS(217),
-    [anon_sym_if] = ACTIONS(219),
-    [anon_sym_match] = ACTIONS(219),
-    [anon_sym_while] = ACTIONS(219),
-    [anon_sym_for] = ACTIONS(219),
-    [anon_sym_asyncfor] = ACTIONS(217),
-    [anon_sym_in] = ACTIONS(219),
-    [anon_sym_return] = ACTIONS(219),
-    [anon_sym_DASH_GT] = ACTIONS(217),
-    [anon_sym_assert] = ACTIONS(219),
-    [anon_sym_assert_equal] = ACTIONS(219),
-    [anon_sym_bash] = ACTIONS(219),
-    [anon_sym_download] = ACTIONS(219),
-    [anon_sym_either_or] = ACTIONS(219),
-    [anon_sym_fish] = ACTIONS(219),
-    [anon_sym_from_json] = ACTIONS(219),
-    [anon_sym_is_none] = ACTIONS(219),
-    [anon_sym_is_some] = ACTIONS(219),
-    [anon_sym_length] = ACTIONS(219),
-    [anon_sym_metadata] = ACTIONS(219),
-    [anon_sym_output] = ACTIONS(219),
-    [anon_sym_output_error] = ACTIONS(219),
-    [anon_sym_random] = ACTIONS(219),
-    [anon_sym_random_boolean] = ACTIONS(219),
-    [anon_sym_random_float] = ACTIONS(219),
-    [anon_sym_random_integer] = ACTIONS(219),
-    [anon_sym_read] = ACTIONS(219),
-    [anon_sym_to_json] = ACTIONS(219),
-    [anon_sym_write] = ACTIONS(219),
-    [anon_sym_std] = ACTIONS(219),
-  },
-  [51] = {
-    [sym_math_operator] = STATE(211),
-    [sym_logic_operator] = STATE(210),
-    [ts_builtin_sym_end] = ACTIONS(203),
-    [sym__identifier_pattern] = ACTIONS(205),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(203),
-    [anon_sym_LPAREN] = ACTIONS(203),
-    [anon_sym_async] = ACTIONS(205),
-    [anon_sym_LBRACE] = ACTIONS(203),
-    [anon_sym_RBRACE] = ACTIONS(203),
-    [sym_integer] = ACTIONS(205),
-    [sym_float] = ACTIONS(203),
-    [sym_string] = ACTIONS(203),
-    [anon_sym_true] = ACTIONS(205),
-    [anon_sym_false] = ACTIONS(205),
-    [anon_sym_LBRACK] = ACTIONS(203),
-    [anon_sym_EQ] = ACTIONS(205),
-    [anon_sym_none] = ACTIONS(205),
-    [anon_sym_some] = ACTIONS(205),
-    [anon_sym_COLON] = ACTIONS(203),
-    [anon_sym_PLUS] = ACTIONS(205),
-    [anon_sym_DASH] = ACTIONS(205),
-    [anon_sym_STAR] = ACTIONS(203),
-    [anon_sym_SLASH] = ACTIONS(203),
-    [anon_sym_PERCENT] = ACTIONS(203),
-    [anon_sym_EQ_EQ] = ACTIONS(203),
-    [anon_sym_BANG_EQ] = ACTIONS(203),
-    [anon_sym_AMP_AMP] = ACTIONS(203),
-    [anon_sym_PIPE_PIPE] = ACTIONS(203),
-    [anon_sym_GT] = ACTIONS(205),
-    [anon_sym_LT] = ACTIONS(205),
-    [anon_sym_GT_EQ] = ACTIONS(203),
-    [anon_sym_LT_EQ] = ACTIONS(203),
-    [anon_sym_PLUS_EQ] = ACTIONS(203),
-    [anon_sym_DASH_EQ] = ACTIONS(203),
-    [anon_sym_if] = ACTIONS(205),
-    [anon_sym_match] = ACTIONS(205),
-    [anon_sym_while] = ACTIONS(205),
-    [anon_sym_for] = ACTIONS(205),
-    [anon_sym_asyncfor] = ACTIONS(203),
-    [anon_sym_return] = ACTIONS(205),
-    [anon_sym_DASH_GT] = ACTIONS(215),
-    [anon_sym_assert] = ACTIONS(205),
-    [anon_sym_assert_equal] = ACTIONS(205),
-    [anon_sym_bash] = ACTIONS(205),
-    [anon_sym_download] = ACTIONS(205),
-    [anon_sym_either_or] = ACTIONS(205),
-    [anon_sym_fish] = ACTIONS(205),
-    [anon_sym_from_json] = ACTIONS(205),
-    [anon_sym_is_none] = ACTIONS(205),
-    [anon_sym_is_some] = ACTIONS(205),
-    [anon_sym_length] = ACTIONS(205),
-    [anon_sym_metadata] = ACTIONS(205),
-    [anon_sym_output] = ACTIONS(205),
-    [anon_sym_output_error] = ACTIONS(205),
-    [anon_sym_random] = ACTIONS(205),
-    [anon_sym_random_boolean] = ACTIONS(205),
-    [anon_sym_random_float] = ACTIONS(205),
-    [anon_sym_random_integer] = ACTIONS(205),
-    [anon_sym_read] = ACTIONS(205),
-    [anon_sym_to_json] = ACTIONS(205),
-    [anon_sym_write] = ACTIONS(205),
-    [anon_sym_std] = ACTIONS(205),
-  },
-  [52] = {
-    [sym_assignment_operator] = STATE(41),
-    [sym_type_definition] = STATE(410),
-    [ts_builtin_sym_end] = ACTIONS(221),
-    [sym__identifier_pattern] = ACTIONS(223),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(221),
-    [anon_sym_LPAREN] = ACTIONS(225),
-    [anon_sym_async] = ACTIONS(223),
-    [anon_sym_LBRACE] = ACTIONS(221),
-    [anon_sym_RBRACE] = ACTIONS(221),
-    [sym_integer] = ACTIONS(223),
-    [sym_float] = ACTIONS(221),
-    [sym_string] = ACTIONS(221),
-    [anon_sym_true] = ACTIONS(223),
-    [anon_sym_false] = ACTIONS(223),
-    [anon_sym_LBRACK] = ACTIONS(221),
-    [anon_sym_EQ] = ACTIONS(227),
-    [anon_sym_none] = ACTIONS(223),
-    [anon_sym_some] = ACTIONS(223),
-    [anon_sym_COLON] = ACTIONS(229),
-    [anon_sym_PLUS] = ACTIONS(223),
-    [anon_sym_DASH] = ACTIONS(223),
-    [anon_sym_STAR] = ACTIONS(221),
-    [anon_sym_SLASH] = ACTIONS(221),
-    [anon_sym_PERCENT] = ACTIONS(221),
-    [anon_sym_EQ_EQ] = ACTIONS(221),
-    [anon_sym_BANG_EQ] = ACTIONS(221),
-    [anon_sym_AMP_AMP] = ACTIONS(221),
-    [anon_sym_PIPE_PIPE] = ACTIONS(221),
-    [anon_sym_GT] = ACTIONS(223),
-    [anon_sym_LT] = ACTIONS(231),
-    [anon_sym_GT_EQ] = ACTIONS(221),
-    [anon_sym_LT_EQ] = ACTIONS(221),
-    [anon_sym_PLUS_EQ] = ACTIONS(233),
-    [anon_sym_DASH_EQ] = ACTIONS(233),
-    [anon_sym_if] = ACTIONS(223),
-    [anon_sym_match] = ACTIONS(223),
-    [anon_sym_while] = ACTIONS(223),
-    [anon_sym_for] = ACTIONS(223),
-    [anon_sym_asyncfor] = ACTIONS(221),
-    [anon_sym_return] = ACTIONS(223),
-    [anon_sym_DASH_GT] = ACTIONS(221),
-    [anon_sym_assert] = ACTIONS(223),
-    [anon_sym_assert_equal] = ACTIONS(223),
-    [anon_sym_bash] = ACTIONS(223),
-    [anon_sym_download] = ACTIONS(223),
-    [anon_sym_either_or] = ACTIONS(223),
-    [anon_sym_fish] = ACTIONS(223),
-    [anon_sym_from_json] = ACTIONS(223),
-    [anon_sym_is_none] = ACTIONS(223),
-    [anon_sym_is_some] = ACTIONS(223),
-    [anon_sym_length] = ACTIONS(223),
-    [anon_sym_metadata] = ACTIONS(223),
-    [anon_sym_output] = ACTIONS(223),
-    [anon_sym_output_error] = ACTIONS(223),
-    [anon_sym_random] = ACTIONS(223),
-    [anon_sym_random_boolean] = ACTIONS(223),
-    [anon_sym_random_float] = ACTIONS(223),
-    [anon_sym_random_integer] = ACTIONS(223),
-    [anon_sym_read] = ACTIONS(223),
-    [anon_sym_to_json] = ACTIONS(223),
-    [anon_sym_write] = ACTIONS(223),
-    [anon_sym_std] = ACTIONS(223),
-  },
-  [53] = {
-    [ts_builtin_sym_end] = ACTIONS(235),
-    [sym__identifier_pattern] = ACTIONS(237),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(235),
-    [anon_sym_LPAREN] = ACTIONS(235),
-    [anon_sym_async] = ACTIONS(237),
-    [anon_sym_LBRACE] = ACTIONS(235),
-    [anon_sym_RBRACE] = ACTIONS(235),
-    [sym_integer] = ACTIONS(237),
-    [sym_float] = ACTIONS(235),
-    [sym_string] = ACTIONS(235),
-    [anon_sym_true] = ACTIONS(237),
-    [anon_sym_false] = ACTIONS(237),
-    [anon_sym_LBRACK] = ACTIONS(235),
-    [anon_sym_EQ] = ACTIONS(237),
-    [anon_sym_none] = ACTIONS(237),
-    [anon_sym_some] = ACTIONS(237),
-    [anon_sym_COLON] = ACTIONS(235),
-    [anon_sym_DOT_DOT] = ACTIONS(235),
-    [anon_sym_PLUS] = ACTIONS(237),
-    [anon_sym_DASH] = ACTIONS(237),
-    [anon_sym_STAR] = ACTIONS(235),
-    [anon_sym_SLASH] = ACTIONS(235),
-    [anon_sym_PERCENT] = ACTIONS(235),
-    [anon_sym_EQ_EQ] = ACTIONS(235),
-    [anon_sym_BANG_EQ] = ACTIONS(235),
-    [anon_sym_AMP_AMP] = ACTIONS(235),
-    [anon_sym_PIPE_PIPE] = ACTIONS(235),
-    [anon_sym_GT] = ACTIONS(237),
-    [anon_sym_LT] = ACTIONS(237),
-    [anon_sym_GT_EQ] = ACTIONS(235),
-    [anon_sym_LT_EQ] = ACTIONS(235),
-    [anon_sym_PLUS_EQ] = ACTIONS(235),
-    [anon_sym_DASH_EQ] = ACTIONS(235),
-    [anon_sym_if] = ACTIONS(237),
-    [anon_sym_match] = ACTIONS(237),
-    [anon_sym_while] = ACTIONS(237),
-    [anon_sym_for] = ACTIONS(237),
-    [anon_sym_asyncfor] = ACTIONS(235),
-    [anon_sym_return] = ACTIONS(237),
-    [anon_sym_DASH_GT] = ACTIONS(235),
-    [anon_sym_assert] = ACTIONS(237),
-    [anon_sym_assert_equal] = ACTIONS(237),
-    [anon_sym_bash] = ACTIONS(237),
-    [anon_sym_download] = ACTIONS(237),
-    [anon_sym_either_or] = ACTIONS(237),
-    [anon_sym_fish] = ACTIONS(237),
-    [anon_sym_from_json] = ACTIONS(237),
-    [anon_sym_is_none] = ACTIONS(237),
-    [anon_sym_is_some] = ACTIONS(237),
-    [anon_sym_length] = ACTIONS(237),
-    [anon_sym_metadata] = ACTIONS(237),
-    [anon_sym_output] = ACTIONS(237),
-    [anon_sym_output_error] = ACTIONS(237),
-    [anon_sym_random] = ACTIONS(237),
-    [anon_sym_random_boolean] = ACTIONS(237),
-    [anon_sym_random_float] = ACTIONS(237),
-    [anon_sym_random_integer] = ACTIONS(237),
-    [anon_sym_read] = ACTIONS(237),
-    [anon_sym_to_json] = ACTIONS(237),
-    [anon_sym_write] = ACTIONS(237),
-    [anon_sym_std] = ACTIONS(237),
-  },
-  [54] = {
-    [ts_builtin_sym_end] = ACTIONS(239),
-    [sym__identifier_pattern] = ACTIONS(241),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(239),
-    [anon_sym_LPAREN] = ACTIONS(239),
-    [anon_sym_async] = ACTIONS(241),
-    [anon_sym_LBRACE] = ACTIONS(239),
-    [anon_sym_RBRACE] = ACTIONS(239),
-    [sym_integer] = ACTIONS(241),
-    [sym_float] = ACTIONS(239),
-    [sym_string] = ACTIONS(239),
-    [anon_sym_true] = ACTIONS(241),
-    [anon_sym_false] = ACTIONS(241),
-    [anon_sym_LBRACK] = ACTIONS(239),
-    [anon_sym_EQ] = ACTIONS(241),
-    [anon_sym_none] = ACTIONS(241),
-    [anon_sym_some] = ACTIONS(241),
-    [anon_sym_COLON] = ACTIONS(239),
-    [anon_sym_DOT_DOT] = ACTIONS(239),
-    [anon_sym_PLUS] = ACTIONS(241),
-    [anon_sym_DASH] = ACTIONS(241),
-    [anon_sym_STAR] = ACTIONS(239),
-    [anon_sym_SLASH] = ACTIONS(239),
-    [anon_sym_PERCENT] = ACTIONS(239),
-    [anon_sym_EQ_EQ] = ACTIONS(239),
-    [anon_sym_BANG_EQ] = ACTIONS(239),
-    [anon_sym_AMP_AMP] = ACTIONS(239),
-    [anon_sym_PIPE_PIPE] = ACTIONS(239),
-    [anon_sym_GT] = ACTIONS(241),
-    [anon_sym_LT] = ACTIONS(241),
-    [anon_sym_GT_EQ] = ACTIONS(239),
-    [anon_sym_LT_EQ] = ACTIONS(239),
-    [anon_sym_PLUS_EQ] = ACTIONS(239),
-    [anon_sym_DASH_EQ] = ACTIONS(239),
-    [anon_sym_if] = ACTIONS(241),
-    [anon_sym_match] = ACTIONS(241),
-    [anon_sym_while] = ACTIONS(241),
-    [anon_sym_for] = ACTIONS(241),
-    [anon_sym_asyncfor] = ACTIONS(239),
-    [anon_sym_return] = ACTIONS(241),
-    [anon_sym_DASH_GT] = ACTIONS(239),
-    [anon_sym_assert] = ACTIONS(241),
-    [anon_sym_assert_equal] = ACTIONS(241),
-    [anon_sym_bash] = ACTIONS(241),
-    [anon_sym_download] = ACTIONS(241),
-    [anon_sym_either_or] = ACTIONS(241),
-    [anon_sym_fish] = ACTIONS(241),
-    [anon_sym_from_json] = ACTIONS(241),
-    [anon_sym_is_none] = ACTIONS(241),
-    [anon_sym_is_some] = ACTIONS(241),
-    [anon_sym_length] = ACTIONS(241),
-    [anon_sym_metadata] = ACTIONS(241),
-    [anon_sym_output] = ACTIONS(241),
-    [anon_sym_output_error] = ACTIONS(241),
-    [anon_sym_random] = ACTIONS(241),
-    [anon_sym_random_boolean] = ACTIONS(241),
-    [anon_sym_random_float] = ACTIONS(241),
-    [anon_sym_random_integer] = ACTIONS(241),
-    [anon_sym_read] = ACTIONS(241),
-    [anon_sym_to_json] = ACTIONS(241),
-    [anon_sym_write] = ACTIONS(241),
-    [anon_sym_std] = ACTIONS(241),
-  },
-  [55] = {
-    [ts_builtin_sym_end] = ACTIONS(243),
-    [sym__identifier_pattern] = ACTIONS(245),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(243),
-    [anon_sym_LPAREN] = ACTIONS(243),
-    [anon_sym_async] = ACTIONS(245),
-    [anon_sym_LBRACE] = ACTIONS(243),
-    [anon_sym_RBRACE] = ACTIONS(243),
-    [sym_integer] = ACTIONS(245),
-    [sym_float] = ACTIONS(243),
-    [sym_string] = ACTIONS(243),
-    [anon_sym_true] = ACTIONS(245),
-    [anon_sym_false] = ACTIONS(245),
-    [anon_sym_LBRACK] = ACTIONS(243),
-    [anon_sym_EQ] = ACTIONS(245),
-    [anon_sym_none] = ACTIONS(245),
-    [anon_sym_some] = ACTIONS(245),
-    [anon_sym_COLON] = ACTIONS(243),
-    [anon_sym_DOT_DOT] = ACTIONS(243),
-    [anon_sym_PLUS] = ACTIONS(245),
-    [anon_sym_DASH] = ACTIONS(245),
-    [anon_sym_STAR] = ACTIONS(243),
-    [anon_sym_SLASH] = ACTIONS(243),
-    [anon_sym_PERCENT] = ACTIONS(243),
-    [anon_sym_EQ_EQ] = ACTIONS(243),
-    [anon_sym_BANG_EQ] = ACTIONS(243),
-    [anon_sym_AMP_AMP] = ACTIONS(243),
-    [anon_sym_PIPE_PIPE] = ACTIONS(243),
-    [anon_sym_GT] = ACTIONS(245),
-    [anon_sym_LT] = ACTIONS(245),
-    [anon_sym_GT_EQ] = ACTIONS(243),
-    [anon_sym_LT_EQ] = ACTIONS(243),
-    [anon_sym_PLUS_EQ] = ACTIONS(243),
-    [anon_sym_DASH_EQ] = ACTIONS(243),
-    [anon_sym_if] = ACTIONS(245),
-    [anon_sym_match] = ACTIONS(245),
-    [anon_sym_while] = ACTIONS(245),
-    [anon_sym_for] = ACTIONS(245),
-    [anon_sym_asyncfor] = ACTIONS(243),
-    [anon_sym_return] = ACTIONS(245),
-    [anon_sym_DASH_GT] = ACTIONS(243),
-    [anon_sym_assert] = ACTIONS(245),
-    [anon_sym_assert_equal] = ACTIONS(245),
-    [anon_sym_bash] = ACTIONS(245),
-    [anon_sym_download] = ACTIONS(245),
-    [anon_sym_either_or] = ACTIONS(245),
-    [anon_sym_fish] = ACTIONS(245),
-    [anon_sym_from_json] = ACTIONS(245),
-    [anon_sym_is_none] = ACTIONS(245),
-    [anon_sym_is_some] = ACTIONS(245),
-    [anon_sym_length] = ACTIONS(245),
-    [anon_sym_metadata] = ACTIONS(245),
-    [anon_sym_output] = ACTIONS(245),
-    [anon_sym_output_error] = ACTIONS(245),
-    [anon_sym_random] = ACTIONS(245),
-    [anon_sym_random_boolean] = ACTIONS(245),
-    [anon_sym_random_float] = ACTIONS(245),
-    [anon_sym_random_integer] = ACTIONS(245),
-    [anon_sym_read] = ACTIONS(245),
-    [anon_sym_to_json] = ACTIONS(245),
-    [anon_sym_write] = ACTIONS(245),
-    [anon_sym_std] = ACTIONS(245),
-  },
-  [56] = {
-    [sym_assignment_operator] = STATE(43),
-    [ts_builtin_sym_end] = ACTIONS(221),
-    [sym__identifier_pattern] = ACTIONS(223),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(221),
-    [anon_sym_LPAREN] = ACTIONS(225),
-    [anon_sym_async] = ACTIONS(223),
-    [anon_sym_LBRACE] = ACTIONS(221),
-    [anon_sym_RBRACE] = ACTIONS(221),
-    [sym_integer] = ACTIONS(223),
-    [sym_float] = ACTIONS(221),
-    [sym_string] = ACTIONS(221),
-    [anon_sym_true] = ACTIONS(223),
-    [anon_sym_false] = ACTIONS(223),
-    [anon_sym_LBRACK] = ACTIONS(221),
-    [anon_sym_EQ] = ACTIONS(227),
-    [anon_sym_none] = ACTIONS(223),
-    [anon_sym_some] = ACTIONS(223),
-    [anon_sym_COLON] = ACTIONS(229),
-    [anon_sym_PLUS] = ACTIONS(223),
-    [anon_sym_DASH] = ACTIONS(223),
-    [anon_sym_STAR] = ACTIONS(221),
-    [anon_sym_SLASH] = ACTIONS(221),
-    [anon_sym_PERCENT] = ACTIONS(221),
-    [anon_sym_EQ_EQ] = ACTIONS(221),
-    [anon_sym_BANG_EQ] = ACTIONS(221),
-    [anon_sym_AMP_AMP] = ACTIONS(221),
-    [anon_sym_PIPE_PIPE] = ACTIONS(221),
-    [anon_sym_GT] = ACTIONS(223),
-    [anon_sym_LT] = ACTIONS(223),
-    [anon_sym_GT_EQ] = ACTIONS(221),
-    [anon_sym_LT_EQ] = ACTIONS(221),
-    [anon_sym_PLUS_EQ] = ACTIONS(233),
-    [anon_sym_DASH_EQ] = ACTIONS(233),
-    [anon_sym_if] = ACTIONS(223),
-    [anon_sym_match] = ACTIONS(223),
-    [anon_sym_while] = ACTIONS(223),
-    [anon_sym_for] = ACTIONS(223),
-    [anon_sym_asyncfor] = ACTIONS(221),
-    [anon_sym_return] = ACTIONS(223),
-    [anon_sym_DASH_GT] = ACTIONS(221),
-    [anon_sym_assert] = ACTIONS(223),
-    [anon_sym_assert_equal] = ACTIONS(223),
-    [anon_sym_bash] = ACTIONS(223),
-    [anon_sym_download] = ACTIONS(223),
-    [anon_sym_either_or] = ACTIONS(223),
-    [anon_sym_fish] = ACTIONS(223),
-    [anon_sym_from_json] = ACTIONS(223),
-    [anon_sym_is_none] = ACTIONS(223),
-    [anon_sym_is_some] = ACTIONS(223),
-    [anon_sym_length] = ACTIONS(223),
-    [anon_sym_metadata] = ACTIONS(223),
-    [anon_sym_output] = ACTIONS(223),
-    [anon_sym_output_error] = ACTIONS(223),
-    [anon_sym_random] = ACTIONS(223),
-    [anon_sym_random_boolean] = ACTIONS(223),
-    [anon_sym_random_float] = ACTIONS(223),
-    [anon_sym_random_integer] = ACTIONS(223),
-    [anon_sym_read] = ACTIONS(223),
-    [anon_sym_to_json] = ACTIONS(223),
-    [anon_sym_write] = ACTIONS(223),
-    [anon_sym_std] = ACTIONS(223),
-  },
-  [57] = {
-    [ts_builtin_sym_end] = ACTIONS(247),
-    [sym__identifier_pattern] = ACTIONS(249),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(247),
-    [anon_sym_LPAREN] = ACTIONS(247),
-    [anon_sym_async] = ACTIONS(249),
-    [anon_sym_LBRACE] = ACTIONS(247),
-    [anon_sym_RBRACE] = ACTIONS(247),
-    [sym_integer] = ACTIONS(249),
-    [sym_float] = ACTIONS(247),
-    [sym_string] = ACTIONS(247),
-    [anon_sym_true] = ACTIONS(249),
-    [anon_sym_false] = ACTIONS(249),
-    [anon_sym_LBRACK] = ACTIONS(247),
-    [anon_sym_EQ] = ACTIONS(249),
-    [anon_sym_none] = ACTIONS(249),
-    [anon_sym_some] = ACTIONS(249),
-    [anon_sym_COLON] = ACTIONS(247),
-    [anon_sym_DOT_DOT] = ACTIONS(247),
-    [anon_sym_PLUS] = ACTIONS(249),
-    [anon_sym_DASH] = ACTIONS(249),
-    [anon_sym_STAR] = ACTIONS(247),
-    [anon_sym_SLASH] = ACTIONS(247),
-    [anon_sym_PERCENT] = ACTIONS(247),
-    [anon_sym_EQ_EQ] = ACTIONS(247),
-    [anon_sym_BANG_EQ] = ACTIONS(247),
-    [anon_sym_AMP_AMP] = ACTIONS(247),
-    [anon_sym_PIPE_PIPE] = ACTIONS(247),
-    [anon_sym_GT] = ACTIONS(249),
-    [anon_sym_LT] = ACTIONS(249),
-    [anon_sym_GT_EQ] = ACTIONS(247),
-    [anon_sym_LT_EQ] = ACTIONS(247),
-    [anon_sym_PLUS_EQ] = ACTIONS(247),
-    [anon_sym_DASH_EQ] = ACTIONS(247),
-    [anon_sym_if] = ACTIONS(249),
-    [anon_sym_match] = ACTIONS(249),
-    [anon_sym_while] = ACTIONS(249),
-    [anon_sym_for] = ACTIONS(249),
-    [anon_sym_asyncfor] = ACTIONS(247),
-    [anon_sym_return] = ACTIONS(249),
-    [anon_sym_DASH_GT] = ACTIONS(247),
-    [anon_sym_assert] = ACTIONS(249),
-    [anon_sym_assert_equal] = ACTIONS(249),
-    [anon_sym_bash] = ACTIONS(249),
-    [anon_sym_download] = ACTIONS(249),
-    [anon_sym_either_or] = ACTIONS(249),
-    [anon_sym_fish] = ACTIONS(249),
-    [anon_sym_from_json] = ACTIONS(249),
-    [anon_sym_is_none] = ACTIONS(249),
-    [anon_sym_is_some] = ACTIONS(249),
-    [anon_sym_length] = ACTIONS(249),
-    [anon_sym_metadata] = ACTIONS(249),
-    [anon_sym_output] = ACTIONS(249),
-    [anon_sym_output_error] = ACTIONS(249),
-    [anon_sym_random] = ACTIONS(249),
-    [anon_sym_random_boolean] = ACTIONS(249),
-    [anon_sym_random_float] = ACTIONS(249),
-    [anon_sym_random_integer] = ACTIONS(249),
-    [anon_sym_read] = ACTIONS(249),
-    [anon_sym_to_json] = ACTIONS(249),
-    [anon_sym_write] = ACTIONS(249),
-    [anon_sym_std] = ACTIONS(249),
-  },
-  [58] = {
-    [ts_builtin_sym_end] = ACTIONS(251),
-    [sym__identifier_pattern] = ACTIONS(253),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(251),
-    [anon_sym_LPAREN] = ACTIONS(251),
-    [anon_sym_async] = ACTIONS(253),
-    [anon_sym_LBRACE] = ACTIONS(251),
-    [anon_sym_RBRACE] = ACTIONS(251),
-    [sym_integer] = ACTIONS(253),
-    [sym_float] = ACTIONS(251),
-    [sym_string] = ACTIONS(251),
-    [anon_sym_true] = ACTIONS(253),
-    [anon_sym_false] = ACTIONS(253),
-    [anon_sym_LBRACK] = ACTIONS(251),
-    [anon_sym_EQ] = ACTIONS(253),
-    [anon_sym_none] = ACTIONS(253),
-    [anon_sym_some] = ACTIONS(253),
-    [anon_sym_COLON] = ACTIONS(251),
-    [anon_sym_DOT_DOT] = ACTIONS(251),
-    [anon_sym_PLUS] = ACTIONS(253),
-    [anon_sym_DASH] = ACTIONS(253),
-    [anon_sym_STAR] = ACTIONS(251),
-    [anon_sym_SLASH] = ACTIONS(251),
-    [anon_sym_PERCENT] = ACTIONS(251),
-    [anon_sym_EQ_EQ] = ACTIONS(251),
-    [anon_sym_BANG_EQ] = ACTIONS(251),
-    [anon_sym_AMP_AMP] = ACTIONS(251),
-    [anon_sym_PIPE_PIPE] = ACTIONS(251),
-    [anon_sym_GT] = ACTIONS(253),
-    [anon_sym_LT] = ACTIONS(253),
-    [anon_sym_GT_EQ] = ACTIONS(251),
-    [anon_sym_LT_EQ] = ACTIONS(251),
-    [anon_sym_PLUS_EQ] = ACTIONS(251),
-    [anon_sym_DASH_EQ] = ACTIONS(251),
-    [anon_sym_if] = ACTIONS(253),
-    [anon_sym_match] = ACTIONS(253),
-    [anon_sym_while] = ACTIONS(253),
-    [anon_sym_for] = ACTIONS(253),
-    [anon_sym_asyncfor] = ACTIONS(251),
-    [anon_sym_return] = ACTIONS(253),
-    [anon_sym_DASH_GT] = ACTIONS(251),
-    [anon_sym_assert] = ACTIONS(253),
-    [anon_sym_assert_equal] = ACTIONS(253),
-    [anon_sym_bash] = ACTIONS(253),
-    [anon_sym_download] = ACTIONS(253),
-    [anon_sym_either_or] = ACTIONS(253),
-    [anon_sym_fish] = ACTIONS(253),
-    [anon_sym_from_json] = ACTIONS(253),
-    [anon_sym_is_none] = ACTIONS(253),
-    [anon_sym_is_some] = ACTIONS(253),
-    [anon_sym_length] = ACTIONS(253),
-    [anon_sym_metadata] = ACTIONS(253),
-    [anon_sym_output] = ACTIONS(253),
-    [anon_sym_output_error] = ACTIONS(253),
-    [anon_sym_random] = ACTIONS(253),
-    [anon_sym_random_boolean] = ACTIONS(253),
-    [anon_sym_random_float] = ACTIONS(253),
-    [anon_sym_random_integer] = ACTIONS(253),
-    [anon_sym_read] = ACTIONS(253),
-    [anon_sym_to_json] = ACTIONS(253),
-    [anon_sym_write] = ACTIONS(253),
-    [anon_sym_std] = ACTIONS(253),
-  },
-  [59] = {
-    [ts_builtin_sym_end] = ACTIONS(255),
-    [sym__identifier_pattern] = ACTIONS(257),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(255),
-    [anon_sym_LPAREN] = ACTIONS(255),
-    [anon_sym_async] = ACTIONS(257),
-    [anon_sym_LBRACE] = ACTIONS(255),
-    [anon_sym_RBRACE] = ACTIONS(255),
-    [sym_integer] = ACTIONS(257),
-    [sym_float] = ACTIONS(255),
-    [sym_string] = ACTIONS(255),
-    [anon_sym_true] = ACTIONS(257),
-    [anon_sym_false] = ACTIONS(257),
-    [anon_sym_LBRACK] = ACTIONS(255),
-    [anon_sym_EQ] = ACTIONS(257),
-    [anon_sym_none] = ACTIONS(257),
-    [anon_sym_some] = ACTIONS(257),
-    [anon_sym_COLON] = ACTIONS(255),
-    [anon_sym_DOT_DOT] = ACTIONS(255),
-    [anon_sym_PLUS] = ACTIONS(257),
-    [anon_sym_DASH] = ACTIONS(257),
-    [anon_sym_STAR] = ACTIONS(255),
-    [anon_sym_SLASH] = ACTIONS(255),
-    [anon_sym_PERCENT] = ACTIONS(255),
-    [anon_sym_EQ_EQ] = ACTIONS(255),
-    [anon_sym_BANG_EQ] = ACTIONS(255),
-    [anon_sym_AMP_AMP] = ACTIONS(255),
-    [anon_sym_PIPE_PIPE] = ACTIONS(255),
-    [anon_sym_GT] = ACTIONS(257),
-    [anon_sym_LT] = ACTIONS(257),
-    [anon_sym_GT_EQ] = ACTIONS(255),
-    [anon_sym_LT_EQ] = ACTIONS(255),
-    [anon_sym_PLUS_EQ] = ACTIONS(255),
-    [anon_sym_DASH_EQ] = ACTIONS(255),
-    [anon_sym_if] = ACTIONS(257),
-    [anon_sym_match] = ACTIONS(257),
-    [anon_sym_while] = ACTIONS(257),
-    [anon_sym_for] = ACTIONS(257),
-    [anon_sym_asyncfor] = ACTIONS(255),
-    [anon_sym_return] = ACTIONS(257),
-    [anon_sym_DASH_GT] = ACTIONS(255),
-    [anon_sym_assert] = ACTIONS(257),
-    [anon_sym_assert_equal] = ACTIONS(257),
-    [anon_sym_bash] = ACTIONS(257),
-    [anon_sym_download] = ACTIONS(257),
-    [anon_sym_either_or] = ACTIONS(257),
-    [anon_sym_fish] = ACTIONS(257),
-    [anon_sym_from_json] = ACTIONS(257),
-    [anon_sym_is_none] = ACTIONS(257),
-    [anon_sym_is_some] = ACTIONS(257),
-    [anon_sym_length] = ACTIONS(257),
-    [anon_sym_metadata] = ACTIONS(257),
-    [anon_sym_output] = ACTIONS(257),
-    [anon_sym_output_error] = ACTIONS(257),
-    [anon_sym_random] = ACTIONS(257),
-    [anon_sym_random_boolean] = ACTIONS(257),
-    [anon_sym_random_float] = ACTIONS(257),
-    [anon_sym_random_integer] = ACTIONS(257),
-    [anon_sym_read] = ACTIONS(257),
-    [anon_sym_to_json] = ACTIONS(257),
-    [anon_sym_write] = ACTIONS(257),
-    [anon_sym_std] = ACTIONS(257),
-  },
-  [60] = {
-    [ts_builtin_sym_end] = ACTIONS(259),
-    [sym__identifier_pattern] = ACTIONS(261),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(259),
-    [anon_sym_LPAREN] = ACTIONS(259),
-    [anon_sym_async] = ACTIONS(261),
-    [anon_sym_LBRACE] = ACTIONS(259),
-    [anon_sym_RBRACE] = ACTIONS(259),
-    [sym_integer] = ACTIONS(261),
-    [sym_float] = ACTIONS(259),
-    [sym_string] = ACTIONS(259),
-    [anon_sym_true] = ACTIONS(261),
-    [anon_sym_false] = ACTIONS(261),
-    [anon_sym_LBRACK] = ACTIONS(259),
-    [anon_sym_EQ] = ACTIONS(261),
-    [anon_sym_none] = ACTIONS(261),
-    [anon_sym_some] = ACTIONS(261),
-    [anon_sym_COLON] = ACTIONS(259),
-    [anon_sym_DOT_DOT] = ACTIONS(259),
-    [anon_sym_PLUS] = ACTIONS(261),
-    [anon_sym_DASH] = ACTIONS(261),
-    [anon_sym_STAR] = ACTIONS(259),
-    [anon_sym_SLASH] = ACTIONS(259),
-    [anon_sym_PERCENT] = ACTIONS(259),
-    [anon_sym_EQ_EQ] = ACTIONS(259),
-    [anon_sym_BANG_EQ] = ACTIONS(259),
-    [anon_sym_AMP_AMP] = ACTIONS(259),
-    [anon_sym_PIPE_PIPE] = ACTIONS(259),
-    [anon_sym_GT] = ACTIONS(261),
-    [anon_sym_LT] = ACTIONS(261),
-    [anon_sym_GT_EQ] = ACTIONS(259),
-    [anon_sym_LT_EQ] = ACTIONS(259),
-    [anon_sym_PLUS_EQ] = ACTIONS(259),
-    [anon_sym_DASH_EQ] = ACTIONS(259),
-    [anon_sym_if] = ACTIONS(261),
-    [anon_sym_match] = ACTIONS(261),
-    [anon_sym_while] = ACTIONS(261),
-    [anon_sym_for] = ACTIONS(261),
-    [anon_sym_asyncfor] = ACTIONS(259),
-    [anon_sym_return] = ACTIONS(261),
-    [anon_sym_DASH_GT] = ACTIONS(259),
-    [anon_sym_assert] = ACTIONS(261),
-    [anon_sym_assert_equal] = ACTIONS(261),
-    [anon_sym_bash] = ACTIONS(261),
-    [anon_sym_download] = ACTIONS(261),
-    [anon_sym_either_or] = ACTIONS(261),
-    [anon_sym_fish] = ACTIONS(261),
-    [anon_sym_from_json] = ACTIONS(261),
-    [anon_sym_is_none] = ACTIONS(261),
-    [anon_sym_is_some] = ACTIONS(261),
-    [anon_sym_length] = ACTIONS(261),
-    [anon_sym_metadata] = ACTIONS(261),
-    [anon_sym_output] = ACTIONS(261),
-    [anon_sym_output_error] = ACTIONS(261),
-    [anon_sym_random] = ACTIONS(261),
-    [anon_sym_random_boolean] = ACTIONS(261),
-    [anon_sym_random_float] = ACTIONS(261),
-    [anon_sym_random_integer] = ACTIONS(261),
-    [anon_sym_read] = ACTIONS(261),
-    [anon_sym_to_json] = ACTIONS(261),
-    [anon_sym_write] = ACTIONS(261),
-    [anon_sym_std] = ACTIONS(261),
-  },
-  [61] = {
-    [ts_builtin_sym_end] = ACTIONS(263),
-    [sym__identifier_pattern] = ACTIONS(265),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(263),
-    [anon_sym_LPAREN] = ACTIONS(263),
-    [anon_sym_async] = ACTIONS(265),
-    [anon_sym_LBRACE] = ACTIONS(263),
-    [anon_sym_RBRACE] = ACTIONS(263),
-    [sym_integer] = ACTIONS(265),
-    [sym_float] = ACTIONS(263),
-    [sym_string] = ACTIONS(263),
-    [anon_sym_true] = ACTIONS(265),
-    [anon_sym_false] = ACTIONS(265),
-    [anon_sym_LBRACK] = ACTIONS(263),
-    [anon_sym_EQ] = ACTIONS(265),
-    [anon_sym_none] = ACTIONS(265),
-    [anon_sym_some] = ACTIONS(265),
-    [anon_sym_COLON] = ACTIONS(263),
-    [anon_sym_DOT_DOT] = ACTIONS(263),
-    [anon_sym_PLUS] = ACTIONS(265),
-    [anon_sym_DASH] = ACTIONS(265),
-    [anon_sym_STAR] = ACTIONS(263),
-    [anon_sym_SLASH] = ACTIONS(263),
-    [anon_sym_PERCENT] = ACTIONS(263),
-    [anon_sym_EQ_EQ] = ACTIONS(263),
-    [anon_sym_BANG_EQ] = ACTIONS(263),
-    [anon_sym_AMP_AMP] = ACTIONS(263),
-    [anon_sym_PIPE_PIPE] = ACTIONS(263),
-    [anon_sym_GT] = ACTIONS(265),
-    [anon_sym_LT] = ACTIONS(265),
-    [anon_sym_GT_EQ] = ACTIONS(263),
-    [anon_sym_LT_EQ] = ACTIONS(263),
-    [anon_sym_PLUS_EQ] = ACTIONS(263),
-    [anon_sym_DASH_EQ] = ACTIONS(263),
-    [anon_sym_if] = ACTIONS(265),
-    [anon_sym_match] = ACTIONS(265),
-    [anon_sym_while] = ACTIONS(265),
-    [anon_sym_for] = ACTIONS(265),
-    [anon_sym_asyncfor] = ACTIONS(263),
-    [anon_sym_return] = ACTIONS(265),
-    [anon_sym_DASH_GT] = ACTIONS(263),
-    [anon_sym_assert] = ACTIONS(265),
-    [anon_sym_assert_equal] = ACTIONS(265),
-    [anon_sym_bash] = ACTIONS(265),
-    [anon_sym_download] = ACTIONS(265),
-    [anon_sym_either_or] = ACTIONS(265),
-    [anon_sym_fish] = ACTIONS(265),
-    [anon_sym_from_json] = ACTIONS(265),
-    [anon_sym_is_none] = ACTIONS(265),
-    [anon_sym_is_some] = ACTIONS(265),
-    [anon_sym_length] = ACTIONS(265),
-    [anon_sym_metadata] = ACTIONS(265),
-    [anon_sym_output] = ACTIONS(265),
-    [anon_sym_output_error] = ACTIONS(265),
-    [anon_sym_random] = ACTIONS(265),
-    [anon_sym_random_boolean] = ACTIONS(265),
-    [anon_sym_random_float] = ACTIONS(265),
-    [anon_sym_random_integer] = ACTIONS(265),
-    [anon_sym_read] = ACTIONS(265),
-    [anon_sym_to_json] = ACTIONS(265),
-    [anon_sym_write] = ACTIONS(265),
-    [anon_sym_std] = ACTIONS(265),
-  },
-  [62] = {
-    [ts_builtin_sym_end] = ACTIONS(267),
-    [sym__identifier_pattern] = ACTIONS(269),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(267),
-    [anon_sym_LPAREN] = ACTIONS(267),
-    [anon_sym_async] = ACTIONS(269),
-    [anon_sym_LBRACE] = ACTIONS(267),
-    [anon_sym_RBRACE] = ACTIONS(267),
-    [sym_integer] = ACTIONS(269),
-    [sym_float] = ACTIONS(267),
-    [sym_string] = ACTIONS(267),
-    [anon_sym_true] = ACTIONS(269),
-    [anon_sym_false] = ACTIONS(269),
-    [anon_sym_LBRACK] = ACTIONS(267),
-    [anon_sym_EQ] = ACTIONS(269),
-    [anon_sym_none] = ACTIONS(269),
-    [anon_sym_some] = ACTIONS(269),
-    [anon_sym_COLON] = ACTIONS(267),
-    [anon_sym_DOT_DOT] = ACTIONS(267),
-    [anon_sym_PLUS] = ACTIONS(269),
-    [anon_sym_DASH] = ACTIONS(269),
-    [anon_sym_STAR] = ACTIONS(267),
-    [anon_sym_SLASH] = ACTIONS(267),
-    [anon_sym_PERCENT] = ACTIONS(267),
-    [anon_sym_EQ_EQ] = ACTIONS(267),
-    [anon_sym_BANG_EQ] = ACTIONS(267),
-    [anon_sym_AMP_AMP] = ACTIONS(267),
-    [anon_sym_PIPE_PIPE] = ACTIONS(267),
-    [anon_sym_GT] = ACTIONS(269),
-    [anon_sym_LT] = ACTIONS(269),
-    [anon_sym_GT_EQ] = ACTIONS(267),
-    [anon_sym_LT_EQ] = ACTIONS(267),
-    [anon_sym_PLUS_EQ] = ACTIONS(267),
-    [anon_sym_DASH_EQ] = ACTIONS(267),
-    [anon_sym_if] = ACTIONS(269),
-    [anon_sym_match] = ACTIONS(269),
-    [anon_sym_while] = ACTIONS(269),
-    [anon_sym_for] = ACTIONS(269),
-    [anon_sym_asyncfor] = ACTIONS(267),
-    [anon_sym_return] = ACTIONS(269),
-    [anon_sym_DASH_GT] = ACTIONS(267),
-    [anon_sym_assert] = ACTIONS(269),
-    [anon_sym_assert_equal] = ACTIONS(269),
-    [anon_sym_bash] = ACTIONS(269),
-    [anon_sym_download] = ACTIONS(269),
-    [anon_sym_either_or] = ACTIONS(269),
-    [anon_sym_fish] = ACTIONS(269),
-    [anon_sym_from_json] = ACTIONS(269),
-    [anon_sym_is_none] = ACTIONS(269),
-    [anon_sym_is_some] = ACTIONS(269),
-    [anon_sym_length] = ACTIONS(269),
-    [anon_sym_metadata] = ACTIONS(269),
-    [anon_sym_output] = ACTIONS(269),
-    [anon_sym_output_error] = ACTIONS(269),
-    [anon_sym_random] = ACTIONS(269),
-    [anon_sym_random_boolean] = ACTIONS(269),
-    [anon_sym_random_float] = ACTIONS(269),
-    [anon_sym_random_integer] = ACTIONS(269),
-    [anon_sym_read] = ACTIONS(269),
-    [anon_sym_to_json] = ACTIONS(269),
-    [anon_sym_write] = ACTIONS(269),
-    [anon_sym_std] = ACTIONS(269),
-  },
-  [63] = {
-    [ts_builtin_sym_end] = ACTIONS(221),
-    [sym__identifier_pattern] = ACTIONS(223),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(221),
-    [anon_sym_LPAREN] = ACTIONS(221),
-    [anon_sym_async] = ACTIONS(223),
-    [anon_sym_LBRACE] = ACTIONS(221),
-    [anon_sym_RBRACE] = ACTIONS(221),
-    [sym_integer] = ACTIONS(223),
-    [sym_float] = ACTIONS(221),
-    [sym_string] = ACTIONS(221),
-    [anon_sym_true] = ACTIONS(223),
-    [anon_sym_false] = ACTIONS(223),
-    [anon_sym_LBRACK] = ACTIONS(221),
-    [anon_sym_EQ] = ACTIONS(223),
-    [anon_sym_none] = ACTIONS(223),
-    [anon_sym_some] = ACTIONS(223),
-    [anon_sym_COLON] = ACTIONS(229),
-    [anon_sym_DOT_DOT] = ACTIONS(221),
-    [anon_sym_PLUS] = ACTIONS(223),
-    [anon_sym_DASH] = ACTIONS(223),
-    [anon_sym_STAR] = ACTIONS(221),
-    [anon_sym_SLASH] = ACTIONS(221),
-    [anon_sym_PERCENT] = ACTIONS(221),
-    [anon_sym_EQ_EQ] = ACTIONS(221),
-    [anon_sym_BANG_EQ] = ACTIONS(221),
-    [anon_sym_AMP_AMP] = ACTIONS(221),
-    [anon_sym_PIPE_PIPE] = ACTIONS(221),
-    [anon_sym_GT] = ACTIONS(223),
-    [anon_sym_LT] = ACTIONS(223),
-    [anon_sym_GT_EQ] = ACTIONS(221),
-    [anon_sym_LT_EQ] = ACTIONS(221),
-    [anon_sym_PLUS_EQ] = ACTIONS(221),
-    [anon_sym_DASH_EQ] = ACTIONS(221),
-    [anon_sym_if] = ACTIONS(223),
-    [anon_sym_match] = ACTIONS(223),
-    [anon_sym_while] = ACTIONS(223),
-    [anon_sym_for] = ACTIONS(223),
-    [anon_sym_asyncfor] = ACTIONS(221),
-    [anon_sym_return] = ACTIONS(223),
-    [anon_sym_DASH_GT] = ACTIONS(221),
-    [anon_sym_assert] = ACTIONS(223),
-    [anon_sym_assert_equal] = ACTIONS(223),
-    [anon_sym_bash] = ACTIONS(223),
-    [anon_sym_download] = ACTIONS(223),
-    [anon_sym_either_or] = ACTIONS(223),
-    [anon_sym_fish] = ACTIONS(223),
-    [anon_sym_from_json] = ACTIONS(223),
-    [anon_sym_is_none] = ACTIONS(223),
-    [anon_sym_is_some] = ACTIONS(223),
-    [anon_sym_length] = ACTIONS(223),
-    [anon_sym_metadata] = ACTIONS(223),
-    [anon_sym_output] = ACTIONS(223),
-    [anon_sym_output_error] = ACTIONS(223),
-    [anon_sym_random] = ACTIONS(223),
-    [anon_sym_random_boolean] = ACTIONS(223),
-    [anon_sym_random_float] = ACTIONS(223),
-    [anon_sym_random_integer] = ACTIONS(223),
-    [anon_sym_read] = ACTIONS(223),
-    [anon_sym_to_json] = ACTIONS(223),
-    [anon_sym_write] = ACTIONS(223),
-    [anon_sym_std] = ACTIONS(223),
-  },
-  [64] = {
-    [ts_builtin_sym_end] = ACTIONS(271),
-    [sym__identifier_pattern] = ACTIONS(273),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(271),
-    [anon_sym_LPAREN] = ACTIONS(271),
-    [anon_sym_async] = ACTIONS(273),
-    [anon_sym_LBRACE] = ACTIONS(271),
-    [anon_sym_RBRACE] = ACTIONS(271),
-    [sym_integer] = ACTIONS(273),
-    [sym_float] = ACTIONS(271),
-    [sym_string] = ACTIONS(271),
-    [anon_sym_true] = ACTIONS(273),
-    [anon_sym_false] = ACTIONS(273),
-    [anon_sym_LBRACK] = ACTIONS(271),
-    [anon_sym_EQ] = ACTIONS(273),
-    [anon_sym_none] = ACTIONS(273),
-    [anon_sym_some] = ACTIONS(273),
-    [anon_sym_COLON] = ACTIONS(271),
-    [anon_sym_DOT_DOT] = ACTIONS(271),
-    [anon_sym_PLUS] = ACTIONS(273),
-    [anon_sym_DASH] = ACTIONS(273),
-    [anon_sym_STAR] = ACTIONS(271),
-    [anon_sym_SLASH] = ACTIONS(271),
-    [anon_sym_PERCENT] = ACTIONS(271),
-    [anon_sym_EQ_EQ] = ACTIONS(271),
-    [anon_sym_BANG_EQ] = ACTIONS(271),
-    [anon_sym_AMP_AMP] = ACTIONS(271),
-    [anon_sym_PIPE_PIPE] = ACTIONS(271),
-    [anon_sym_GT] = ACTIONS(273),
-    [anon_sym_LT] = ACTIONS(273),
-    [anon_sym_GT_EQ] = ACTIONS(271),
-    [anon_sym_LT_EQ] = ACTIONS(271),
-    [anon_sym_PLUS_EQ] = ACTIONS(271),
-    [anon_sym_DASH_EQ] = ACTIONS(271),
-    [anon_sym_if] = ACTIONS(273),
-    [anon_sym_match] = ACTIONS(273),
-    [anon_sym_while] = ACTIONS(273),
-    [anon_sym_for] = ACTIONS(273),
-    [anon_sym_asyncfor] = ACTIONS(271),
-    [anon_sym_return] = ACTIONS(273),
-    [anon_sym_DASH_GT] = ACTIONS(271),
-    [anon_sym_assert] = ACTIONS(273),
-    [anon_sym_assert_equal] = ACTIONS(273),
-    [anon_sym_bash] = ACTIONS(273),
-    [anon_sym_download] = ACTIONS(273),
-    [anon_sym_either_or] = ACTIONS(273),
-    [anon_sym_fish] = ACTIONS(273),
-    [anon_sym_from_json] = ACTIONS(273),
-    [anon_sym_is_none] = ACTIONS(273),
-    [anon_sym_is_some] = ACTIONS(273),
-    [anon_sym_length] = ACTIONS(273),
-    [anon_sym_metadata] = ACTIONS(273),
-    [anon_sym_output] = ACTIONS(273),
-    [anon_sym_output_error] = ACTIONS(273),
-    [anon_sym_random] = ACTIONS(273),
-    [anon_sym_random_boolean] = ACTIONS(273),
-    [anon_sym_random_float] = ACTIONS(273),
-    [anon_sym_random_integer] = ACTIONS(273),
-    [anon_sym_read] = ACTIONS(273),
-    [anon_sym_to_json] = ACTIONS(273),
-    [anon_sym_write] = ACTIONS(273),
-    [anon_sym_std] = ACTIONS(273),
-  },
-  [65] = {
-    [sym_assignment_operator] = STATE(41),
-    [sym_type_definition] = STATE(413),
-    [sym__identifier_pattern] = ACTIONS(223),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(221),
-    [anon_sym_LPAREN] = ACTIONS(225),
-    [anon_sym_async] = ACTIONS(223),
-    [anon_sym_LBRACE] = ACTIONS(221),
-    [anon_sym_RBRACE] = ACTIONS(221),
-    [sym_integer] = ACTIONS(223),
-    [sym_float] = ACTIONS(221),
-    [sym_string] = ACTIONS(221),
-    [anon_sym_true] = ACTIONS(223),
-    [anon_sym_false] = ACTIONS(223),
-    [anon_sym_LBRACK] = ACTIONS(221),
-    [anon_sym_EQ] = ACTIONS(275),
-    [anon_sym_none] = ACTIONS(223),
-    [anon_sym_some] = ACTIONS(223),
-    [anon_sym_COLON] = ACTIONS(229),
-    [anon_sym_PLUS] = ACTIONS(223),
-    [anon_sym_DASH] = ACTIONS(223),
-    [anon_sym_STAR] = ACTIONS(221),
-    [anon_sym_SLASH] = ACTIONS(221),
-    [anon_sym_PERCENT] = ACTIONS(221),
-    [anon_sym_EQ_EQ] = ACTIONS(221),
-    [anon_sym_BANG_EQ] = ACTIONS(221),
-    [anon_sym_AMP_AMP] = ACTIONS(221),
-    [anon_sym_PIPE_PIPE] = ACTIONS(221),
-    [anon_sym_GT] = ACTIONS(223),
-    [anon_sym_LT] = ACTIONS(231),
-    [anon_sym_GT_EQ] = ACTIONS(221),
-    [anon_sym_LT_EQ] = ACTIONS(221),
-    [anon_sym_PLUS_EQ] = ACTIONS(233),
-    [anon_sym_DASH_EQ] = ACTIONS(233),
-    [anon_sym_if] = ACTIONS(223),
-    [anon_sym_match] = ACTIONS(223),
-    [anon_sym_while] = ACTIONS(223),
-    [anon_sym_for] = ACTIONS(223),
-    [anon_sym_asyncfor] = ACTIONS(221),
-    [anon_sym_return] = ACTIONS(223),
-    [anon_sym_DASH_GT] = ACTIONS(221),
-    [anon_sym_assert] = ACTIONS(223),
-    [anon_sym_assert_equal] = ACTIONS(223),
-    [anon_sym_bash] = ACTIONS(223),
-    [anon_sym_download] = ACTIONS(223),
-    [anon_sym_either_or] = ACTIONS(223),
-    [anon_sym_fish] = ACTIONS(223),
-    [anon_sym_from_json] = ACTIONS(223),
-    [anon_sym_is_none] = ACTIONS(223),
-    [anon_sym_is_some] = ACTIONS(223),
-    [anon_sym_length] = ACTIONS(223),
-    [anon_sym_metadata] = ACTIONS(223),
-    [anon_sym_output] = ACTIONS(223),
-    [anon_sym_output_error] = ACTIONS(223),
-    [anon_sym_random] = ACTIONS(223),
-    [anon_sym_random_boolean] = ACTIONS(223),
-    [anon_sym_random_float] = ACTIONS(223),
-    [anon_sym_random_integer] = ACTIONS(223),
-    [anon_sym_read] = ACTIONS(223),
-    [anon_sym_to_json] = ACTIONS(223),
-    [anon_sym_write] = ACTIONS(223),
-    [anon_sym_std] = ACTIONS(223),
-  },
-  [66] = {
-    [ts_builtin_sym_end] = ACTIONS(277),
-    [sym__identifier_pattern] = ACTIONS(279),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(277),
-    [anon_sym_LPAREN] = ACTIONS(277),
-    [anon_sym_async] = ACTIONS(279),
-    [anon_sym_LBRACE] = ACTIONS(277),
-    [anon_sym_RBRACE] = ACTIONS(277),
-    [sym_integer] = ACTIONS(279),
-    [sym_float] = ACTIONS(277),
-    [sym_string] = ACTIONS(277),
-    [anon_sym_true] = ACTIONS(279),
-    [anon_sym_false] = ACTIONS(279),
-    [anon_sym_LBRACK] = ACTIONS(277),
-    [anon_sym_EQ] = ACTIONS(279),
-    [anon_sym_none] = ACTIONS(279),
-    [anon_sym_some] = ACTIONS(279),
-    [anon_sym_COLON] = ACTIONS(277),
-    [anon_sym_DOT_DOT] = ACTIONS(277),
-    [anon_sym_PLUS] = ACTIONS(279),
-    [anon_sym_DASH] = ACTIONS(279),
-    [anon_sym_STAR] = ACTIONS(277),
-    [anon_sym_SLASH] = ACTIONS(277),
-    [anon_sym_PERCENT] = ACTIONS(277),
-    [anon_sym_EQ_EQ] = ACTIONS(277),
-    [anon_sym_BANG_EQ] = ACTIONS(277),
-    [anon_sym_AMP_AMP] = ACTIONS(277),
-    [anon_sym_PIPE_PIPE] = ACTIONS(277),
-    [anon_sym_GT] = ACTIONS(279),
-    [anon_sym_LT] = ACTIONS(279),
-    [anon_sym_GT_EQ] = ACTIONS(277),
-    [anon_sym_LT_EQ] = ACTIONS(277),
-    [anon_sym_PLUS_EQ] = ACTIONS(277),
-    [anon_sym_DASH_EQ] = ACTIONS(277),
-    [anon_sym_if] = ACTIONS(279),
-    [anon_sym_match] = ACTIONS(279),
-    [anon_sym_while] = ACTIONS(279),
-    [anon_sym_for] = ACTIONS(279),
-    [anon_sym_asyncfor] = ACTIONS(277),
-    [anon_sym_return] = ACTIONS(279),
-    [anon_sym_DASH_GT] = ACTIONS(277),
-    [anon_sym_assert] = ACTIONS(279),
-    [anon_sym_assert_equal] = ACTIONS(279),
-    [anon_sym_bash] = ACTIONS(279),
-    [anon_sym_download] = ACTIONS(279),
-    [anon_sym_either_or] = ACTIONS(279),
-    [anon_sym_fish] = ACTIONS(279),
-    [anon_sym_from_json] = ACTIONS(279),
-    [anon_sym_is_none] = ACTIONS(279),
-    [anon_sym_is_some] = ACTIONS(279),
-    [anon_sym_length] = ACTIONS(279),
-    [anon_sym_metadata] = ACTIONS(279),
-    [anon_sym_output] = ACTIONS(279),
-    [anon_sym_output_error] = ACTIONS(279),
-    [anon_sym_random] = ACTIONS(279),
-    [anon_sym_random_boolean] = ACTIONS(279),
-    [anon_sym_random_float] = ACTIONS(279),
-    [anon_sym_random_integer] = ACTIONS(279),
-    [anon_sym_read] = ACTIONS(279),
-    [anon_sym_to_json] = ACTIONS(279),
-    [anon_sym_write] = ACTIONS(279),
-    [anon_sym_std] = ACTIONS(279),
-  },
-  [67] = {
-    [ts_builtin_sym_end] = ACTIONS(281),
-    [sym__identifier_pattern] = ACTIONS(283),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(281),
-    [anon_sym_LPAREN] = ACTIONS(281),
-    [anon_sym_async] = ACTIONS(283),
-    [anon_sym_LBRACE] = ACTIONS(281),
-    [anon_sym_RBRACE] = ACTIONS(281),
-    [sym_integer] = ACTIONS(283),
-    [sym_float] = ACTIONS(281),
-    [sym_string] = ACTIONS(281),
-    [anon_sym_true] = ACTIONS(283),
-    [anon_sym_false] = ACTIONS(283),
-    [anon_sym_LBRACK] = ACTIONS(281),
-    [anon_sym_EQ] = ACTIONS(283),
-    [anon_sym_none] = ACTIONS(283),
-    [anon_sym_some] = ACTIONS(283),
-    [anon_sym_COLON] = ACTIONS(281),
-    [anon_sym_DOT_DOT] = ACTIONS(281),
-    [anon_sym_PLUS] = ACTIONS(283),
-    [anon_sym_DASH] = ACTIONS(283),
-    [anon_sym_STAR] = ACTIONS(281),
-    [anon_sym_SLASH] = ACTIONS(281),
-    [anon_sym_PERCENT] = ACTIONS(281),
-    [anon_sym_EQ_EQ] = ACTIONS(281),
-    [anon_sym_BANG_EQ] = ACTIONS(281),
-    [anon_sym_AMP_AMP] = ACTIONS(281),
-    [anon_sym_PIPE_PIPE] = ACTIONS(281),
-    [anon_sym_GT] = ACTIONS(283),
-    [anon_sym_LT] = ACTIONS(283),
-    [anon_sym_GT_EQ] = ACTIONS(281),
-    [anon_sym_LT_EQ] = ACTIONS(281),
-    [anon_sym_PLUS_EQ] = ACTIONS(281),
-    [anon_sym_DASH_EQ] = ACTIONS(281),
-    [anon_sym_if] = ACTIONS(283),
-    [anon_sym_match] = ACTIONS(283),
-    [anon_sym_while] = ACTIONS(283),
-    [anon_sym_for] = ACTIONS(283),
-    [anon_sym_asyncfor] = ACTIONS(281),
-    [anon_sym_return] = ACTIONS(283),
-    [anon_sym_DASH_GT] = ACTIONS(281),
-    [anon_sym_assert] = ACTIONS(283),
-    [anon_sym_assert_equal] = ACTIONS(283),
-    [anon_sym_bash] = ACTIONS(283),
-    [anon_sym_download] = ACTIONS(283),
-    [anon_sym_either_or] = ACTIONS(283),
-    [anon_sym_fish] = ACTIONS(283),
-    [anon_sym_from_json] = ACTIONS(283),
-    [anon_sym_is_none] = ACTIONS(283),
-    [anon_sym_is_some] = ACTIONS(283),
-    [anon_sym_length] = ACTIONS(283),
-    [anon_sym_metadata] = ACTIONS(283),
-    [anon_sym_output] = ACTIONS(283),
-    [anon_sym_output_error] = ACTIONS(283),
-    [anon_sym_random] = ACTIONS(283),
-    [anon_sym_random_boolean] = ACTIONS(283),
-    [anon_sym_random_float] = ACTIONS(283),
-    [anon_sym_random_integer] = ACTIONS(283),
-    [anon_sym_read] = ACTIONS(283),
-    [anon_sym_to_json] = ACTIONS(283),
-    [anon_sym_write] = ACTIONS(283),
-    [anon_sym_std] = ACTIONS(283),
-  },
-  [68] = {
-    [ts_builtin_sym_end] = ACTIONS(263),
-    [sym__identifier_pattern] = ACTIONS(265),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(263),
-    [anon_sym_LPAREN] = ACTIONS(225),
-    [anon_sym_async] = ACTIONS(265),
-    [anon_sym_LBRACE] = ACTIONS(263),
-    [anon_sym_RBRACE] = ACTIONS(263),
-    [sym_integer] = ACTIONS(265),
-    [sym_float] = ACTIONS(263),
-    [sym_string] = ACTIONS(263),
-    [anon_sym_true] = ACTIONS(265),
-    [anon_sym_false] = ACTIONS(265),
-    [anon_sym_LBRACK] = ACTIONS(263),
-    [anon_sym_EQ] = ACTIONS(265),
-    [anon_sym_none] = ACTIONS(265),
-    [anon_sym_some] = ACTIONS(265),
-    [anon_sym_COLON] = ACTIONS(263),
-    [anon_sym_DOT_DOT] = ACTIONS(263),
-    [anon_sym_PLUS] = ACTIONS(265),
-    [anon_sym_DASH] = ACTIONS(265),
-    [anon_sym_STAR] = ACTIONS(263),
-    [anon_sym_SLASH] = ACTIONS(263),
-    [anon_sym_PERCENT] = ACTIONS(263),
-    [anon_sym_EQ_EQ] = ACTIONS(263),
-    [anon_sym_BANG_EQ] = ACTIONS(263),
-    [anon_sym_AMP_AMP] = ACTIONS(263),
-    [anon_sym_PIPE_PIPE] = ACTIONS(263),
-    [anon_sym_GT] = ACTIONS(265),
-    [anon_sym_LT] = ACTIONS(265),
-    [anon_sym_GT_EQ] = ACTIONS(263),
-    [anon_sym_LT_EQ] = ACTIONS(263),
-    [anon_sym_PLUS_EQ] = ACTIONS(263),
-    [anon_sym_DASH_EQ] = ACTIONS(263),
-    [anon_sym_if] = ACTIONS(265),
-    [anon_sym_match] = ACTIONS(265),
-    [anon_sym_while] = ACTIONS(265),
-    [anon_sym_for] = ACTIONS(265),
-    [anon_sym_asyncfor] = ACTIONS(263),
-    [anon_sym_return] = ACTIONS(265),
-    [anon_sym_DASH_GT] = ACTIONS(263),
-    [anon_sym_assert] = ACTIONS(265),
-    [anon_sym_assert_equal] = ACTIONS(265),
-    [anon_sym_bash] = ACTIONS(265),
-    [anon_sym_download] = ACTIONS(265),
-    [anon_sym_either_or] = ACTIONS(265),
-    [anon_sym_fish] = ACTIONS(265),
-    [anon_sym_from_json] = ACTIONS(265),
-    [anon_sym_is_none] = ACTIONS(265),
-    [anon_sym_is_some] = ACTIONS(265),
-    [anon_sym_length] = ACTIONS(265),
-    [anon_sym_metadata] = ACTIONS(265),
-    [anon_sym_output] = ACTIONS(265),
-    [anon_sym_output_error] = ACTIONS(265),
-    [anon_sym_random] = ACTIONS(265),
-    [anon_sym_random_boolean] = ACTIONS(265),
-    [anon_sym_random_float] = ACTIONS(265),
-    [anon_sym_random_integer] = ACTIONS(265),
-    [anon_sym_read] = ACTIONS(265),
-    [anon_sym_to_json] = ACTIONS(265),
-    [anon_sym_write] = ACTIONS(265),
-    [anon_sym_std] = ACTIONS(265),
-  },
-  [69] = {
-    [ts_builtin_sym_end] = ACTIONS(285),
-    [sym__identifier_pattern] = ACTIONS(287),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(285),
-    [anon_sym_LPAREN] = ACTIONS(285),
-    [anon_sym_async] = ACTIONS(287),
-    [anon_sym_LBRACE] = ACTIONS(285),
-    [anon_sym_RBRACE] = ACTIONS(285),
-    [sym_integer] = ACTIONS(287),
-    [sym_float] = ACTIONS(285),
-    [sym_string] = ACTIONS(285),
-    [anon_sym_true] = ACTIONS(287),
-    [anon_sym_false] = ACTIONS(287),
-    [anon_sym_LBRACK] = ACTIONS(285),
-    [anon_sym_EQ] = ACTIONS(287),
-    [anon_sym_none] = ACTIONS(287),
-    [anon_sym_some] = ACTIONS(287),
-    [anon_sym_COLON] = ACTIONS(285),
-    [anon_sym_DOT_DOT] = ACTIONS(285),
-    [anon_sym_PLUS] = ACTIONS(287),
-    [anon_sym_DASH] = ACTIONS(287),
-    [anon_sym_STAR] = ACTIONS(285),
-    [anon_sym_SLASH] = ACTIONS(285),
-    [anon_sym_PERCENT] = ACTIONS(285),
-    [anon_sym_EQ_EQ] = ACTIONS(285),
-    [anon_sym_BANG_EQ] = ACTIONS(285),
-    [anon_sym_AMP_AMP] = ACTIONS(285),
-    [anon_sym_PIPE_PIPE] = ACTIONS(285),
-    [anon_sym_GT] = ACTIONS(287),
-    [anon_sym_LT] = ACTIONS(287),
-    [anon_sym_GT_EQ] = ACTIONS(285),
-    [anon_sym_LT_EQ] = ACTIONS(285),
-    [anon_sym_PLUS_EQ] = ACTIONS(285),
-    [anon_sym_DASH_EQ] = ACTIONS(285),
-    [anon_sym_if] = ACTIONS(287),
-    [anon_sym_match] = ACTIONS(287),
-    [anon_sym_while] = ACTIONS(287),
-    [anon_sym_for] = ACTIONS(287),
-    [anon_sym_asyncfor] = ACTIONS(285),
-    [anon_sym_return] = ACTIONS(287),
-    [anon_sym_DASH_GT] = ACTIONS(285),
-    [anon_sym_assert] = ACTIONS(287),
-    [anon_sym_assert_equal] = ACTIONS(287),
-    [anon_sym_bash] = ACTIONS(287),
-    [anon_sym_download] = ACTIONS(287),
-    [anon_sym_either_or] = ACTIONS(287),
-    [anon_sym_fish] = ACTIONS(287),
-    [anon_sym_from_json] = ACTIONS(287),
-    [anon_sym_is_none] = ACTIONS(287),
-    [anon_sym_is_some] = ACTIONS(287),
-    [anon_sym_length] = ACTIONS(287),
-    [anon_sym_metadata] = ACTIONS(287),
-    [anon_sym_output] = ACTIONS(287),
-    [anon_sym_output_error] = ACTIONS(287),
-    [anon_sym_random] = ACTIONS(287),
-    [anon_sym_random_boolean] = ACTIONS(287),
-    [anon_sym_random_float] = ACTIONS(287),
-    [anon_sym_random_integer] = ACTIONS(287),
-    [anon_sym_read] = ACTIONS(287),
-    [anon_sym_to_json] = ACTIONS(287),
-    [anon_sym_write] = ACTIONS(287),
-    [anon_sym_std] = ACTIONS(287),
-  },
-  [70] = {
-    [ts_builtin_sym_end] = ACTIONS(289),
-    [sym__identifier_pattern] = ACTIONS(291),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(289),
-    [anon_sym_LPAREN] = ACTIONS(289),
-    [anon_sym_async] = ACTIONS(291),
-    [anon_sym_LBRACE] = ACTIONS(289),
-    [anon_sym_RBRACE] = ACTIONS(289),
-    [sym_integer] = ACTIONS(291),
-    [sym_float] = ACTIONS(289),
-    [sym_string] = ACTIONS(289),
-    [anon_sym_true] = ACTIONS(291),
-    [anon_sym_false] = ACTIONS(291),
-    [anon_sym_LBRACK] = ACTIONS(289),
-    [anon_sym_EQ] = ACTIONS(291),
-    [anon_sym_none] = ACTIONS(291),
-    [anon_sym_some] = ACTIONS(291),
-    [anon_sym_COLON] = ACTIONS(289),
-    [anon_sym_DOT_DOT] = ACTIONS(289),
-    [anon_sym_PLUS] = ACTIONS(291),
-    [anon_sym_DASH] = ACTIONS(291),
-    [anon_sym_STAR] = ACTIONS(289),
-    [anon_sym_SLASH] = ACTIONS(289),
-    [anon_sym_PERCENT] = ACTIONS(289),
-    [anon_sym_EQ_EQ] = ACTIONS(289),
-    [anon_sym_BANG_EQ] = ACTIONS(289),
-    [anon_sym_AMP_AMP] = ACTIONS(289),
-    [anon_sym_PIPE_PIPE] = ACTIONS(289),
-    [anon_sym_GT] = ACTIONS(291),
-    [anon_sym_LT] = ACTIONS(291),
-    [anon_sym_GT_EQ] = ACTIONS(289),
-    [anon_sym_LT_EQ] = ACTIONS(289),
-    [anon_sym_PLUS_EQ] = ACTIONS(289),
-    [anon_sym_DASH_EQ] = ACTIONS(289),
-    [anon_sym_if] = ACTIONS(291),
-    [anon_sym_match] = ACTIONS(291),
-    [anon_sym_while] = ACTIONS(291),
-    [anon_sym_for] = ACTIONS(291),
-    [anon_sym_asyncfor] = ACTIONS(289),
-    [anon_sym_return] = ACTIONS(291),
-    [anon_sym_DASH_GT] = ACTIONS(289),
-    [anon_sym_assert] = ACTIONS(291),
-    [anon_sym_assert_equal] = ACTIONS(291),
-    [anon_sym_bash] = ACTIONS(291),
-    [anon_sym_download] = ACTIONS(291),
-    [anon_sym_either_or] = ACTIONS(291),
-    [anon_sym_fish] = ACTIONS(291),
-    [anon_sym_from_json] = ACTIONS(291),
-    [anon_sym_is_none] = ACTIONS(291),
-    [anon_sym_is_some] = ACTIONS(291),
-    [anon_sym_length] = ACTIONS(291),
-    [anon_sym_metadata] = ACTIONS(291),
-    [anon_sym_output] = ACTIONS(291),
-    [anon_sym_output_error] = ACTIONS(291),
-    [anon_sym_random] = ACTIONS(291),
-    [anon_sym_random_boolean] = ACTIONS(291),
-    [anon_sym_random_float] = ACTIONS(291),
-    [anon_sym_random_integer] = ACTIONS(291),
-    [anon_sym_read] = ACTIONS(291),
-    [anon_sym_to_json] = ACTIONS(291),
-    [anon_sym_write] = ACTIONS(291),
-    [anon_sym_std] = ACTIONS(291),
-  },
-  [71] = {
-    [ts_builtin_sym_end] = ACTIONS(293),
-    [sym__identifier_pattern] = ACTIONS(295),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(293),
-    [anon_sym_LPAREN] = ACTIONS(293),
-    [anon_sym_async] = ACTIONS(295),
-    [anon_sym_LBRACE] = ACTIONS(293),
-    [anon_sym_RBRACE] = ACTIONS(293),
-    [sym_integer] = ACTIONS(295),
-    [sym_float] = ACTIONS(293),
-    [sym_string] = ACTIONS(293),
-    [anon_sym_true] = ACTIONS(295),
-    [anon_sym_false] = ACTIONS(295),
-    [anon_sym_LBRACK] = ACTIONS(293),
-    [anon_sym_EQ] = ACTIONS(295),
-    [anon_sym_none] = ACTIONS(295),
-    [anon_sym_some] = ACTIONS(295),
-    [anon_sym_COLON] = ACTIONS(293),
-    [anon_sym_DOT_DOT] = ACTIONS(293),
-    [anon_sym_PLUS] = ACTIONS(295),
-    [anon_sym_DASH] = ACTIONS(295),
-    [anon_sym_STAR] = ACTIONS(293),
-    [anon_sym_SLASH] = ACTIONS(293),
-    [anon_sym_PERCENT] = ACTIONS(293),
-    [anon_sym_EQ_EQ] = ACTIONS(293),
-    [anon_sym_BANG_EQ] = ACTIONS(293),
-    [anon_sym_AMP_AMP] = ACTIONS(293),
-    [anon_sym_PIPE_PIPE] = ACTIONS(293),
-    [anon_sym_GT] = ACTIONS(295),
-    [anon_sym_LT] = ACTIONS(295),
-    [anon_sym_GT_EQ] = ACTIONS(293),
-    [anon_sym_LT_EQ] = ACTIONS(293),
-    [anon_sym_PLUS_EQ] = ACTIONS(293),
-    [anon_sym_DASH_EQ] = ACTIONS(293),
-    [anon_sym_if] = ACTIONS(295),
-    [anon_sym_match] = ACTIONS(295),
-    [anon_sym_while] = ACTIONS(295),
-    [anon_sym_for] = ACTIONS(295),
-    [anon_sym_asyncfor] = ACTIONS(293),
-    [anon_sym_return] = ACTIONS(295),
-    [anon_sym_DASH_GT] = ACTIONS(293),
-    [anon_sym_assert] = ACTIONS(295),
-    [anon_sym_assert_equal] = ACTIONS(295),
-    [anon_sym_bash] = ACTIONS(295),
-    [anon_sym_download] = ACTIONS(295),
-    [anon_sym_either_or] = ACTIONS(295),
-    [anon_sym_fish] = ACTIONS(295),
-    [anon_sym_from_json] = ACTIONS(295),
-    [anon_sym_is_none] = ACTIONS(295),
-    [anon_sym_is_some] = ACTIONS(295),
-    [anon_sym_length] = ACTIONS(295),
-    [anon_sym_metadata] = ACTIONS(295),
-    [anon_sym_output] = ACTIONS(295),
-    [anon_sym_output_error] = ACTIONS(295),
-    [anon_sym_random] = ACTIONS(295),
-    [anon_sym_random_boolean] = ACTIONS(295),
-    [anon_sym_random_float] = ACTIONS(295),
-    [anon_sym_random_integer] = ACTIONS(295),
-    [anon_sym_read] = ACTIONS(295),
-    [anon_sym_to_json] = ACTIONS(295),
-    [anon_sym_write] = ACTIONS(295),
-    [anon_sym_std] = ACTIONS(295),
-  },
-  [72] = {
-    [ts_builtin_sym_end] = ACTIONS(221),
-    [sym__identifier_pattern] = ACTIONS(223),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(221),
-    [anon_sym_LPAREN] = ACTIONS(225),
-    [anon_sym_async] = ACTIONS(223),
-    [anon_sym_LBRACE] = ACTIONS(221),
-    [anon_sym_RBRACE] = ACTIONS(221),
-    [sym_integer] = ACTIONS(223),
-    [sym_float] = ACTIONS(221),
-    [sym_string] = ACTIONS(221),
-    [anon_sym_true] = ACTIONS(223),
-    [anon_sym_false] = ACTIONS(223),
-    [anon_sym_LBRACK] = ACTIONS(221),
-    [anon_sym_EQ] = ACTIONS(223),
-    [anon_sym_none] = ACTIONS(223),
-    [anon_sym_some] = ACTIONS(223),
-    [anon_sym_COLON] = ACTIONS(229),
-    [anon_sym_DOT_DOT] = ACTIONS(221),
-    [anon_sym_PLUS] = ACTIONS(223),
-    [anon_sym_DASH] = ACTIONS(223),
-    [anon_sym_STAR] = ACTIONS(221),
-    [anon_sym_SLASH] = ACTIONS(221),
-    [anon_sym_PERCENT] = ACTIONS(221),
-    [anon_sym_EQ_EQ] = ACTIONS(221),
-    [anon_sym_BANG_EQ] = ACTIONS(221),
-    [anon_sym_AMP_AMP] = ACTIONS(221),
-    [anon_sym_PIPE_PIPE] = ACTIONS(221),
-    [anon_sym_GT] = ACTIONS(223),
-    [anon_sym_LT] = ACTIONS(223),
-    [anon_sym_GT_EQ] = ACTIONS(221),
-    [anon_sym_LT_EQ] = ACTIONS(221),
-    [anon_sym_PLUS_EQ] = ACTIONS(221),
-    [anon_sym_DASH_EQ] = ACTIONS(221),
-    [anon_sym_if] = ACTIONS(223),
-    [anon_sym_match] = ACTIONS(223),
-    [anon_sym_while] = ACTIONS(223),
-    [anon_sym_for] = ACTIONS(223),
-    [anon_sym_asyncfor] = ACTIONS(221),
-    [anon_sym_return] = ACTIONS(223),
-    [anon_sym_DASH_GT] = ACTIONS(221),
-    [anon_sym_assert] = ACTIONS(223),
-    [anon_sym_assert_equal] = ACTIONS(223),
-    [anon_sym_bash] = ACTIONS(223),
-    [anon_sym_download] = ACTIONS(223),
-    [anon_sym_either_or] = ACTIONS(223),
-    [anon_sym_fish] = ACTIONS(223),
-    [anon_sym_from_json] = ACTIONS(223),
-    [anon_sym_is_none] = ACTIONS(223),
-    [anon_sym_is_some] = ACTIONS(223),
-    [anon_sym_length] = ACTIONS(223),
-    [anon_sym_metadata] = ACTIONS(223),
-    [anon_sym_output] = ACTIONS(223),
-    [anon_sym_output_error] = ACTIONS(223),
-    [anon_sym_random] = ACTIONS(223),
-    [anon_sym_random_boolean] = ACTIONS(223),
-    [anon_sym_random_float] = ACTIONS(223),
-    [anon_sym_random_integer] = ACTIONS(223),
-    [anon_sym_read] = ACTIONS(223),
-    [anon_sym_to_json] = ACTIONS(223),
-    [anon_sym_write] = ACTIONS(223),
-    [anon_sym_std] = ACTIONS(223),
-  },
-  [73] = {
-    [ts_builtin_sym_end] = ACTIONS(297),
-    [sym__identifier_pattern] = ACTIONS(299),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(297),
-    [anon_sym_LPAREN] = ACTIONS(297),
-    [anon_sym_async] = ACTIONS(299),
-    [anon_sym_LBRACE] = ACTIONS(297),
-    [anon_sym_RBRACE] = ACTIONS(297),
-    [sym_integer] = ACTIONS(299),
-    [sym_float] = ACTIONS(297),
-    [sym_string] = ACTIONS(297),
-    [anon_sym_true] = ACTIONS(299),
-    [anon_sym_false] = ACTIONS(299),
-    [anon_sym_LBRACK] = ACTIONS(297),
-    [anon_sym_EQ] = ACTIONS(299),
-    [anon_sym_none] = ACTIONS(299),
-    [anon_sym_some] = ACTIONS(299),
-    [anon_sym_COLON] = ACTIONS(297),
-    [anon_sym_DOT_DOT] = ACTIONS(301),
-    [anon_sym_PLUS] = ACTIONS(299),
-    [anon_sym_DASH] = ACTIONS(299),
-    [anon_sym_STAR] = ACTIONS(297),
-    [anon_sym_SLASH] = ACTIONS(297),
-    [anon_sym_PERCENT] = ACTIONS(297),
-    [anon_sym_EQ_EQ] = ACTIONS(297),
-    [anon_sym_BANG_EQ] = ACTIONS(297),
-    [anon_sym_AMP_AMP] = ACTIONS(297),
-    [anon_sym_PIPE_PIPE] = ACTIONS(297),
-    [anon_sym_GT] = ACTIONS(299),
-    [anon_sym_LT] = ACTIONS(299),
-    [anon_sym_GT_EQ] = ACTIONS(297),
-    [anon_sym_LT_EQ] = ACTIONS(297),
-    [anon_sym_PLUS_EQ] = ACTIONS(297),
-    [anon_sym_DASH_EQ] = ACTIONS(297),
-    [anon_sym_if] = ACTIONS(299),
-    [anon_sym_match] = ACTIONS(299),
-    [anon_sym_while] = ACTIONS(299),
-    [anon_sym_for] = ACTIONS(299),
-    [anon_sym_asyncfor] = ACTIONS(297),
-    [anon_sym_return] = ACTIONS(299),
-    [anon_sym_DASH_GT] = ACTIONS(297),
-    [anon_sym_assert] = ACTIONS(299),
-    [anon_sym_assert_equal] = ACTIONS(299),
-    [anon_sym_bash] = ACTIONS(299),
-    [anon_sym_download] = ACTIONS(299),
-    [anon_sym_either_or] = ACTIONS(299),
-    [anon_sym_fish] = ACTIONS(299),
-    [anon_sym_from_json] = ACTIONS(299),
-    [anon_sym_is_none] = ACTIONS(299),
-    [anon_sym_is_some] = ACTIONS(299),
-    [anon_sym_length] = ACTIONS(299),
-    [anon_sym_metadata] = ACTIONS(299),
-    [anon_sym_output] = ACTIONS(299),
-    [anon_sym_output_error] = ACTIONS(299),
-    [anon_sym_random] = ACTIONS(299),
-    [anon_sym_random_boolean] = ACTIONS(299),
-    [anon_sym_random_float] = ACTIONS(299),
-    [anon_sym_random_integer] = ACTIONS(299),
-    [anon_sym_read] = ACTIONS(299),
-    [anon_sym_to_json] = ACTIONS(299),
-    [anon_sym_write] = ACTIONS(299),
-    [anon_sym_std] = ACTIONS(299),
-  },
-  [74] = {
-    [ts_builtin_sym_end] = ACTIONS(229),
-    [sym__identifier_pattern] = ACTIONS(303),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(229),
-    [anon_sym_LPAREN] = ACTIONS(229),
-    [anon_sym_async] = ACTIONS(303),
-    [anon_sym_LBRACE] = ACTIONS(229),
-    [anon_sym_RBRACE] = ACTIONS(229),
-    [sym_integer] = ACTIONS(303),
-    [sym_float] = ACTIONS(229),
-    [sym_string] = ACTIONS(229),
-    [anon_sym_true] = ACTIONS(303),
-    [anon_sym_false] = ACTIONS(303),
-    [anon_sym_LBRACK] = ACTIONS(229),
-    [anon_sym_EQ] = ACTIONS(303),
-    [anon_sym_none] = ACTIONS(303),
-    [anon_sym_some] = ACTIONS(303),
-    [anon_sym_COLON] = ACTIONS(229),
-    [anon_sym_DOT_DOT] = ACTIONS(229),
-    [anon_sym_PLUS] = ACTIONS(303),
-    [anon_sym_DASH] = ACTIONS(303),
-    [anon_sym_STAR] = ACTIONS(229),
-    [anon_sym_SLASH] = ACTIONS(229),
-    [anon_sym_PERCENT] = ACTIONS(229),
-    [anon_sym_EQ_EQ] = ACTIONS(229),
-    [anon_sym_BANG_EQ] = ACTIONS(229),
-    [anon_sym_AMP_AMP] = ACTIONS(229),
-    [anon_sym_PIPE_PIPE] = ACTIONS(229),
-    [anon_sym_GT] = ACTIONS(303),
-    [anon_sym_LT] = ACTIONS(303),
-    [anon_sym_GT_EQ] = ACTIONS(229),
-    [anon_sym_LT_EQ] = ACTIONS(229),
-    [anon_sym_PLUS_EQ] = ACTIONS(229),
-    [anon_sym_DASH_EQ] = ACTIONS(229),
-    [anon_sym_if] = ACTIONS(303),
-    [anon_sym_match] = ACTIONS(303),
-    [anon_sym_while] = ACTIONS(303),
-    [anon_sym_for] = ACTIONS(303),
-    [anon_sym_asyncfor] = ACTIONS(229),
-    [anon_sym_return] = ACTIONS(303),
-    [anon_sym_DASH_GT] = ACTIONS(229),
-    [anon_sym_assert] = ACTIONS(303),
-    [anon_sym_assert_equal] = ACTIONS(303),
-    [anon_sym_bash] = ACTIONS(303),
-    [anon_sym_download] = ACTIONS(303),
-    [anon_sym_either_or] = ACTIONS(303),
-    [anon_sym_fish] = ACTIONS(303),
-    [anon_sym_from_json] = ACTIONS(303),
-    [anon_sym_is_none] = ACTIONS(303),
-    [anon_sym_is_some] = ACTIONS(303),
-    [anon_sym_length] = ACTIONS(303),
-    [anon_sym_metadata] = ACTIONS(303),
-    [anon_sym_output] = ACTIONS(303),
-    [anon_sym_output_error] = ACTIONS(303),
-    [anon_sym_random] = ACTIONS(303),
-    [anon_sym_random_boolean] = ACTIONS(303),
-    [anon_sym_random_float] = ACTIONS(303),
-    [anon_sym_random_integer] = ACTIONS(303),
-    [anon_sym_read] = ACTIONS(303),
-    [anon_sym_to_json] = ACTIONS(303),
-    [anon_sym_write] = ACTIONS(303),
-    [anon_sym_std] = ACTIONS(303),
-  },
-  [75] = {
-    [ts_builtin_sym_end] = ACTIONS(305),
-    [sym__identifier_pattern] = ACTIONS(307),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(305),
-    [anon_sym_LPAREN] = ACTIONS(305),
-    [anon_sym_async] = ACTIONS(307),
-    [anon_sym_LBRACE] = ACTIONS(305),
-    [anon_sym_RBRACE] = ACTIONS(305),
-    [sym_integer] = ACTIONS(307),
-    [sym_float] = ACTIONS(305),
-    [sym_string] = ACTIONS(305),
-    [anon_sym_true] = ACTIONS(307),
-    [anon_sym_false] = ACTIONS(307),
-    [anon_sym_LBRACK] = ACTIONS(305),
-    [anon_sym_EQ] = ACTIONS(307),
-    [anon_sym_none] = ACTIONS(307),
-    [anon_sym_some] = ACTIONS(307),
-    [anon_sym_COLON] = ACTIONS(305),
-    [anon_sym_DOT_DOT] = ACTIONS(305),
-    [anon_sym_PLUS] = ACTIONS(307),
-    [anon_sym_DASH] = ACTIONS(307),
-    [anon_sym_STAR] = ACTIONS(305),
-    [anon_sym_SLASH] = ACTIONS(305),
-    [anon_sym_PERCENT] = ACTIONS(305),
-    [anon_sym_EQ_EQ] = ACTIONS(305),
-    [anon_sym_BANG_EQ] = ACTIONS(305),
-    [anon_sym_AMP_AMP] = ACTIONS(305),
-    [anon_sym_PIPE_PIPE] = ACTIONS(305),
-    [anon_sym_GT] = ACTIONS(307),
-    [anon_sym_LT] = ACTIONS(307),
-    [anon_sym_GT_EQ] = ACTIONS(305),
-    [anon_sym_LT_EQ] = ACTIONS(305),
-    [anon_sym_PLUS_EQ] = ACTIONS(305),
-    [anon_sym_DASH_EQ] = ACTIONS(305),
-    [anon_sym_if] = ACTIONS(307),
-    [anon_sym_match] = ACTIONS(307),
-    [anon_sym_while] = ACTIONS(307),
-    [anon_sym_for] = ACTIONS(307),
-    [anon_sym_asyncfor] = ACTIONS(305),
-    [anon_sym_return] = ACTIONS(307),
-    [anon_sym_DASH_GT] = ACTIONS(305),
-    [anon_sym_assert] = ACTIONS(307),
-    [anon_sym_assert_equal] = ACTIONS(307),
-    [anon_sym_bash] = ACTIONS(307),
-    [anon_sym_download] = ACTIONS(307),
-    [anon_sym_either_or] = ACTIONS(307),
-    [anon_sym_fish] = ACTIONS(307),
-    [anon_sym_from_json] = ACTIONS(307),
-    [anon_sym_is_none] = ACTIONS(307),
-    [anon_sym_is_some] = ACTIONS(307),
-    [anon_sym_length] = ACTIONS(307),
-    [anon_sym_metadata] = ACTIONS(307),
-    [anon_sym_output] = ACTIONS(307),
-    [anon_sym_output_error] = ACTIONS(307),
-    [anon_sym_random] = ACTIONS(307),
-    [anon_sym_random_boolean] = ACTIONS(307),
-    [anon_sym_random_float] = ACTIONS(307),
-    [anon_sym_random_integer] = ACTIONS(307),
-    [anon_sym_read] = ACTIONS(307),
-    [anon_sym_to_json] = ACTIONS(307),
-    [anon_sym_write] = ACTIONS(307),
-    [anon_sym_std] = ACTIONS(307),
-  },
-  [76] = {
-    [ts_builtin_sym_end] = ACTIONS(309),
-    [sym__identifier_pattern] = ACTIONS(311),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(309),
-    [anon_sym_LPAREN] = ACTIONS(309),
-    [anon_sym_async] = ACTIONS(311),
-    [anon_sym_LBRACE] = ACTIONS(309),
-    [anon_sym_RBRACE] = ACTIONS(309),
-    [sym_integer] = ACTIONS(311),
-    [sym_float] = ACTIONS(309),
-    [sym_string] = ACTIONS(309),
-    [anon_sym_true] = ACTIONS(311),
-    [anon_sym_false] = ACTIONS(311),
-    [anon_sym_LBRACK] = ACTIONS(309),
-    [anon_sym_EQ] = ACTIONS(311),
-    [anon_sym_none] = ACTIONS(311),
-    [anon_sym_some] = ACTIONS(311),
-    [anon_sym_COLON] = ACTIONS(309),
-    [anon_sym_DOT_DOT] = ACTIONS(309),
-    [anon_sym_PLUS] = ACTIONS(311),
-    [anon_sym_DASH] = ACTIONS(311),
-    [anon_sym_STAR] = ACTIONS(309),
-    [anon_sym_SLASH] = ACTIONS(309),
-    [anon_sym_PERCENT] = ACTIONS(309),
-    [anon_sym_EQ_EQ] = ACTIONS(309),
-    [anon_sym_BANG_EQ] = ACTIONS(309),
-    [anon_sym_AMP_AMP] = ACTIONS(309),
-    [anon_sym_PIPE_PIPE] = ACTIONS(309),
-    [anon_sym_GT] = ACTIONS(311),
-    [anon_sym_LT] = ACTIONS(311),
-    [anon_sym_GT_EQ] = ACTIONS(309),
-    [anon_sym_LT_EQ] = ACTIONS(309),
-    [anon_sym_PLUS_EQ] = ACTIONS(309),
-    [anon_sym_DASH_EQ] = ACTIONS(309),
-    [anon_sym_if] = ACTIONS(311),
-    [anon_sym_match] = ACTIONS(311),
-    [anon_sym_while] = ACTIONS(311),
-    [anon_sym_for] = ACTIONS(311),
-    [anon_sym_asyncfor] = ACTIONS(309),
-    [anon_sym_return] = ACTIONS(311),
-    [anon_sym_DASH_GT] = ACTIONS(309),
-    [anon_sym_assert] = ACTIONS(311),
-    [anon_sym_assert_equal] = ACTIONS(311),
-    [anon_sym_bash] = ACTIONS(311),
-    [anon_sym_download] = ACTIONS(311),
-    [anon_sym_either_or] = ACTIONS(311),
-    [anon_sym_fish] = ACTIONS(311),
-    [anon_sym_from_json] = ACTIONS(311),
-    [anon_sym_is_none] = ACTIONS(311),
-    [anon_sym_is_some] = ACTIONS(311),
-    [anon_sym_length] = ACTIONS(311),
-    [anon_sym_metadata] = ACTIONS(311),
-    [anon_sym_output] = ACTIONS(311),
-    [anon_sym_output_error] = ACTIONS(311),
-    [anon_sym_random] = ACTIONS(311),
-    [anon_sym_random_boolean] = ACTIONS(311),
-    [anon_sym_random_float] = ACTIONS(311),
-    [anon_sym_random_integer] = ACTIONS(311),
-    [anon_sym_read] = ACTIONS(311),
-    [anon_sym_to_json] = ACTIONS(311),
-    [anon_sym_write] = ACTIONS(311),
-    [anon_sym_std] = ACTIONS(311),
-  },
-  [77] = {
-    [ts_builtin_sym_end] = ACTIONS(313),
-    [sym__identifier_pattern] = ACTIONS(315),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(313),
-    [anon_sym_LPAREN] = ACTIONS(313),
-    [anon_sym_async] = ACTIONS(315),
-    [anon_sym_LBRACE] = ACTIONS(313),
-    [anon_sym_RBRACE] = ACTIONS(313),
-    [sym_integer] = ACTIONS(315),
-    [sym_float] = ACTIONS(313),
-    [sym_string] = ACTIONS(313),
-    [anon_sym_true] = ACTIONS(315),
-    [anon_sym_false] = ACTIONS(315),
-    [anon_sym_LBRACK] = ACTIONS(313),
-    [anon_sym_EQ] = ACTIONS(315),
-    [anon_sym_none] = ACTIONS(315),
-    [anon_sym_some] = ACTIONS(315),
-    [anon_sym_COLON] = ACTIONS(313),
-    [anon_sym_DOT_DOT] = ACTIONS(313),
-    [anon_sym_PLUS] = ACTIONS(315),
-    [anon_sym_DASH] = ACTIONS(315),
-    [anon_sym_STAR] = ACTIONS(313),
-    [anon_sym_SLASH] = ACTIONS(313),
-    [anon_sym_PERCENT] = ACTIONS(313),
-    [anon_sym_EQ_EQ] = ACTIONS(313),
-    [anon_sym_BANG_EQ] = ACTIONS(313),
-    [anon_sym_AMP_AMP] = ACTIONS(313),
-    [anon_sym_PIPE_PIPE] = ACTIONS(313),
-    [anon_sym_GT] = ACTIONS(315),
-    [anon_sym_LT] = ACTIONS(315),
-    [anon_sym_GT_EQ] = ACTIONS(313),
-    [anon_sym_LT_EQ] = ACTIONS(313),
-    [anon_sym_PLUS_EQ] = ACTIONS(313),
-    [anon_sym_DASH_EQ] = ACTIONS(313),
-    [anon_sym_if] = ACTIONS(315),
-    [anon_sym_match] = ACTIONS(315),
-    [anon_sym_while] = ACTIONS(315),
-    [anon_sym_for] = ACTIONS(315),
-    [anon_sym_asyncfor] = ACTIONS(313),
-    [anon_sym_return] = ACTIONS(315),
-    [anon_sym_DASH_GT] = ACTIONS(313),
-    [anon_sym_assert] = ACTIONS(315),
-    [anon_sym_assert_equal] = ACTIONS(315),
-    [anon_sym_bash] = ACTIONS(315),
-    [anon_sym_download] = ACTIONS(315),
-    [anon_sym_either_or] = ACTIONS(315),
-    [anon_sym_fish] = ACTIONS(315),
-    [anon_sym_from_json] = ACTIONS(315),
-    [anon_sym_is_none] = ACTIONS(315),
-    [anon_sym_is_some] = ACTIONS(315),
-    [anon_sym_length] = ACTIONS(315),
-    [anon_sym_metadata] = ACTIONS(315),
-    [anon_sym_output] = ACTIONS(315),
-    [anon_sym_output_error] = ACTIONS(315),
-    [anon_sym_random] = ACTIONS(315),
-    [anon_sym_random_boolean] = ACTIONS(315),
-    [anon_sym_random_float] = ACTIONS(315),
-    [anon_sym_random_integer] = ACTIONS(315),
-    [anon_sym_read] = ACTIONS(315),
-    [anon_sym_to_json] = ACTIONS(315),
-    [anon_sym_write] = ACTIONS(315),
-    [anon_sym_std] = ACTIONS(315),
-  },
-  [78] = {
-    [ts_builtin_sym_end] = ACTIONS(317),
-    [sym__identifier_pattern] = ACTIONS(319),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(317),
-    [anon_sym_LPAREN] = ACTIONS(317),
-    [anon_sym_async] = ACTIONS(319),
-    [anon_sym_LBRACE] = ACTIONS(317),
-    [anon_sym_RBRACE] = ACTIONS(317),
-    [sym_integer] = ACTIONS(319),
-    [sym_float] = ACTIONS(317),
-    [sym_string] = ACTIONS(317),
-    [anon_sym_true] = ACTIONS(319),
-    [anon_sym_false] = ACTIONS(319),
-    [anon_sym_LBRACK] = ACTIONS(317),
-    [anon_sym_EQ] = ACTIONS(319),
-    [anon_sym_none] = ACTIONS(319),
-    [anon_sym_some] = ACTIONS(319),
-    [anon_sym_COLON] = ACTIONS(317),
-    [anon_sym_DOT_DOT] = ACTIONS(317),
-    [anon_sym_PLUS] = ACTIONS(319),
-    [anon_sym_DASH] = ACTIONS(319),
-    [anon_sym_STAR] = ACTIONS(317),
-    [anon_sym_SLASH] = ACTIONS(317),
-    [anon_sym_PERCENT] = ACTIONS(317),
-    [anon_sym_EQ_EQ] = ACTIONS(317),
-    [anon_sym_BANG_EQ] = ACTIONS(317),
-    [anon_sym_AMP_AMP] = ACTIONS(317),
-    [anon_sym_PIPE_PIPE] = ACTIONS(317),
-    [anon_sym_GT] = ACTIONS(319),
-    [anon_sym_LT] = ACTIONS(319),
-    [anon_sym_GT_EQ] = ACTIONS(317),
-    [anon_sym_LT_EQ] = ACTIONS(317),
-    [anon_sym_PLUS_EQ] = ACTIONS(317),
-    [anon_sym_DASH_EQ] = ACTIONS(317),
-    [anon_sym_if] = ACTIONS(319),
-    [anon_sym_match] = ACTIONS(319),
-    [anon_sym_while] = ACTIONS(319),
-    [anon_sym_for] = ACTIONS(319),
-    [anon_sym_asyncfor] = ACTIONS(317),
-    [anon_sym_return] = ACTIONS(319),
-    [anon_sym_DASH_GT] = ACTIONS(317),
-    [anon_sym_assert] = ACTIONS(319),
-    [anon_sym_assert_equal] = ACTIONS(319),
-    [anon_sym_bash] = ACTIONS(319),
-    [anon_sym_download] = ACTIONS(319),
-    [anon_sym_either_or] = ACTIONS(319),
-    [anon_sym_fish] = ACTIONS(319),
-    [anon_sym_from_json] = ACTIONS(319),
-    [anon_sym_is_none] = ACTIONS(319),
-    [anon_sym_is_some] = ACTIONS(319),
-    [anon_sym_length] = ACTIONS(319),
-    [anon_sym_metadata] = ACTIONS(319),
-    [anon_sym_output] = ACTIONS(319),
-    [anon_sym_output_error] = ACTIONS(319),
-    [anon_sym_random] = ACTIONS(319),
-    [anon_sym_random_boolean] = ACTIONS(319),
-    [anon_sym_random_float] = ACTIONS(319),
-    [anon_sym_random_integer] = ACTIONS(319),
-    [anon_sym_read] = ACTIONS(319),
-    [anon_sym_to_json] = ACTIONS(319),
-    [anon_sym_write] = ACTIONS(319),
-    [anon_sym_std] = ACTIONS(319),
-  },
-  [79] = {
-    [ts_builtin_sym_end] = ACTIONS(321),
-    [sym__identifier_pattern] = ACTIONS(323),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(321),
-    [anon_sym_LPAREN] = ACTIONS(321),
-    [anon_sym_async] = ACTIONS(323),
-    [anon_sym_LBRACE] = ACTIONS(321),
-    [anon_sym_RBRACE] = ACTIONS(321),
-    [sym_integer] = ACTIONS(323),
-    [sym_float] = ACTIONS(321),
-    [sym_string] = ACTIONS(321),
-    [anon_sym_true] = ACTIONS(323),
-    [anon_sym_false] = ACTIONS(323),
-    [anon_sym_LBRACK] = ACTIONS(321),
-    [anon_sym_EQ] = ACTIONS(323),
-    [anon_sym_none] = ACTIONS(323),
-    [anon_sym_some] = ACTIONS(323),
-    [anon_sym_COLON] = ACTIONS(321),
-    [anon_sym_DOT_DOT] = ACTIONS(321),
-    [anon_sym_PLUS] = ACTIONS(323),
-    [anon_sym_DASH] = ACTIONS(323),
-    [anon_sym_STAR] = ACTIONS(321),
-    [anon_sym_SLASH] = ACTIONS(321),
-    [anon_sym_PERCENT] = ACTIONS(321),
-    [anon_sym_EQ_EQ] = ACTIONS(321),
-    [anon_sym_BANG_EQ] = ACTIONS(321),
-    [anon_sym_AMP_AMP] = ACTIONS(321),
-    [anon_sym_PIPE_PIPE] = ACTIONS(321),
-    [anon_sym_GT] = ACTIONS(323),
-    [anon_sym_LT] = ACTIONS(323),
-    [anon_sym_GT_EQ] = ACTIONS(321),
-    [anon_sym_LT_EQ] = ACTIONS(321),
-    [anon_sym_PLUS_EQ] = ACTIONS(321),
-    [anon_sym_DASH_EQ] = ACTIONS(321),
-    [anon_sym_if] = ACTIONS(323),
-    [anon_sym_match] = ACTIONS(323),
-    [anon_sym_while] = ACTIONS(323),
-    [anon_sym_for] = ACTIONS(323),
-    [anon_sym_asyncfor] = ACTIONS(321),
-    [anon_sym_return] = ACTIONS(323),
-    [anon_sym_DASH_GT] = ACTIONS(321),
-    [anon_sym_assert] = ACTIONS(323),
-    [anon_sym_assert_equal] = ACTIONS(323),
-    [anon_sym_bash] = ACTIONS(323),
-    [anon_sym_download] = ACTIONS(323),
-    [anon_sym_either_or] = ACTIONS(323),
-    [anon_sym_fish] = ACTIONS(323),
-    [anon_sym_from_json] = ACTIONS(323),
-    [anon_sym_is_none] = ACTIONS(323),
-    [anon_sym_is_some] = ACTIONS(323),
-    [anon_sym_length] = ACTIONS(323),
-    [anon_sym_metadata] = ACTIONS(323),
-    [anon_sym_output] = ACTIONS(323),
-    [anon_sym_output_error] = ACTIONS(323),
-    [anon_sym_random] = ACTIONS(323),
-    [anon_sym_random_boolean] = ACTIONS(323),
-    [anon_sym_random_float] = ACTIONS(323),
-    [anon_sym_random_integer] = ACTIONS(323),
-    [anon_sym_read] = ACTIONS(323),
-    [anon_sym_to_json] = ACTIONS(323),
-    [anon_sym_write] = ACTIONS(323),
-    [anon_sym_std] = ACTIONS(323),
-  },
-  [80] = {
-    [ts_builtin_sym_end] = ACTIONS(325),
-    [sym__identifier_pattern] = ACTIONS(327),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(325),
-    [anon_sym_LPAREN] = ACTIONS(325),
-    [anon_sym_async] = ACTIONS(327),
-    [anon_sym_LBRACE] = ACTIONS(325),
-    [anon_sym_RBRACE] = ACTIONS(325),
-    [sym_integer] = ACTIONS(327),
-    [sym_float] = ACTIONS(325),
-    [sym_string] = ACTIONS(325),
-    [anon_sym_true] = ACTIONS(327),
-    [anon_sym_false] = ACTIONS(327),
-    [anon_sym_LBRACK] = ACTIONS(325),
-    [anon_sym_EQ] = ACTIONS(327),
-    [anon_sym_none] = ACTIONS(327),
-    [anon_sym_some] = ACTIONS(327),
-    [anon_sym_COLON] = ACTIONS(325),
-    [anon_sym_DOT_DOT] = ACTIONS(325),
-    [anon_sym_PLUS] = ACTIONS(327),
-    [anon_sym_DASH] = ACTIONS(327),
-    [anon_sym_STAR] = ACTIONS(325),
-    [anon_sym_SLASH] = ACTIONS(325),
-    [anon_sym_PERCENT] = ACTIONS(325),
-    [anon_sym_EQ_EQ] = ACTIONS(325),
-    [anon_sym_BANG_EQ] = ACTIONS(325),
-    [anon_sym_AMP_AMP] = ACTIONS(325),
-    [anon_sym_PIPE_PIPE] = ACTIONS(325),
-    [anon_sym_GT] = ACTIONS(327),
-    [anon_sym_LT] = ACTIONS(327),
-    [anon_sym_GT_EQ] = ACTIONS(325),
-    [anon_sym_LT_EQ] = ACTIONS(325),
-    [anon_sym_PLUS_EQ] = ACTIONS(325),
-    [anon_sym_DASH_EQ] = ACTIONS(325),
-    [anon_sym_if] = ACTIONS(327),
-    [anon_sym_match] = ACTIONS(327),
-    [anon_sym_while] = ACTIONS(327),
-    [anon_sym_for] = ACTIONS(327),
-    [anon_sym_asyncfor] = ACTIONS(325),
-    [anon_sym_return] = ACTIONS(327),
-    [anon_sym_DASH_GT] = ACTIONS(325),
-    [anon_sym_assert] = ACTIONS(327),
-    [anon_sym_assert_equal] = ACTIONS(327),
-    [anon_sym_bash] = ACTIONS(327),
-    [anon_sym_download] = ACTIONS(327),
-    [anon_sym_either_or] = ACTIONS(327),
-    [anon_sym_fish] = ACTIONS(327),
-    [anon_sym_from_json] = ACTIONS(327),
-    [anon_sym_is_none] = ACTIONS(327),
-    [anon_sym_is_some] = ACTIONS(327),
-    [anon_sym_length] = ACTIONS(327),
-    [anon_sym_metadata] = ACTIONS(327),
-    [anon_sym_output] = ACTIONS(327),
-    [anon_sym_output_error] = ACTIONS(327),
-    [anon_sym_random] = ACTIONS(327),
-    [anon_sym_random_boolean] = ACTIONS(327),
-    [anon_sym_random_float] = ACTIONS(327),
-    [anon_sym_random_integer] = ACTIONS(327),
-    [anon_sym_read] = ACTIONS(327),
-    [anon_sym_to_json] = ACTIONS(327),
-    [anon_sym_write] = ACTIONS(327),
-    [anon_sym_std] = ACTIONS(327),
-  },
-  [81] = {
-    [ts_builtin_sym_end] = ACTIONS(297),
-    [sym__identifier_pattern] = ACTIONS(299),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(297),
-    [anon_sym_LPAREN] = ACTIONS(297),
-    [anon_sym_async] = ACTIONS(299),
-    [anon_sym_LBRACE] = ACTIONS(297),
-    [anon_sym_RBRACE] = ACTIONS(297),
-    [sym_integer] = ACTIONS(299),
-    [sym_float] = ACTIONS(297),
-    [sym_string] = ACTIONS(297),
-    [anon_sym_true] = ACTIONS(299),
-    [anon_sym_false] = ACTIONS(299),
-    [anon_sym_LBRACK] = ACTIONS(297),
-    [anon_sym_EQ] = ACTIONS(299),
-    [anon_sym_none] = ACTIONS(299),
-    [anon_sym_some] = ACTIONS(299),
-    [anon_sym_COLON] = ACTIONS(297),
-    [anon_sym_DOT_DOT] = ACTIONS(297),
-    [anon_sym_PLUS] = ACTIONS(299),
-    [anon_sym_DASH] = ACTIONS(299),
-    [anon_sym_STAR] = ACTIONS(297),
-    [anon_sym_SLASH] = ACTIONS(297),
-    [anon_sym_PERCENT] = ACTIONS(297),
-    [anon_sym_EQ_EQ] = ACTIONS(297),
-    [anon_sym_BANG_EQ] = ACTIONS(297),
-    [anon_sym_AMP_AMP] = ACTIONS(297),
-    [anon_sym_PIPE_PIPE] = ACTIONS(297),
-    [anon_sym_GT] = ACTIONS(299),
-    [anon_sym_LT] = ACTIONS(299),
-    [anon_sym_GT_EQ] = ACTIONS(297),
-    [anon_sym_LT_EQ] = ACTIONS(297),
-    [anon_sym_PLUS_EQ] = ACTIONS(297),
-    [anon_sym_DASH_EQ] = ACTIONS(297),
-    [anon_sym_if] = ACTIONS(299),
-    [anon_sym_match] = ACTIONS(299),
-    [anon_sym_while] = ACTIONS(299),
-    [anon_sym_for] = ACTIONS(299),
-    [anon_sym_asyncfor] = ACTIONS(297),
-    [anon_sym_return] = ACTIONS(299),
-    [anon_sym_DASH_GT] = ACTIONS(297),
-    [anon_sym_assert] = ACTIONS(299),
-    [anon_sym_assert_equal] = ACTIONS(299),
-    [anon_sym_bash] = ACTIONS(299),
-    [anon_sym_download] = ACTIONS(299),
-    [anon_sym_either_or] = ACTIONS(299),
-    [anon_sym_fish] = ACTIONS(299),
-    [anon_sym_from_json] = ACTIONS(299),
-    [anon_sym_is_none] = ACTIONS(299),
-    [anon_sym_is_some] = ACTIONS(299),
-    [anon_sym_length] = ACTIONS(299),
-    [anon_sym_metadata] = ACTIONS(299),
-    [anon_sym_output] = ACTIONS(299),
-    [anon_sym_output_error] = ACTIONS(299),
-    [anon_sym_random] = ACTIONS(299),
-    [anon_sym_random_boolean] = ACTIONS(299),
-    [anon_sym_random_float] = ACTIONS(299),
-    [anon_sym_random_integer] = ACTIONS(299),
-    [anon_sym_read] = ACTIONS(299),
-    [anon_sym_to_json] = ACTIONS(299),
-    [anon_sym_write] = ACTIONS(299),
-    [anon_sym_std] = ACTIONS(299),
-  },
-  [82] = {
-    [ts_builtin_sym_end] = ACTIONS(329),
-    [sym__identifier_pattern] = ACTIONS(331),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(329),
-    [anon_sym_LPAREN] = ACTIONS(329),
-    [anon_sym_async] = ACTIONS(331),
-    [anon_sym_LBRACE] = ACTIONS(329),
-    [anon_sym_RBRACE] = ACTIONS(329),
-    [sym_integer] = ACTIONS(331),
-    [sym_float] = ACTIONS(329),
-    [sym_string] = ACTIONS(329),
-    [anon_sym_true] = ACTIONS(331),
-    [anon_sym_false] = ACTIONS(331),
-    [anon_sym_LBRACK] = ACTIONS(329),
-    [anon_sym_EQ] = ACTIONS(331),
-    [anon_sym_none] = ACTIONS(331),
-    [anon_sym_some] = ACTIONS(331),
-    [anon_sym_COLON] = ACTIONS(329),
-    [anon_sym_DOT_DOT] = ACTIONS(329),
-    [anon_sym_PLUS] = ACTIONS(331),
-    [anon_sym_DASH] = ACTIONS(331),
-    [anon_sym_STAR] = ACTIONS(329),
-    [anon_sym_SLASH] = ACTIONS(329),
-    [anon_sym_PERCENT] = ACTIONS(329),
-    [anon_sym_EQ_EQ] = ACTIONS(329),
-    [anon_sym_BANG_EQ] = ACTIONS(329),
-    [anon_sym_AMP_AMP] = ACTIONS(329),
-    [anon_sym_PIPE_PIPE] = ACTIONS(329),
-    [anon_sym_GT] = ACTIONS(331),
-    [anon_sym_LT] = ACTIONS(331),
-    [anon_sym_GT_EQ] = ACTIONS(329),
-    [anon_sym_LT_EQ] = ACTIONS(329),
-    [anon_sym_PLUS_EQ] = ACTIONS(329),
-    [anon_sym_DASH_EQ] = ACTIONS(329),
-    [anon_sym_if] = ACTIONS(331),
-    [anon_sym_match] = ACTIONS(331),
-    [anon_sym_while] = ACTIONS(331),
-    [anon_sym_for] = ACTIONS(331),
-    [anon_sym_asyncfor] = ACTIONS(329),
-    [anon_sym_return] = ACTIONS(331),
-    [anon_sym_DASH_GT] = ACTIONS(329),
-    [anon_sym_assert] = ACTIONS(331),
-    [anon_sym_assert_equal] = ACTIONS(331),
-    [anon_sym_bash] = ACTIONS(331),
-    [anon_sym_download] = ACTIONS(331),
-    [anon_sym_either_or] = ACTIONS(331),
-    [anon_sym_fish] = ACTIONS(331),
-    [anon_sym_from_json] = ACTIONS(331),
-    [anon_sym_is_none] = ACTIONS(331),
-    [anon_sym_is_some] = ACTIONS(331),
-    [anon_sym_length] = ACTIONS(331),
-    [anon_sym_metadata] = ACTIONS(331),
-    [anon_sym_output] = ACTIONS(331),
-    [anon_sym_output_error] = ACTIONS(331),
-    [anon_sym_random] = ACTIONS(331),
-    [anon_sym_random_boolean] = ACTIONS(331),
-    [anon_sym_random_float] = ACTIONS(331),
-    [anon_sym_random_integer] = ACTIONS(331),
-    [anon_sym_read] = ACTIONS(331),
-    [anon_sym_to_json] = ACTIONS(331),
-    [anon_sym_write] = ACTIONS(331),
-    [anon_sym_std] = ACTIONS(331),
-  },
-  [83] = {
-    [ts_builtin_sym_end] = ACTIONS(221),
-    [sym__identifier_pattern] = ACTIONS(223),
-    [sym__comment] = ACTIONS(3),
-    [anon_sym_SEMI] = ACTIONS(221),
-    [anon_sym_LPAREN] = ACTIONS(225),
-    [anon_sym_async] = ACTIONS(223),
-    [anon_sym_LBRACE] = ACTIONS(221),
-    [anon_sym_RBRACE] = ACTIONS(221),
-    [sym_integer] = ACTIONS(223),
-    [sym_float] = ACTIONS(221),
-    [sym_string] = ACTIONS(221),
-    [anon_sym_true] = ACTIONS(223),
-    [anon_sym_false] = ACTIONS(223),
-    [anon_sym_LBRACK] = ACTIONS(221),
-    [anon_sym_EQ] = ACTIONS(223),
-    [anon_sym_none] = ACTIONS(223),
-    [anon_sym_some] = ACTIONS(223),
-    [anon_sym_COLON] = ACTIONS(221),
-    [anon_sym_DOT_DOT] = ACTIONS(221),
-    [anon_sym_PLUS] = ACTIONS(223),
-    [anon_sym_DASH] = ACTIONS(223),
-    [anon_sym_STAR] = ACTIONS(221),
-    [anon_sym_SLASH] = ACTIONS(221),
-    [anon_sym_PERCENT] = ACTIONS(221),
-    [anon_sym_EQ_EQ] = ACTIONS(221),
-    [anon_sym_BANG_EQ] = ACTIONS(221),
-    [anon_sym_AMP_AMP] = ACTIONS(221),
-    [anon_sym_PIPE_PIPE] = ACTIONS(221),
-    [anon_sym_GT] = ACTIONS(223),
-    [anon_sym_LT] = ACTIONS(223),
-    [anon_sym_GT_EQ] = ACTIONS(221),
-    [anon_sym_LT_EQ] = ACTIONS(221),
-    [anon_sym_PLUS_EQ] = ACTIONS(221),
-    [anon_sym_DASH_EQ] = ACTIONS(221),
-    [anon_sym_if] = ACTIONS(223),
-    [anon_sym_match] = ACTIONS(223),
-    [anon_sym_while] = ACTIONS(223),
-    [anon_sym_for] = ACTIONS(223),
-    [anon_sym_asyncfor] = ACTIONS(221),
-    [anon_sym_return] = ACTIONS(223),
-    [anon_sym_DASH_GT] = ACTIONS(221),
-    [anon_sym_assert] = ACTIONS(223),
-    [anon_sym_assert_equal] = ACTIONS(223),
-    [anon_sym_bash] = ACTIONS(223),
-    [anon_sym_download] = ACTIONS(223),
-    [anon_sym_either_or] = ACTIONS(223),
-    [anon_sym_fish] = ACTIONS(223),
-    [anon_sym_from_json] = ACTIONS(223),
-    [anon_sym_is_none] = ACTIONS(223),
-    [anon_sym_is_some] = ACTIONS(223),
-    [anon_sym_length] = ACTIONS(223),
-    [anon_sym_metadata] = ACTIONS(223),
-    [anon_sym_output] = ACTIONS(223),
-    [anon_sym_output_error] = ACTIONS(223),
-    [anon_sym_random] = ACTIONS(223),
-    [anon_sym_random_boolean] = ACTIONS(223),
-    [anon_sym_random_float] = ACTIONS(223),
-    [anon_sym_random_integer] = ACTIONS(223),
-    [anon_sym_read] = ACTIONS(223),
-    [anon_sym_to_json] = ACTIONS(223),
-    [anon_sym_write] = ACTIONS(223),
-    [anon_sym_std] = ACTIONS(223),
   },
 };
 
 static const uint16_t ts_small_parse_table[] = {
-  [0] = 6,
+  [0] = 30,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(333), 1,
-      anon_sym_DASH_GT,
-    STATE(170), 1,
-      sym_math_operator,
-    STATE(171), 1,
-      sym_logic_operator,
-    ACTIONS(203), 23,
-      anon_sym_SEMI,
+    ACTIONS(126), 1,
+      sym_identifier,
+    ACTIONS(128), 1,
       anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(205), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [72] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(335), 1,
-      anon_sym_DASH_GT,
-    STATE(199), 1,
-      sym_math_operator,
-    STATE(200), 1,
-      sym_logic_operator,
-    ACTIONS(197), 19,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      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_asyncfor,
-    ACTIONS(199), 36,
+    ACTIONS(130), 1,
       anon_sym_async,
-      sym__identifier_pattern,
+    ACTIONS(132), 1,
+      anon_sym_LBRACE,
+    ACTIONS(134), 1,
       sym_integer,
-      anon_sym_true,
-      anon_sym_false,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
       anon_sym_none,
+    ACTIONS(144), 1,
       anon_sym_some,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
+    ACTIONS(146), 1,
       anon_sym_if,
+    ACTIONS(148), 1,
       anon_sym_match,
+    ACTIONS(150), 1,
       anon_sym_while,
+    ACTIONS(152), 1,
       anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [144] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(170), 1,
-      sym_math_operator,
-    STATE(171), 1,
-      sym_logic_operator,
-    ACTIONS(207), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(209), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [214] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(335), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(341), 1,
-      anon_sym_SEMI,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    STATE(199), 1,
-      sym_math_operator,
-    STATE(200), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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(337), 8,
-      ts_builtin_sym_end,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
+    ACTIONS(154), 1,
       anon_sym_asyncfor,
-    ACTIONS(339), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
+    ACTIONS(156), 1,
       anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [296] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(335), 1,
-      anon_sym_DASH_GT,
-    STATE(199), 1,
-      sym_math_operator,
-    STATE(200), 1,
-      sym_logic_operator,
-    ACTIONS(203), 19,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      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_asyncfor,
-    ACTIONS(205), 36,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [368] = 10,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(335), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    STATE(199), 1,
-      sym_math_operator,
-    STATE(200), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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(337), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(339), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [448] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(333), 1,
-      anon_sym_DASH_GT,
-    STATE(170), 1,
-      sym_math_operator,
-    STATE(171), 1,
-      sym_logic_operator,
-    ACTIONS(197), 23,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(199), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [520] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(225), 20,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      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_asyncfor,
-      anon_sym_DASH_GT,
-    ACTIONS(351), 36,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [587] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(263), 1,
-      anon_sym_COLON,
-    ACTIONS(225), 20,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      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_asyncfor,
-      anon_sym_DASH_GT,
-    ACTIONS(351), 36,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [654] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(353), 1,
-      anon_sym_DASH_GT,
-    STATE(186), 1,
-      sym_logic_operator,
-    STATE(202), 1,
-      sym_math_operator,
-    ACTIONS(203), 22,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(205), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [725] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(353), 1,
-      anon_sym_DASH_GT,
-    STATE(186), 1,
-      sym_logic_operator,
-    STATE(202), 1,
-      sym_math_operator,
-    ACTIONS(197), 22,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(199), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [796] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(186), 1,
-      sym_logic_operator,
-    STATE(202), 1,
-      sym_math_operator,
-    ACTIONS(207), 23,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(209), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [865] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(329), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(331), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [929] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(281), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(283), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [993] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(293), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(295), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1057] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(277), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(279), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1121] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(235), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(237), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1185] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(289), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(291), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1249] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(211), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(213), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1313] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(321), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(323), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1377] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(267), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(269), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1441] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(297), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(299), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1505] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(247), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(249), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1569] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(251), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(253), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1633] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(255), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(257), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1697] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(259), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(261), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1761] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(263), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(265), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1825] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(285), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(287), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1889] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(355), 1,
-      anon_sym_DOT_DOT,
-    ACTIONS(297), 23,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(299), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [1955] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(217), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(219), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2019] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(221), 22,
-      anon_sym_SEMI,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(223), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2087] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(303), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2151] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(243), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(245), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2215] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(309), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(311), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2279] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(305), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(307), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2343] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(221), 23,
-      anon_sym_SEMI,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(223), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2409] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(271), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(273), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2473] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(325), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(327), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2537] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(239), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(241), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2601] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(263), 23,
-      anon_sym_SEMI,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(265), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2667] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(317), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(319), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2731] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(221), 23,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(223), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2797] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(313), 24,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      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,
-    ACTIONS(315), 32,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_EQ,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2861] = 10,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(227), 1,
-      anon_sym_EQ,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(231), 1,
-      anon_sym_LT,
-    STATE(34), 1,
-      sym_assignment_operator,
-    STATE(412), 1,
-      sym_type_definition,
-    ACTIONS(233), 2,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-    ACTIONS(221), 17,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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_DASH_GT,
-    ACTIONS(223), 30,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [2938] = 26,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(359), 1,
-      anon_sym_RBRACE,
-    ACTIONS(361), 1,
-      anon_sym_STAR,
-    STATE(54), 1,
+    STATE(59), 1,
       sym__function_expression_kind,
-    STATE(131), 1,
-      aux_sym_match_repeat1,
-    STATE(227), 1,
+    STATE(114), 1,
       sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(374), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
+    STATE(119), 1,
       sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [3046] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(227), 1,
-      anon_sym_EQ,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    STATE(33), 1,
-      sym_assignment_operator,
-    ACTIONS(233), 2,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-    ACTIONS(221), 17,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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_DASH_GT,
-    ACTIONS(223), 31,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [3118] = 26,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(361), 1,
-      anon_sym_STAR,
-    ACTIONS(363), 1,
-      anon_sym_RBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(131), 1,
-      aux_sym_match_repeat1,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(374), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [3226] = 26,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(365), 1,
-      sym__identifier_pattern,
-    ACTIONS(368), 1,
-      anon_sym_LPAREN,
-    ACTIONS(371), 1,
-      anon_sym_LBRACE,
-    ACTIONS(374), 1,
-      anon_sym_RBRACE,
-    ACTIONS(376), 1,
-      sym_integer,
-    ACTIONS(385), 1,
-      anon_sym_LBRACK,
-    ACTIONS(388), 1,
-      anon_sym_none,
-    ACTIONS(391), 1,
-      anon_sym_some,
-    ACTIONS(394), 1,
-      anon_sym_STAR,
-    ACTIONS(400), 1,
-      anon_sym_std,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(131), 1,
-      aux_sym_match_repeat1,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(374), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(379), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(382), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(397), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [3334] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(403), 1,
-      anon_sym_RPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(332), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(375), 1,
-      sym_expression,
-    STATE(385), 1,
-      sym_function_call,
-    STATE(433), 1,
-      sym__function_expression_kind,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(393), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [3443] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(403), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(332), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(378), 1,
-      sym_expression,
-    STATE(388), 1,
-      sym_function_call,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [3552] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(405), 1,
-      anon_sym_RPAREN,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(142), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [3657] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(409), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(142), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [3762] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(411), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(329), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(378), 1,
-      sym_expression,
-    STATE(384), 1,
-      sym_function_call,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [3871] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(413), 1,
-      anon_sym_DASH_GT,
-    STATE(173), 1,
-      sym_logic_operator,
-    STATE(219), 1,
-      sym_math_operator,
-    ACTIONS(197), 20,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(199), 30,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [3938] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(413), 1,
-      anon_sym_DASH_GT,
-    STATE(173), 1,
-      sym_logic_operator,
-    STATE(219), 1,
-      sym_math_operator,
-    ACTIONS(203), 20,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(205), 30,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [4005] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(415), 1,
-      anon_sym_RPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(330), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(375), 1,
-      sym_expression,
-    STATE(385), 1,
-      sym_function_call,
-    STATE(426), 1,
-      sym__function_expression_kind,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(393), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4114] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(417), 1,
-      anon_sym_RBRACK,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(153), 1,
-      aux_sym_list_repeat1,
-    STATE(221), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4219] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(419), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(147), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4324] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(421), 1,
-      sym__identifier_pattern,
-    ACTIONS(424), 1,
-      anon_sym_LPAREN,
-    ACTIONS(427), 1,
-      anon_sym_RPAREN,
-    ACTIONS(429), 1,
-      anon_sym_LBRACE,
-    ACTIONS(432), 1,
-      sym_integer,
-    ACTIONS(441), 1,
-      anon_sym_LBRACK,
-    ACTIONS(444), 1,
-      anon_sym_none,
-    ACTIONS(447), 1,
-      anon_sym_some,
-    ACTIONS(453), 1,
-      anon_sym_std,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(142), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(435), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(438), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(450), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4429] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(456), 1,
-      anon_sym_RBRACK,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(159), 1,
-      aux_sym_list_repeat1,
-    STATE(221), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4534] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(458), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(158), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4639] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(361), 1,
-      anon_sym_STAR,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(128), 1,
-      aux_sym_match_repeat1,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(374), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4744] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(403), 1,
-      anon_sym_RPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(332), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(375), 1,
-      sym_expression,
-    STATE(385), 1,
-      sym_function_call,
-    STATE(433), 1,
-      sym__function_expression_kind,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(397), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4853] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(460), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(142), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [4958] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(462), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(135), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5063] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(464), 1,
-      anon_sym_RBRACK,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(143), 1,
-      aux_sym_list_repeat1,
-    STATE(221), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5168] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(415), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(330), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(376), 1,
-      sym_function_call,
-    STATE(378), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5277] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(466), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(142), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5382] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(468), 1,
-      anon_sym_RBRACK,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(159), 1,
-      aux_sym_list_repeat1,
-    STATE(221), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5487] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(470), 1,
-      anon_sym_RBRACK,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(159), 1,
-      aux_sym_list_repeat1,
-    STATE(221), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5592] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(415), 1,
-      anon_sym_RPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(330), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(375), 1,
-      sym_expression,
-    STATE(385), 1,
-      sym_function_call,
-    STATE(433), 1,
-      sym__function_expression_kind,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(399), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5701] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(472), 1,
-      anon_sym_RBRACK,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(152), 1,
-      aux_sym_list_repeat1,
-    STATE(221), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5806] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(411), 1,
-      anon_sym_RPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(329), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(375), 1,
-      sym_expression,
-    STATE(385), 1,
-      sym_function_call,
-    STATE(427), 1,
-      sym__function_expression_kind,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(393), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [5915] = 27,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(411), 1,
-      anon_sym_RPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(230), 1,
-      sym_index,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(251), 1,
-      sym_yield,
-    STATE(329), 1,
-      aux_sym_function_repeat1,
-    STATE(362), 1,
-      sym_identifier,
-    STATE(375), 1,
-      sym_expression,
-    STATE(385), 1,
-      sym_function_call,
-    STATE(433), 1,
-      sym__function_expression_kind,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(393), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [6024] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(474), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(142), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [6129] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(476), 1,
-      sym__identifier_pattern,
-    ACTIONS(479), 1,
-      anon_sym_LPAREN,
-    ACTIONS(482), 1,
-      anon_sym_LBRACE,
-    ACTIONS(485), 1,
-      sym_integer,
-    ACTIONS(494), 1,
-      anon_sym_LBRACK,
-    ACTIONS(497), 1,
-      anon_sym_RBRACK,
-    ACTIONS(499), 1,
-      anon_sym_none,
-    ACTIONS(502), 1,
-      anon_sym_some,
-    ACTIONS(508), 1,
-      anon_sym_std,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(159), 1,
-      aux_sym_list_repeat1,
-    STATE(221), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(488), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(491), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(505), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [6234] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(511), 1,
-      anon_sym_RPAREN,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(142), 1,
-      aux_sym__expression_list,
-    STATE(220), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [6339] = 25,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(361), 1,
-      anon_sym_STAR,
-    STATE(54), 1,
-      sym__function_expression_kind,
     STATE(130), 1,
-      aux_sym_match_repeat1,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(374), 1,
       sym_expression,
-    STATE(446), 1,
+    STATE(267), 1,
+      sym_if,
+    STATE(291), 1,
+      sym_statement,
+    STATE(427), 1,
       sym_function_expression,
-    STATE(454), 1,
+    STATE(435), 1,
       sym_index_expression,
-    ACTIONS(175), 2,
+    ACTIONS(136), 2,
       sym_float,
       sym_string,
-    ACTIONS(177), 2,
+    ACTIONS(138), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
+    STATE(103), 2,
       sym_function_call,
       sym_yield,
-    STATE(252), 3,
+    STATE(106), 3,
       sym__expression_kind,
       sym_math,
       sym_logic,
-    STATE(232), 4,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [6444] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(263), 1,
-      anon_sym_COLON,
-    ACTIONS(225), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(351), 30,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [6506] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(225), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(351), 30,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [6568] = 20,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(513), 1,
-      anon_sym_LPAREN,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(117), 1,
-      sym_function_expression,
-    STATE(227), 1,
-      sym_value,
-    STATE(380), 1,
-      sym_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    STATE(122), 7,
-      sym_identifier,
-      sym_index,
       sym_function,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
       sym_built_in_value,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [6661] = 10,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(413), 1,
-      anon_sym_DASH_GT,
-    STATE(173), 1,
-      sym_logic_operator,
-    STATE(219), 1,
-      sym_math_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 3,
-      anon_sym_PLUS,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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(337), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(339), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [6734] = 23,
+    STATE(289), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [113] = 30,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(5), 1,
-      sym__identifier_pattern,
+      sym_identifier,
     ACTIONS(7), 1,
       anon_sym_LPAREN,
+    ACTIONS(9), 1,
+      anon_sym_async,
+    ACTIONS(11), 1,
+      anon_sym_LBRACE,
     ACTIONS(13), 1,
       sym_integer,
     ACTIONS(19), 1,
@@ -14408,4200 +4158,3552 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_none,
     ACTIONS(23), 1,
       anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
-      anon_sym_LBRACE,
-    STATE(45), 1,
-      sym_expression,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(54), 1,
+    ACTIONS(25), 1,
+      anon_sym_if,
+    ACTIONS(27), 1,
+      anon_sym_match,
+    ACTIONS(29), 1,
+      anon_sym_while,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_asyncfor,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    STATE(59), 1,
       sym__function_expression_kind,
-    STATE(63), 1,
-      sym_value,
-    STATE(441), 1,
-      sym_index_expression,
-    STATE(442), 1,
-      sym_function_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(68), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(72), 2,
-      sym_identifier,
+    STATE(65), 1,
       sym_index,
-    STATE(83), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(57), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(61), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [6833] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
+    STATE(75), 1,
       sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(346), 1,
+    STATE(82), 1,
       sym_expression,
-    STATE(444), 1,
-      sym_index_expression,
-    STATE(446), 1,
+    STATE(212), 1,
+      sym_if,
+    STATE(258), 1,
+      sym_statement,
+    STATE(437), 1,
       sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(363), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [6932] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(413), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(517), 1,
-      anon_sym_SEMI,
-    STATE(173), 1,
-      sym_logic_operator,
-    STATE(219), 1,
-      sym_math_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 3,
-      anon_sym_PLUS,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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(337), 8,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(339), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [7007] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(347), 1,
-      sym_expression,
-    STATE(444), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(363), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7106] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(90), 1,
-      sym_expression,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
     STATE(438), 1,
       sym_index_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7205] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(84), 1,
-      sym_expression,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(438), 1,
-      sym_index_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7304] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(7), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_none,
-    ACTIONS(23), 1,
-      anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
-      anon_sym_LBRACE,
-    STATE(44), 1,
-      sym_expression,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(63), 1,
-      sym_value,
-    STATE(441), 1,
-      sym_index_expression,
-    STATE(442), 1,
-      sym_function_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(68), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(72), 2,
-      sym_identifier,
-      sym_index,
-    STATE(83), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(57), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(61), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7403] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(138), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7502] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(224), 1,
-      sym_expression,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(444), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7601] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(368), 1,
-      sym_expression,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(363), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7700] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(355), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7799] = 20,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(519), 1,
-      anon_sym_LPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(76), 1,
-      sym_function_expression,
-    STATE(227), 1,
-      sym_value,
-    STATE(383), 1,
-      sym_expression,
-    STATE(448), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    STATE(54), 7,
-      sym_identifier,
-      sym_index,
-      sym_function,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-      sym_built_in_value,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7892] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(95), 1,
-      sym_expression,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [7991] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(367), 1,
-      sym_expression,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(363), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8090] = 20,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(513), 1,
-      anon_sym_LPAREN,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(117), 1,
-      sym_function_expression,
-    STATE(227), 1,
-      sym_value,
-    STATE(390), 1,
-      sym_expression,
-    STATE(438), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    STATE(122), 7,
-      sym_identifier,
-      sym_index,
-      sym_function,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-      sym_built_in_value,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8183] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(240), 1,
-      sym_expression,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8282] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(253), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8381] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(353), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8480] = 20,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(519), 1,
-      anon_sym_LPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(76), 1,
-      sym_function_expression,
-    STATE(227), 1,
-      sym_value,
-    STATE(392), 1,
-      sym_expression,
-    STATE(441), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    STATE(54), 7,
-      sym_identifier,
-      sym_index,
-      sym_function,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-      sym_built_in_value,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8573] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(357), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8672] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(93), 1,
-      sym_expression,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(106), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(110), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8771] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(7), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_none,
-    ACTIONS(23), 1,
-      anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
-      anon_sym_LBRACE,
-    STATE(47), 1,
-      sym_expression,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(63), 1,
-      sym_value,
-    STATE(442), 1,
-      sym_function_expression,
-    STATE(448), 1,
-      sym_index_expression,
     ACTIONS(15), 2,
       sym_float,
       sym_string,
     ACTIONS(17), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(68), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(72), 2,
-      sym_identifier,
-      sym_index,
-    STATE(83), 2,
+    STATE(58), 2,
       sym_function_call,
       sym_yield,
-    STATE(57), 3,
+    STATE(66), 3,
       sym__expression_kind,
       sym_math,
       sym_logic,
-    STATE(61), 4,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8870] = 22,
+      sym_function,
+      sym_built_in_value,
+    STATE(265), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [226] = 30,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(519), 1,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(160), 1,
+      sym_identifier,
+    ACTIONS(162), 1,
       anon_sym_LPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(76), 1,
-      sym_function_expression,
-    STATE(227), 1,
+    ACTIONS(164), 1,
+      anon_sym_async,
+    ACTIONS(166), 1,
+      anon_sym_LBRACE,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(180), 1,
+      anon_sym_while,
+    ACTIONS(182), 1,
+      anon_sym_for,
+    ACTIONS(184), 1,
+      anon_sym_asyncfor,
+    ACTIONS(186), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(237), 1,
       sym_value,
-    STATE(389), 1,
+    STATE(277), 1,
+      sym_index,
+    STATE(297), 1,
+      sym_statement,
+    STATE(304), 1,
       sym_expression,
-    STATE(448), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(91), 2,
-      sym_identifier,
-      sym_index,
-    STATE(92), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(54), 3,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [8967] = 22,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(521), 1,
-      anon_sym_LPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(229), 1,
-      sym_function_expression,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(387), 1,
-      sym_expression,
-    STATE(435), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(264), 2,
-      sym_identifier,
-      sym_index,
-    STATE(266), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(249), 3,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9064] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
     STATE(372), 1,
-      sym_expression,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
+      sym_if,
+    STATE(439), 1,
       sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(363), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9163] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(371), 1,
-      sym_expression,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(363), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9262] = 20,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(521), 1,
-      anon_sym_LPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(229), 1,
-      sym_function_expression,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(377), 1,
-      sym_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    STATE(249), 7,
-      sym_identifier,
-      sym_index,
-      sym_function,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-      sym_built_in_value,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9355] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(349), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9454] = 20,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(521), 1,
-      anon_sym_LPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(229), 1,
-      sym_function_expression,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(386), 1,
-      sym_expression,
-    STATE(435), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    STATE(249), 7,
-      sym_identifier,
-      sym_index,
-      sym_function,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-      sym_built_in_value,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9547] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(271), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9646] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(273), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9745] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(250), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9844] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(356), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [9943] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(7), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_none,
-    ACTIONS(23), 1,
-      anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
-      anon_sym_LBRACE,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(63), 1,
-      sym_value,
-    STATE(85), 1,
-      sym_expression,
     STATE(442), 1,
-      sym_function_expression,
-    STATE(448), 1,
       sym_index_expression,
-    ACTIONS(15), 2,
+    ACTIONS(170), 2,
       sym_float,
       sym_string,
-    ACTIONS(17), 2,
+    ACTIONS(172), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(68), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(72), 2,
-      sym_identifier,
-      sym_index,
-    STATE(83), 2,
+    STATE(241), 2,
       sym_function_call,
       sym_yield,
-    STATE(57), 3,
+    STATE(231), 3,
       sym__expression_kind,
       sym_math,
       sym_logic,
-    STATE(61), 4,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10042] = 23,
+      sym_function,
+      sym_built_in_value,
+    STATE(289), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [339] = 30,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(7), 1,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(160), 1,
+      sym_identifier,
+    ACTIONS(162), 1,
       anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_none,
-    ACTIONS(23), 1,
-      anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
+    ACTIONS(164), 1,
+      anon_sym_async,
+    ACTIONS(166), 1,
       anon_sym_LBRACE,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(54), 1,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(180), 1,
+      anon_sym_while,
+    ACTIONS(182), 1,
+      anon_sym_for,
+    ACTIONS(184), 1,
+      anon_sym_asyncfor,
+    ACTIONS(186), 1,
+      anon_sym_return,
+    STATE(59), 1,
       sym__function_expression_kind,
-    STATE(63), 1,
+    STATE(237), 1,
       sym_value,
-    STATE(88), 1,
+    STATE(277), 1,
+      sym_index,
+    STATE(299), 1,
+      sym_statement,
+    STATE(304), 1,
       sym_expression,
+    STATE(372), 1,
+      sym_if,
+    STATE(439), 1,
+      sym_function_expression,
     STATE(442), 1,
-      sym_function_expression,
-    STATE(448), 1,
       sym_index_expression,
-    ACTIONS(15), 2,
+    ACTIONS(170), 2,
       sym_float,
       sym_string,
-    ACTIONS(17), 2,
+    ACTIONS(172), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(68), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(72), 2,
-      sym_identifier,
-      sym_index,
-    STATE(83), 2,
+    STATE(241), 2,
       sym_function_call,
       sym_yield,
-    STATE(57), 3,
+    STATE(231), 3,
       sym__expression_kind,
       sym_math,
       sym_logic,
-    STATE(61), 4,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10141] = 23,
+      sym_function,
+      sym_built_in_value,
+    STATE(289), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [452] = 30,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(160), 1,
+      sym_identifier,
+    ACTIONS(162), 1,
       anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
+    ACTIONS(164), 1,
+      anon_sym_async,
+    ACTIONS(166), 1,
       anon_sym_LBRACE,
-    STATE(54), 1,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(180), 1,
+      anon_sym_while,
+    ACTIONS(182), 1,
+      anon_sym_for,
+    ACTIONS(184), 1,
+      anon_sym_asyncfor,
+    ACTIONS(186), 1,
+      anon_sym_return,
+    STATE(59), 1,
       sym__function_expression_kind,
-    STATE(227), 1,
+    STATE(237), 1,
       sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(351), 1,
+    STATE(277), 1,
+      sym_index,
+    STATE(291), 1,
+      sym_statement,
+    STATE(304), 1,
       sym_expression,
+    STATE(372), 1,
+      sym_if,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(289), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [565] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(126), 1,
+      sym_identifier,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(130), 1,
+      anon_sym_async,
+    ACTIONS(132), 1,
+      anon_sym_LBRACE,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(150), 1,
+      anon_sym_while,
+    ACTIONS(152), 1,
+      anon_sym_for,
+    ACTIONS(154), 1,
+      anon_sym_asyncfor,
+    ACTIONS(156), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(114), 1,
+      sym_value,
+    STATE(119), 1,
+      sym_index,
+    STATE(130), 1,
+      sym_expression,
+    STATE(267), 1,
+      sym_if,
+    STATE(299), 1,
+      sym_statement,
+    STATE(427), 1,
+      sym_function_expression,
     STATE(435), 1,
       sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
+    ACTIONS(136), 2,
       sym_float,
       sym_string,
-    ACTIONS(177), 2,
+    ACTIONS(138), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(363), 2,
+    STATE(103), 2,
       sym_function_call,
       sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10240] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(94), 1,
-      sym_expression,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
     STATE(106), 3,
       sym__expression_kind,
       sym_math,
       sym_logic,
-    STATE(110), 4,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10339] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(373), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
       sym_function,
       sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10438] = 23,
+    STATE(289), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [678] = 30,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(359), 1,
-      sym_expression,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(363), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(160), 1,
       sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10537] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
+    ACTIONS(162), 1,
       anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
+    ACTIONS(164), 1,
+      anon_sym_async,
+    ACTIONS(166), 1,
       anon_sym_LBRACE,
-    STATE(54), 1,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(180), 1,
+      anon_sym_while,
+    ACTIONS(182), 1,
+      anon_sym_for,
+    ACTIONS(184), 1,
+      anon_sym_asyncfor,
+    ACTIONS(186), 1,
+      anon_sym_return,
+    STATE(59), 1,
       sym__function_expression_kind,
-    STATE(227), 1,
+    STATE(237), 1,
       sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(360), 1,
+    STATE(277), 1,
+      sym_index,
+    STATE(303), 1,
       sym_expression,
-    STATE(435), 1,
-      sym_index_expression,
-    STATE(446), 1,
+    STATE(372), 1,
+      sym_if,
+    STATE(390), 1,
+      sym_statement,
+    STATE(439), 1,
       sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(363), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10636] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(358), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10735] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(370), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10834] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(350), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [10933] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(361), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11032] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(7), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_none,
-    ACTIONS(23), 1,
-      anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
-      anon_sym_LBRACE,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(51), 1,
-      sym_expression,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(63), 1,
-      sym_value,
     STATE(442), 1,
-      sym_function_expression,
-    STATE(448), 1,
       sym_index_expression,
-    ACTIONS(15), 2,
+    ACTIONS(170), 2,
       sym_float,
       sym_string,
-    ACTIONS(17), 2,
+    ACTIONS(172), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(68), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(72), 2,
-      sym_identifier,
-      sym_index,
-    STATE(83), 2,
+    STATE(241), 2,
       sym_function_call,
       sym_yield,
-    STATE(57), 3,
+    STATE(231), 3,
       sym__expression_kind,
       sym_math,
       sym_logic,
-    STATE(61), 4,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11131] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(7), 1,
-      anon_sym_LPAREN,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_none,
-    ACTIONS(23), 1,
-      anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
-      anon_sym_LBRACE,
-    STATE(49), 1,
-      sym_expression,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(63), 1,
-      sym_value,
-    STATE(442), 1,
-      sym_function_expression,
-    STATE(448), 1,
-      sym_index_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(68), 2,
       sym_function,
       sym_built_in_value,
-    STATE(72), 2,
-      sym_identifier,
-      sym_index,
-    STATE(83), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(57), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(61), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11230] = 23,
+    STATE(292), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [791] = 30,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
+    ACTIONS(126), 1,
+      sym_identifier,
+    ACTIONS(128), 1,
       anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
+    ACTIONS(130), 1,
+      anon_sym_async,
+    ACTIONS(132), 1,
       anon_sym_LBRACE,
-    STATE(54), 1,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(150), 1,
+      anon_sym_while,
+    ACTIONS(152), 1,
+      anon_sym_for,
+    ACTIONS(154), 1,
+      anon_sym_asyncfor,
+    ACTIONS(156), 1,
+      anon_sym_return,
+    STATE(59), 1,
       sym__function_expression_kind,
-    STATE(227), 1,
+    STATE(114), 1,
       sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(369), 1,
+    STATE(119), 1,
+      sym_index,
+    STATE(132), 1,
       sym_expression,
+    STATE(267), 1,
+      sym_if,
+    STATE(302), 1,
+      sym_statement,
+    STATE(427), 1,
+      sym_function_expression,
     STATE(435), 1,
       sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
+    ACTIONS(136), 2,
       sym_float,
       sym_string,
-    ACTIONS(177), 2,
+    ACTIONS(138), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(363), 2,
+    STATE(103), 2,
       sym_function_call,
       sym_yield,
-    STATE(364), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(366), 2,
-      sym_identifier,
-      sym_index,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11329] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(354), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11428] = 20,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(521), 1,
-      anon_sym_LPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(229), 1,
-      sym_function_expression,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(382), 1,
-      sym_expression,
-    STATE(444), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    STATE(249), 7,
-      sym_identifier,
-      sym_index,
-      sym_function,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-      sym_built_in_value,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11521] = 22,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(521), 1,
-      anon_sym_LPAREN,
-    STATE(227), 1,
-      sym_value,
-    STATE(229), 1,
-      sym_function_expression,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(378), 1,
-      sym_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(264), 2,
-      sym_identifier,
-      sym_index,
-    STATE(266), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(249), 3,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11618] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(223), 1,
-      sym_expression,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(444), 1,
-      sym_index_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11717] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(167), 1,
-      anon_sym_LPAREN,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(227), 1,
-      sym_value,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(352), 1,
-      sym_expression,
-    STATE(446), 1,
-      sym_function_expression,
-    STATE(454), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(230), 2,
-      sym_identifier,
-      sym_index,
-    STATE(242), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(251), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11816] = 22,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(513), 1,
-      anon_sym_LPAREN,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(117), 1,
-      sym_function_expression,
-    STATE(227), 1,
-      sym_value,
-    STATE(391), 1,
-      sym_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(162), 2,
-      sym_function,
-      sym_built_in_value,
-    STATE(163), 2,
-      sym_identifier,
-      sym_index,
-    STATE(122), 3,
-      sym__function_expression_kind,
-      sym_function_call,
-      sym_yield,
-    STATE(252), 3,
-      sym__expression_kind,
-      sym_math,
-      sym_logic,
-    STATE(232), 4,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [11913] = 23,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(131), 1,
-      anon_sym_LPAREN,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    STATE(54), 1,
-      sym__function_expression_kind,
-    STATE(113), 1,
-      sym_built_in_function,
-    STATE(125), 1,
-      sym_value,
-    STATE(137), 1,
-      sym_expression,
-    STATE(458), 1,
-      sym_function_expression,
-    STATE(459), 1,
-      sym_index_expression,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(114), 2,
-      sym_identifier,
-      sym_index,
-    STATE(119), 2,
-      sym_function_call,
-      sym_yield,
-    STATE(123), 2,
-      sym_function,
-      sym_built_in_value,
     STATE(106), 3,
       sym__expression_kind,
       sym_math,
       sym_logic,
-    STATE(110), 4,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12012] = 11,
+      sym_function,
+      sym_built_in_value,
+    STATE(292), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [904] = 30,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(413), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(527), 1,
-      anon_sym_COMMA,
-    STATE(173), 1,
+    ACTIONS(126), 1,
+      sym_identifier,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(130), 1,
+      anon_sym_async,
+    ACTIONS(132), 1,
+      anon_sym_LBRACE,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(150), 1,
+      anon_sym_while,
+    ACTIONS(152), 1,
+      anon_sym_for,
+    ACTIONS(154), 1,
+      anon_sym_asyncfor,
+    ACTIONS(156), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(114), 1,
+      sym_value,
+    STATE(119), 1,
+      sym_index,
+    STATE(130), 1,
+      sym_expression,
+    STATE(267), 1,
+      sym_if,
+    STATE(290), 1,
+      sym_statement,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(289), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1017] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(160), 1,
+      sym_identifier,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(164), 1,
+      anon_sym_async,
+    ACTIONS(166), 1,
+      anon_sym_LBRACE,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(180), 1,
+      anon_sym_while,
+    ACTIONS(182), 1,
+      anon_sym_for,
+    ACTIONS(184), 1,
+      anon_sym_asyncfor,
+    ACTIONS(186), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(237), 1,
+      sym_value,
+    STATE(277), 1,
+      sym_index,
+    STATE(290), 1,
+      sym_statement,
+    STATE(304), 1,
+      sym_expression,
+    STATE(372), 1,
+      sym_if,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(289), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1130] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(126), 1,
+      sym_identifier,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(130), 1,
+      anon_sym_async,
+    ACTIONS(132), 1,
+      anon_sym_LBRACE,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(150), 1,
+      anon_sym_while,
+    ACTIONS(152), 1,
+      anon_sym_for,
+    ACTIONS(154), 1,
+      anon_sym_asyncfor,
+    ACTIONS(156), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(114), 1,
+      sym_value,
+    STATE(119), 1,
+      sym_index,
+    STATE(130), 1,
+      sym_expression,
+    STATE(267), 1,
+      sym_if,
+    STATE(297), 1,
+      sym_statement,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(289), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1243] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(160), 1,
+      sym_identifier,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(164), 1,
+      anon_sym_async,
+    ACTIONS(166), 1,
+      anon_sym_LBRACE,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(180), 1,
+      anon_sym_while,
+    ACTIONS(182), 1,
+      anon_sym_for,
+    ACTIONS(184), 1,
+      anon_sym_asyncfor,
+    ACTIONS(186), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(237), 1,
+      sym_value,
+    STATE(277), 1,
+      sym_index,
+    STATE(303), 1,
+      sym_expression,
+    STATE(372), 1,
+      sym_if,
+    STATE(390), 1,
+      sym_statement,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(292), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1356] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(160), 1,
+      sym_identifier,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(164), 1,
+      anon_sym_async,
+    ACTIONS(166), 1,
+      anon_sym_LBRACE,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(180), 1,
+      anon_sym_while,
+    ACTIONS(182), 1,
+      anon_sym_for,
+    ACTIONS(184), 1,
+      anon_sym_asyncfor,
+    ACTIONS(186), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(237), 1,
+      sym_value,
+    STATE(277), 1,
+      sym_index,
+    STATE(303), 1,
+      sym_expression,
+    STATE(372), 1,
+      sym_if,
+    STATE(388), 1,
+      sym_statement,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(292), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1469] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(9), 1,
+      anon_sym_async,
+    ACTIONS(11), 1,
+      anon_sym_LBRACE,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(25), 1,
+      anon_sym_if,
+    ACTIONS(27), 1,
+      anon_sym_match,
+    ACTIONS(29), 1,
+      anon_sym_while,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_asyncfor,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(65), 1,
+      sym_index,
+    STATE(75), 1,
+      sym_value,
+    STATE(82), 1,
+      sym_expression,
+    STATE(212), 1,
+      sym_if,
+    STATE(264), 1,
+      sym_statement,
+    STATE(437), 1,
+      sym_function_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(265), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1582] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(9), 1,
+      anon_sym_async,
+    ACTIONS(11), 1,
+      anon_sym_LBRACE,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(25), 1,
+      anon_sym_if,
+    ACTIONS(27), 1,
+      anon_sym_match,
+    ACTIONS(29), 1,
+      anon_sym_while,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_asyncfor,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(65), 1,
+      sym_index,
+    STATE(75), 1,
+      sym_value,
+    STATE(82), 1,
+      sym_expression,
+    STATE(212), 1,
+      sym_if,
+    STATE(263), 1,
+      sym_statement,
+    STATE(437), 1,
+      sym_function_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(265), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1695] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(5), 1,
+      sym_identifier,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(9), 1,
+      anon_sym_async,
+    ACTIONS(11), 1,
+      anon_sym_LBRACE,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(25), 1,
+      anon_sym_if,
+    ACTIONS(27), 1,
+      anon_sym_match,
+    ACTIONS(29), 1,
+      anon_sym_while,
+    ACTIONS(31), 1,
+      anon_sym_for,
+    ACTIONS(33), 1,
+      anon_sym_asyncfor,
+    ACTIONS(35), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(65), 1,
+      sym_index,
+    STATE(75), 1,
+      sym_value,
+    STATE(82), 1,
+      sym_expression,
+    STATE(212), 1,
+      sym_if,
+    STATE(254), 1,
+      sym_statement,
+    STATE(437), 1,
+      sym_function_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(265), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1808] = 30,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(146), 1,
+      anon_sym_if,
+    ACTIONS(148), 1,
+      anon_sym_match,
+    ACTIONS(160), 1,
+      sym_identifier,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(164), 1,
+      anon_sym_async,
+    ACTIONS(166), 1,
+      anon_sym_LBRACE,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(180), 1,
+      anon_sym_while,
+    ACTIONS(182), 1,
+      anon_sym_for,
+    ACTIONS(184), 1,
+      anon_sym_asyncfor,
+    ACTIONS(186), 1,
+      anon_sym_return,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(237), 1,
+      sym_value,
+    STATE(277), 1,
+      sym_index,
+    STATE(303), 1,
+      sym_expression,
+    STATE(372), 1,
+      sym_if,
+    STATE(388), 1,
+      sym_statement,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+    STATE(292), 8,
+      sym_block,
+      sym_assignment,
+      sym_index_assignment,
+      sym_if_else,
+      sym_match,
+      sym_while,
+      sym_for,
+      sym_return,
+  [1921] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(193), 1,
       sym_logic_operator,
-    STATE(219), 1,
+    STATE(197), 1,
       sym_math_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
+    ACTIONS(190), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_COLON,
+      anon_sym_DOT_DOT,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(347), 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(525), 6,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+    ACTIONS(192), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [1981] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(198), 1,
+      anon_sym_DASH_GT,
+    STATE(193), 1,
+      sym_logic_operator,
+    STATE(197), 1,
+      sym_math_operator,
+    ACTIONS(194), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(196), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2043] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(198), 1,
+      anon_sym_DASH_GT,
+    STATE(193), 1,
+      sym_logic_operator,
+    STATE(197), 1,
+      sym_math_operator,
+    ACTIONS(200), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(202), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2105] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(204), 1,
+      anon_sym_DASH_GT,
+    STATE(166), 1,
+      sym_logic_operator,
+    STATE(175), 1,
+      sym_math_operator,
+    ACTIONS(194), 21,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+    ACTIONS(196), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2166] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(212), 1,
+      anon_sym_EQ,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(216), 1,
+      anon_sym_LT,
+    STATE(41), 1,
+      sym_assignment_operator,
+    STATE(375), 1,
+      sym_type_definition,
+    ACTIONS(218), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+    ACTIONS(206), 18,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_asyncfor,
+      anon_sym_DASH_GT,
+    ACTIONS(208), 21,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2235] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(204), 1,
+      anon_sym_DASH_GT,
+    STATE(166), 1,
+      sym_logic_operator,
+    STATE(175), 1,
+      sym_math_operator,
+    ACTIONS(200), 21,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+    ACTIONS(202), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2296] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(166), 1,
+      sym_logic_operator,
+    STATE(175), 1,
+      sym_math_operator,
+    ACTIONS(190), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+    ACTIONS(192), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2355] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(220), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(222), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2409] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(228), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(224), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_PLUS_EQ,
+      anon_sym_DASH_EQ,
+      anon_sym_asyncfor,
+      anon_sym_DASH_GT,
+    ACTIONS(226), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2465] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(230), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(232), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2519] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(234), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(236), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2573] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(238), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(240), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2627] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(242), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(244), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2681] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(246), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(248), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2735] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(206), 22,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(208), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2791] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(250), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(252), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2845] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(254), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(256), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2899] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(258), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(260), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [2953] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(262), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(264), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3007] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(266), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(268), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3061] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(270), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(272), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3115] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(212), 1,
+      anon_sym_EQ,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    STATE(28), 1,
+      sym_assignment_operator,
+    ACTIONS(218), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+    ACTIONS(206), 18,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_asyncfor,
+      anon_sym_DASH_GT,
+    ACTIONS(208), 22,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3179] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(274), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(276), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3233] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(278), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(280), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3287] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(282), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(284), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3341] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(286), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(288), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3395] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(214), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(290), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3449] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(224), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(226), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3503] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(292), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(294), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3557] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(296), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(298), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3611] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(300), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(302), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3665] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(206), 21,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(208), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3723] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(216), 1,
+      anon_sym_LT,
+    ACTIONS(304), 1,
+      anon_sym_EQ,
+    STATE(41), 1,
+      sym_assignment_operator,
+    STATE(377), 1,
+      sym_type_definition,
+    ACTIONS(218), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+    ACTIONS(206), 17,
+      anon_sym_SEMI,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_asyncfor,
+      anon_sym_DASH_GT,
+    ACTIONS(208), 21,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3791] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(306), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(308), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3845] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(310), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(312), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3899] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(314), 23,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+    ACTIONS(316), 23,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      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_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [3953] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(318), 1,
+      anon_sym_DASH_GT,
+    STATE(207), 1,
+      sym_math_operator,
+    STATE(210), 1,
+      sym_logic_operator,
+    ACTIONS(194), 19,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      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_asyncfor,
+    ACTIONS(196), 21,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [4010] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(318), 1,
+      anon_sym_DASH_GT,
+    STATE(207), 1,
+      sym_math_operator,
+    STATE(210), 1,
+      sym_logic_operator,
+    ACTIONS(200), 19,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      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_asyncfor,
+    ACTIONS(202), 21,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [4067] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(318), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    STATE(207), 1,
+      sym_math_operator,
+    STATE(210), 1,
+      sym_logic_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(322), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [4132] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(318), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(332), 1,
+      anon_sym_SEMI,
+    STATE(207), 1,
+      sym_math_operator,
+    STATE(210), 1,
+      sym_logic_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(322), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [4199] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(189), 1,
+      sym_logic_operator,
+    STATE(190), 1,
+      sym_math_operator,
+    ACTIONS(192), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(190), 24,
+      anon_sym_SEMI,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
-      anon_sym_LBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-    ACTIONS(523), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [12086] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(413), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(533), 1,
       anon_sym_COMMA,
-    STATE(173), 1,
-      sym_logic_operator,
-    STATE(219), 1,
-      sym_math_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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(531), 6,
-      anon_sym_LPAREN,
       anon_sym_LBRACE,
+      anon_sym_RBRACE,
       sym_float,
       sym_string,
       anon_sym_LBRACK,
       anon_sym_RBRACK,
-    ACTIONS(529), 27,
-      sym__identifier_pattern,
+      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,
+  [4254] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(334), 1,
+      anon_sym_DASH_GT,
+    STATE(189), 1,
+      sym_logic_operator,
+    STATE(190), 1,
+      sym_math_operator,
+    ACTIONS(196), 17,
+      sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
+      anon_sym_EQ,
       anon_sym_none,
       anon_sym_some,
-      anon_sym_assert,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [12160] = 5,
+    ACTIONS(194), 23,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [4311] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(174), 1,
+    ACTIONS(334), 1,
+      anon_sym_DASH_GT,
+    STATE(189), 1,
       sym_logic_operator,
-    STATE(216), 1,
+    STATE(190), 1,
       sym_math_operator,
-    ACTIONS(207), 20,
+    ACTIONS(202), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(200), 23,
       anon_sym_SEMI,
       anon_sym_LPAREN,
+      anon_sym_RPAREN,
       anon_sym_COMMA,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
       anon_sym_COLON,
       anon_sym_DOT_DOT,
       anon_sym_STAR,
@@ -18615,53 +7717,45 @@ 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,
-    ACTIONS(209), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12221] = 6,
+  [4368] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(535), 1,
+    ACTIONS(336), 1,
       anon_sym_DASH_GT,
-    STATE(174), 1,
+    STATE(199), 1,
+      sym_math_operator,
+    STATE(204), 1,
       sym_logic_operator,
-    STATE(216), 1,
-      sym_math_operator,
-    ACTIONS(197), 19,
+    ACTIONS(196), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(194), 22,
       anon_sym_SEMI,
       anon_sym_LPAREN,
+      anon_sym_RPAREN,
       anon_sym_COMMA,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
       anon_sym_COLON,
-      anon_sym_DOT_DOT,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
@@ -18673,905 +7767,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,
-    ACTIONS(199), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12284] = 6,
+  [4424] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(535), 1,
+    ACTIONS(336), 1,
       anon_sym_DASH_GT,
-    STATE(174), 1,
+    STATE(199), 1,
+      sym_math_operator,
+    STATE(204), 1,
       sym_logic_operator,
-    STATE(216), 1,
-      sym_math_operator,
-    ACTIONS(203), 19,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(205), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
+    ACTIONS(202), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
       anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
       anon_sym_PLUS,
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-      anon_sym_assert,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12347] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(293), 21,
+    ACTIONS(200), 22,
       anon_sym_SEMI,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
       anon_sym_COMMA,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
-      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,
-    ACTIONS(295), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12403] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(271), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(273), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12459] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(221), 20,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(223), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12517] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(267), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(269), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12573] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(309), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(311), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12629] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(225), 2,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-    ACTIONS(221), 18,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(223), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12689] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(243), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(245), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12745] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(263), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(265), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12801] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(303), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12857] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(313), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(315), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12913] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(321), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(323), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [12969] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(317), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(319), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13025] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(325), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(327), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13081] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(285), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(287), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13137] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(281), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(283), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13193] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(537), 1,
-      anon_sym_DASH_GT,
-    STATE(181), 1,
-      sym_logic_operator,
-    STATE(182), 1,
-      sym_math_operator,
-    ACTIONS(203), 18,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
       anon_sym_COLON,
       anon_sym_STAR,
       anon_sym_SLASH,
@@ -19584,956 +7817,12 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_LT_EQ,
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
-      anon_sym_EQ_GT,
-    ACTIONS(205), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13255] = 3,
+  [4480] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(259), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
+    ACTIONS(214), 1,
       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,
-    ACTIONS(261), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13311] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 2,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-    ACTIONS(263), 19,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(265), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13369] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(289), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(291), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13425] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(235), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(237), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13481] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(217), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(219), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13537] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(255), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(257), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13593] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(251), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(253), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13649] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(297), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(299), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13705] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(239), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(241), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13761] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(181), 1,
-      sym_logic_operator,
-    STATE(182), 1,
-      sym_math_operator,
-    ACTIONS(207), 19,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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_EQ_GT,
-      anon_sym_DASH_GT,
-    ACTIONS(209), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13821] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 2,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-    ACTIONS(221), 19,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(223), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13879] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(247), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(249), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13935] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(537), 1,
-      anon_sym_DASH_GT,
-    STATE(181), 1,
-      sym_logic_operator,
-    STATE(182), 1,
-      sym_math_operator,
-    ACTIONS(197), 18,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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_EQ_GT,
-    ACTIONS(199), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [13997] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(277), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(279), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14053] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(305), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(307), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14109] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(329), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(331), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14165] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(211), 21,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(213), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_EQ,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14221] = 7,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(543), 1,
-      anon_sym_elseif,
-    ACTIONS(545), 1,
-      anon_sym_else,
-    STATE(283), 1,
-      sym_else,
-    STATE(261), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(539), 9,
+    ACTIONS(210), 20,
       ts_builtin_sym_end,
       anon_sym_SEMI,
       anon_sym_LPAREN,
@@ -20542,52 +7831,76 @@ static const uint16_t ts_small_parse_table[] = {
       sym_float,
       sym_string,
       anon_sym_LBRACK,
+      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_asyncfor,
-    ACTIONS(541), 33,
+      anon_sym_DASH_GT,
+    ACTIONS(338), 21,
       anon_sym_async,
-      sym__identifier_pattern,
+      sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_none,
       anon_sym_some,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
       anon_sym_if,
       anon_sym_match,
       anon_sym_while,
       anon_sym_for,
       anon_sym_return,
-      anon_sym_assert,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [14284] = 4,
+  [4532] = 5,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(547), 1,
-      anon_sym_DOT_DOT,
-    ACTIONS(297), 19,
+    STATE(199), 1,
+      sym_math_operator,
+    STATE(204), 1,
+      sym_logic_operator,
+    ACTIONS(192), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(190), 23,
       anon_sym_SEMI,
       anon_sym_LPAREN,
+      anon_sym_RPAREN,
       anon_sym_COMMA,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
       anon_sym_COLON,
       anon_sym_STAR,
       anon_sym_SLASH,
@@ -20600,167 +7913,1295 @@ 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,
-    ACTIONS(299), 27,
-      anon_sym_async,
-      sym__identifier_pattern,
+  [4586] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(222), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
       anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
       anon_sym_PLUS,
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-      anon_sym_assert,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14341] = 7,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(543), 1,
-      anon_sym_elseif,
-    ACTIONS(545), 1,
-      anon_sym_else,
-    STATE(280), 1,
-      sym_else,
-    STATE(258), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(549), 9,
-      ts_builtin_sym_end,
+    ACTIONS(220), 24,
       anon_sym_SEMI,
       anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
       sym_float,
       sym_string,
       anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(551), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [14404] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(557), 1,
-      anon_sym_elseif,
-    STATE(261), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(553), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(555), 34,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [14462] = 10,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(227), 1,
-      anon_sym_EQ,
-    ACTIONS(229), 1,
+      anon_sym_RBRACK,
       anon_sym_COLON,
-    ACTIONS(231), 1,
+      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,
+  [4635] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(226), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(224), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [4684] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(302), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(300), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [4733] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(236), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(234), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [4782] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(264), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(262), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [4831] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(256), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(254), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [4880] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(260), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(258), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [4929] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(268), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(266), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [4978] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(340), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(226), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(224), 23,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5029] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(294), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(292), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5078] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(290), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(214), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5127] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(288), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(286), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5176] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(208), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(206), 23,
+      anon_sym_SEMI,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5227] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(252), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(250), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5276] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(316), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(314), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5325] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(276), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(274), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5374] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(248), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(246), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5423] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(244), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(242), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5472] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(298), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(296), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5521] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(280), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(278), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5570] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(232), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(230), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5619] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(240), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(238), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5668] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(272), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(270), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5717] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(208), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(206), 22,
+      anon_sym_SEMI,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5770] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(308), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(306), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5819] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(284), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(282), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5868] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(312), 17,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_EQ,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(310), 24,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      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,
+  [5917] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(212), 1,
+      anon_sym_EQ,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(216), 1,
       anon_sym_LT,
     STATE(37), 1,
       sym_assignment_operator,
-    STATE(411), 1,
+    STATE(376), 1,
       sym_type_definition,
-    ACTIONS(233), 2,
+    ACTIONS(218), 2,
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
-    ACTIONS(221), 13,
+    ACTIONS(208), 15,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(206), 17,
       anon_sym_SEMI,
       anon_sym_COMMA,
+      anon_sym_LBRACE,
       anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
@@ -20771,556 +9212,362 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-    ACTIONS(223), 24,
-      sym__identifier_pattern,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14529] = 3,
+  [5979] = 8,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(560), 10,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
+    ACTIONS(210), 1,
       anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_elseif,
-      anon_sym_asyncfor,
-    ACTIONS(562), 34,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [14581] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(225), 18,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(351), 25,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14635] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(277), 10,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_elseif,
-      anon_sym_asyncfor,
-    ACTIONS(279), 34,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [14687] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(263), 1,
-      anon_sym_COLON,
-    ACTIONS(225), 18,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(351), 25,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14741] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(329), 10,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_elseif,
-      anon_sym_asyncfor,
-    ACTIONS(331), 34,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [14793] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(564), 10,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_elseif,
-      anon_sym_asyncfor,
-    ACTIONS(566), 34,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [14845] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(235), 10,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_elseif,
-      anon_sym_asyncfor,
-    ACTIONS(237), 34,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_else,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [14897] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(227), 1,
+    ACTIONS(212), 1,
       anon_sym_EQ,
-    ACTIONS(229), 1,
+    ACTIONS(214), 1,
       anon_sym_COLON,
-    STATE(36), 1,
+    STATE(32), 1,
       sym_assignment_operator,
-    ACTIONS(233), 2,
+    ACTIONS(218), 2,
       anon_sym_PLUS_EQ,
       anon_sym_DASH_EQ,
-    ACTIONS(221), 13,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(223), 25,
-      sym__identifier_pattern,
-      anon_sym_PLUS,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [14959] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(197), 15,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      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,
-    ACTIONS(199), 25,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15016] = 16,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(173), 1,
+    ACTIONS(208), 16,
+      sym_identifier,
       sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(570), 1,
-      anon_sym_LPAREN,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(365), 1,
-      sym_index_expression,
-    ACTIONS(175), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(177), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(233), 3,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(206), 17,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_DASH_GT,
+  [6036] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(342), 1,
+      anon_sym_DASH_GT,
+    STATE(201), 1,
+      sym_logic_operator,
+    STATE(202), 1,
+      sym_math_operator,
+    ACTIONS(196), 15,
       sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(194), 20,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [6088] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(342), 1,
+      anon_sym_DASH_GT,
+    STATE(201), 1,
+      sym_logic_operator,
+    STATE(202), 1,
+      sym_math_operator,
+    ACTIONS(202), 15,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(200), 20,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [6140] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(348), 1,
+      anon_sym_RBRACE,
+    ACTIONS(350), 1,
+      anon_sym_STAR,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(124), 1,
+      aux_sym_match_repeat1,
+    STATE(334), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
       sym_value,
       sym_index,
-    STATE(232), 6,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
       sym_function,
       sym_built_in_value,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15093] = 6,
+  [6223] = 22,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(203), 15,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(350), 1,
+      anon_sym_STAR,
+    ACTIONS(352), 1,
+      anon_sym_RBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(124), 1,
+      aux_sym_match_repeat1,
+    STATE(334), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [6306] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(354), 1,
+      sym_identifier,
+    ACTIONS(357), 1,
+      anon_sym_LPAREN,
+    ACTIONS(360), 1,
+      anon_sym_LBRACE,
+    ACTIONS(363), 1,
+      anon_sym_RBRACE,
+    ACTIONS(365), 1,
+      sym_integer,
+    ACTIONS(374), 1,
+      anon_sym_LBRACK,
+    ACTIONS(377), 1,
+      anon_sym_none,
+    ACTIONS(380), 1,
+      anon_sym_some,
+    ACTIONS(383), 1,
+      anon_sym_STAR,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(124), 1,
+      aux_sym_match_repeat1,
+    STATE(334), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(368), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(371), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(386), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [6389] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(338), 15,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    ACTIONS(210), 21,
       anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
       anon_sym_COMMA,
       anon_sym_LBRACE,
       anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
       anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
@@ -21331,66 +9578,59 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_PIPE_PIPE,
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
-      anon_sym_EQ_GT,
-    ACTIONS(205), 25,
-      anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15150] = 16,
+      anon_sym_DASH_GT,
+  [6436] = 21,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(572), 1,
+    ACTIONS(128), 1,
       anon_sym_LPAREN,
-    STATE(112), 1,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(391), 1,
+      anon_sym_RPAREN,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(138), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
       sym_index_expression,
-    STATE(113), 1,
-      sym_built_in_function,
-    ACTIONS(139), 2,
+    ACTIONS(136), 2,
       sym_float,
       sym_string,
-    ACTIONS(141), 2,
+    ACTIONS(138), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(115), 3,
-      sym_identifier,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
       sym_value,
       sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
     STATE(110), 6,
       sym_boolean,
       sym_list,
@@ -21398,121 +9638,58 @@ static const uint16_t ts_small_parse_table[] = {
       sym_option,
       sym_function,
       sym_built_in_value,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15227] = 16,
+  [6516] = 21,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(570), 1,
+    ACTIONS(128), 1,
       anon_sym_LPAREN,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(248), 1,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(395), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(144), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
       sym_index_expression,
-    ACTIONS(175), 2,
+    ACTIONS(136), 2,
       sym_float,
       sym_string,
-    ACTIONS(177), 2,
+    ACTIONS(138), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(233), 3,
-      sym_identifier,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
       sym_value,
       sym_index,
-    STATE(232), 6,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-      sym_function,
-      sym_built_in_value,
-    ACTIONS(193), 20,
-      anon_sym_assert,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15304] = 16,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(129), 1,
-      sym__identifier_pattern,
-    ACTIONS(137), 1,
-      sym_integer,
-    ACTIONS(143), 1,
-      anon_sym_LBRACK,
-    ACTIONS(145), 1,
-      anon_sym_none,
-    ACTIONS(147), 1,
-      anon_sym_some,
-    ACTIONS(163), 1,
-      anon_sym_std,
-    ACTIONS(407), 1,
-      anon_sym_LBRACE,
-    ACTIONS(572), 1,
-      anon_sym_LPAREN,
-    STATE(105), 1,
-      sym_index_expression,
-    STATE(113), 1,
-      sym_built_in_function,
-    ACTIONS(139), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(141), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(115), 3,
-      sym_identifier,
-      sym_value,
-      sym_index,
     STATE(110), 6,
       sym_boolean,
       sym_list,
@@ -21520,1123 +9697,259 @@ static const uint16_t ts_small_parse_table[] = {
       sym_option,
       sym_function,
       sym_built_in_value,
-    ACTIONS(161), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15381] = 16,
+  [6596] = 21,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_none,
-    ACTIONS(23), 1,
-      anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
-      anon_sym_LBRACE,
-    ACTIONS(574), 1,
+    ACTIONS(128), 1,
       anon_sym_LPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(73), 1,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(397), 1,
+      anon_sym_RBRACK,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(143), 1,
+      aux_sym_list_repeat1,
+    STATE(157), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
       sym_index_expression,
-    ACTIONS(15), 2,
+    ACTIONS(136), 2,
       sym_float,
       sym_string,
-    ACTIONS(17), 2,
+    ACTIONS(138), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(74), 3,
-      sym_identifier,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
       sym_value,
       sym_index,
-    STATE(61), 6,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
       sym_function,
       sym_built_in_value,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15458] = 16,
+  [6676] = 21,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(165), 1,
-      sym__identifier_pattern,
-    ACTIONS(173), 1,
-      sym_integer,
-    ACTIONS(179), 1,
-      anon_sym_LBRACK,
-    ACTIONS(181), 1,
-      anon_sym_none,
-    ACTIONS(183), 1,
-      anon_sym_some,
-    ACTIONS(195), 1,
-      anon_sym_std,
-    ACTIONS(357), 1,
-      anon_sym_LBRACE,
-    ACTIONS(570), 1,
+    ACTIONS(128), 1,
       anon_sym_LPAREN,
-    STATE(245), 1,
-      sym_built_in_function,
-    STATE(259), 1,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(399), 1,
+      anon_sym_RBRACK,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(139), 1,
+      aux_sym_list_repeat1,
+    STATE(157), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
       sym_index_expression,
-    ACTIONS(175), 2,
+    ACTIONS(136), 2,
       sym_float,
       sym_string,
-    ACTIONS(177), 2,
+    ACTIONS(138), 2,
       anon_sym_true,
       anon_sym_false,
-    STATE(233), 3,
-      sym_identifier,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
       sym_value,
       sym_index,
-    STATE(232), 6,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
       sym_boolean,
       sym_list,
       sym_map,
       sym_option,
       sym_function,
       sym_built_in_value,
-    ACTIONS(193), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15535] = 16,
+  [6756] = 10,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(13), 1,
-      sym_integer,
-    ACTIONS(19), 1,
-      anon_sym_LBRACK,
-    ACTIONS(21), 1,
-      anon_sym_none,
-    ACTIONS(23), 1,
-      anon_sym_some,
-    ACTIONS(39), 1,
-      anon_sym_std,
-    ACTIONS(515), 1,
-      anon_sym_LBRACE,
-    ACTIONS(574), 1,
-      anon_sym_LPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(81), 1,
-      sym_index_expression,
-    ACTIONS(15), 2,
-      sym_float,
-      sym_string,
-    ACTIONS(17), 2,
-      anon_sym_true,
-      anon_sym_false,
-    STATE(74), 3,
-      sym_identifier,
-      sym_value,
-      sym_index,
-    STATE(61), 6,
-      sym_boolean,
-      sym_list,
-      sym_map,
-      sym_option,
-      sym_function,
-      sym_built_in_value,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [15612] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(539), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(541), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [15662] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(576), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(578), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [15712] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(580), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(582), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [15762] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(584), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(586), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [15812] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(341), 1,
-      anon_sym_SEMI,
-    ACTIONS(337), 8,
-      ts_builtin_sym_end,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(339), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [15864] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(588), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(590), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [15914] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(592), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(594), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [15964] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(596), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(598), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16014] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(600), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(602), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16064] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(604), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(606), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16114] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(337), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(339), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16164] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(608), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(610), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16214] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(612), 9,
-      ts_builtin_sym_end,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(614), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16264] = 7,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(616), 1,
-      anon_sym_elseif,
-    ACTIONS(618), 1,
-      anon_sym_else,
-    STATE(316), 1,
-      sym_else,
-    STATE(295), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(539), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(541), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16321] = 7,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(616), 1,
-      anon_sym_elseif,
-    ACTIONS(618), 1,
-      anon_sym_else,
-    STATE(312), 1,
-      sym_else,
-    STATE(293), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(549), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(551), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16378] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(620), 1,
-      anon_sym_elseif,
-    STATE(295), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(553), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(555), 28,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_else,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16430] = 10,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
+    ACTIONS(326), 1,
       anon_sym_DASH,
-    ACTIONS(568), 1,
+    ACTIONS(342), 1,
       anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
+    STATE(201), 1,
       sym_logic_operator,
-    ACTIONS(349), 2,
+    STATE(202), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(337), 3,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_RBRACE,
-    ACTIONS(343), 4,
+    ACTIONS(324), 3,
       anon_sym_PLUS,
-      anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(347), 6,
+    ACTIONS(328), 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(339), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
+    ACTIONS(320), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(322), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [16492] = 11,
+  [6814] = 21,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(345), 1,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(350), 1,
+      anon_sym_STAR,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(122), 1,
+      aux_sym_match_repeat1,
+    STATE(334), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [6894] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
       anon_sym_DASH,
-    ACTIONS(517), 1,
-      anon_sym_SEMI,
-    ACTIONS(568), 1,
+    ACTIONS(342), 1,
       anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
+    ACTIONS(401), 1,
+      anon_sym_SEMI,
+    STATE(201), 1,
       sym_logic_operator,
-    ACTIONS(337), 2,
-      anon_sym_COMMA,
-      anon_sym_RBRACE,
-    ACTIONS(349), 2,
+    STATE(202), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(343), 4,
+    ACTIONS(324), 3,
       anon_sym_PLUS,
-      anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(347), 6,
+    ACTIONS(328), 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(339), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [16556] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(625), 6,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_asyncfor,
-    ACTIONS(623), 33,
-      anon_sym_async,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_if,
-      anon_sym_match,
-      anon_sym_while,
-      anon_sym_for,
-      anon_sym_return,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16603] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(564), 10,
-      anon_sym_SEMI,
+    ACTIONS(320), 8,
       anon_sym_LPAREN,
       anon_sym_COMMA,
       anon_sym_LBRACE,
@@ -22645,1779 +9958,8777 @@ static const uint16_t ts_small_parse_table[] = {
       sym_string,
       anon_sym_LBRACK,
       anon_sym_STAR,
-      anon_sym_elseif,
-    ACTIONS(566), 28,
-      sym__identifier_pattern,
+    ACTIONS(322), 12,
+      sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_none,
       anon_sym_some,
-      anon_sym_else,
-      anon_sym_assert,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16649] = 3,
+  [6954] = 22,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(560), 10,
-      anon_sym_SEMI,
+    ACTIONS(162), 1,
       anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(405), 1,
+      anon_sym_RPAREN,
+    STATE(241), 1,
+      sym_yield,
+    STATE(349), 1,
+      sym_function_call,
+    STATE(352), 1,
+      sym_expression,
+    STATE(384), 1,
+      aux_sym_function_repeat1,
+    STATE(413), 1,
+      sym__function_expression_kind,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(357), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7036] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(407), 1,
+      anon_sym_RPAREN,
+    STATE(241), 1,
+      sym_yield,
+    STATE(349), 1,
+      sym_function_call,
+    STATE(352), 1,
+      sym_expression,
+    STATE(391), 1,
+      aux_sym_function_repeat1,
+    STATE(409), 1,
+      sym__function_expression_kind,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(357), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7118] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(405), 1,
+      anon_sym_RPAREN,
+    STATE(241), 1,
+      sym_yield,
+    STATE(349), 1,
+      sym_function_call,
+    STATE(352), 1,
+      sym_expression,
+    STATE(384), 1,
+      aux_sym_function_repeat1,
+    STATE(401), 1,
+      sym__function_expression_kind,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(357), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7200] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(409), 1,
+      anon_sym_RPAREN,
+    STATE(241), 1,
+      sym_yield,
+    STATE(349), 1,
+      sym_function_call,
+    STATE(352), 1,
+      sym_expression,
+    STATE(386), 1,
+      aux_sym_function_repeat1,
+    STATE(413), 1,
+      sym__function_expression_kind,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(357), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7282] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(350), 1,
+      anon_sym_STAR,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(123), 1,
+      aux_sym_match_repeat1,
+    STATE(334), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7362] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(411), 1,
+      sym_identifier,
+    ACTIONS(414), 1,
+      anon_sym_LPAREN,
+    ACTIONS(417), 1,
+      anon_sym_RPAREN,
+    ACTIONS(419), 1,
+      anon_sym_LBRACE,
+    ACTIONS(422), 1,
+      sym_integer,
+    ACTIONS(431), 1,
+      anon_sym_LBRACK,
+    ACTIONS(434), 1,
+      anon_sym_none,
+    ACTIONS(437), 1,
+      anon_sym_some,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(138), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(425), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(428), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(440), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7442] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(443), 1,
+      anon_sym_RBRACK,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(152), 1,
+      aux_sym_list_repeat1,
+    STATE(157), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7522] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(445), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(138), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7602] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(447), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(138), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7682] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(407), 1,
+      anon_sym_RPAREN,
+    STATE(241), 1,
+      sym_yield,
+    STATE(349), 1,
+      sym_function_call,
+    STATE(352), 1,
+      sym_expression,
+    STATE(391), 1,
+      aux_sym_function_repeat1,
+    STATE(413), 1,
+      sym__function_expression_kind,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(355), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7764] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(449), 1,
+      anon_sym_RBRACK,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(152), 1,
+      aux_sym_list_repeat1,
+    STATE(157), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7844] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(451), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(138), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [7924] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(407), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(241), 1,
+      sym_yield,
+    STATE(336), 1,
+      sym_expression,
+    STATE(346), 1,
+      sym_function_call,
+    STATE(391), 1,
+      aux_sym_function_repeat1,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8006] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(453), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(140), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8086] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(455), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(141), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8166] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(457), 1,
+      anon_sym_RBRACK,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(155), 1,
+      aux_sym_list_repeat1,
+    STATE(157), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8246] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(409), 1,
+      anon_sym_RPAREN,
+    STATE(241), 1,
+      sym_yield,
+    STATE(349), 1,
+      sym_function_call,
+    STATE(352), 1,
+      sym_expression,
+    STATE(386), 1,
+      aux_sym_function_repeat1,
+    STATE(413), 1,
+      sym__function_expression_kind,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(354), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8328] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(405), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(241), 1,
+      sym_yield,
+    STATE(336), 1,
+      sym_expression,
+    STATE(353), 1,
+      sym_function_call,
+    STATE(384), 1,
+      aux_sym_function_repeat1,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8410] = 22,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(403), 1,
+      sym_identifier,
+    ACTIONS(409), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(241), 1,
+      sym_yield,
+    STATE(336), 1,
+      sym_expression,
+    STATE(343), 1,
+      sym_function_call,
+    STATE(386), 1,
+      aux_sym_function_repeat1,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8492] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(459), 1,
+      sym_identifier,
+    ACTIONS(462), 1,
+      anon_sym_LPAREN,
+    ACTIONS(465), 1,
+      anon_sym_LBRACE,
+    ACTIONS(468), 1,
+      sym_integer,
+    ACTIONS(477), 1,
+      anon_sym_LBRACK,
+    ACTIONS(480), 1,
+      anon_sym_RBRACK,
+    ACTIONS(482), 1,
+      anon_sym_none,
+    ACTIONS(485), 1,
+      anon_sym_some,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(152), 1,
+      aux_sym_list_repeat1,
+    STATE(157), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(471), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(474), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(488), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8572] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(491), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(138), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8652] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(493), 1,
+      anon_sym_RPAREN,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(138), 1,
+      aux_sym__expression_list,
+    STATE(156), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8732] = 21,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(495), 1,
+      anon_sym_RBRACK,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(152), 1,
+      aux_sym_list_repeat1,
+    STATE(157), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [8812] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(342), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(501), 1,
       anon_sym_COMMA,
+    STATE(201), 1,
+      sym_logic_operator,
+    STATE(202), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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(499), 6,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
       anon_sym_LBRACE,
-      anon_sym_RBRACE,
       sym_float,
       sym_string,
       anon_sym_LBRACK,
-      anon_sym_STAR,
-      anon_sym_elseif,
-    ACTIONS(562), 28,
-      sym__identifier_pattern,
+    ACTIONS(497), 12,
+      sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_none,
       anon_sym_some,
-      anon_sym_else,
-      anon_sym_assert,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16695] = 3,
+  [8871] = 11,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(235), 10,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(342), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(507), 1,
       anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
+    STATE(201), 1,
+      sym_logic_operator,
+    STATE(202), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
       anon_sym_STAR,
-      anon_sym_elseif,
-    ACTIONS(237), 28,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_else,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16741] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(277), 10,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-      anon_sym_elseif,
-    ACTIONS(279), 28,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_else,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16787] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(329), 10,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-      anon_sym_elseif,
-    ACTIONS(331), 28,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_else,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16833] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(596), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(598), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16877] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(608), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(610), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16921] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(517), 1,
-      anon_sym_SEMI,
-    ACTIONS(337), 8,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(339), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [16967] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(580), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(582), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17011] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(612), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(614), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17055] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(337), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(339), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17099] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(592), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(594), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17143] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(604), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(606), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17187] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(539), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(541), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17231] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(576), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(578), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17275] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(600), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(602), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17319] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(588), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(590), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17363] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(584), 9,
-      anon_sym_SEMI,
-      anon_sym_LPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(586), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17407] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(631), 1,
-      anon_sym_COMMA,
-    ACTIONS(629), 7,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(627), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17452] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(635), 7,
-      anon_sym_LPAREN,
-      anon_sym_LBRACE,
-      anon_sym_RBRACE,
-      sym_float,
-      sym_string,
-      anon_sym_LBRACK,
-      anon_sym_STAR,
-    ACTIONS(633), 27,
-      sym__identifier_pattern,
-      sym_integer,
-      anon_sym_true,
-      anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17494] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(497), 6,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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(505), 6,
       anon_sym_LPAREN,
       anon_sym_LBRACE,
       sym_float,
       sym_string,
       anon_sym_LBRACK,
       anon_sym_RBRACK,
-    ACTIONS(637), 27,
-      sym__identifier_pattern,
+    ACTIONS(503), 12,
+      sym_identifier,
       sym_integer,
       anon_sym_true,
       anon_sym_false,
       anon_sym_none,
       anon_sym_some,
-      anon_sym_assert,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17535] = 3,
+  [8930] = 19,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(427), 6,
+    ACTIONS(162), 1,
       anon_sym_LPAREN,
-      anon_sym_RPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
       anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(225), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
       sym_float,
       sym_string,
-      anon_sym_LBRACK,
-    ACTIONS(639), 27,
-      sym__identifier_pattern,
-      sym_integer,
+    ACTIONS(172), 2,
       anon_sym_true,
       anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17576] = 3,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9004] = 18,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(643), 5,
-      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
       anon_sym_LBRACE,
+    ACTIONS(509), 1,
+      sym_identifier,
+    ACTIONS(511), 1,
+      anon_sym_LPAREN,
+    STATE(243), 1,
+      sym_function_expression,
+    STATE(351), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
       sym_float,
       sym_string,
-      anon_sym_LBRACK,
-    ACTIONS(641), 27,
-      sym__identifier_pattern,
-      sym_integer,
+    ACTIONS(172), 2,
       anon_sym_true,
       anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
+    STATE(278), 2,
+      sym_value,
+      sym_index,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(239), 3,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(188), 6,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17616] = 3,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9076] = 19,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(647), 5,
+    ACTIONS(162), 1,
       anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
       anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(329), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
       sym_float,
       sym_string,
-      anon_sym_LBRACK,
-    ACTIONS(645), 27,
-      sym__identifier_pattern,
-      sym_integer,
+    ACTIONS(172), 2,
       anon_sym_true,
       anon_sym_false,
-      anon_sym_none,
-      anon_sym_some,
-      anon_sym_assert,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-      anon_sym_std,
-  [17656] = 7,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9150] = 17,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(616), 1,
-      anon_sym_elseif,
-    ACTIONS(649), 1,
-      anon_sym_else,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(511), 1,
+      anon_sym_LPAREN,
+    ACTIONS(513), 1,
+      sym_identifier,
+    STATE(243), 1,
+      sym_function_expression,
+    STATE(339), 1,
+      sym_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(239), 5,
+      sym_value,
+      sym_index,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9220] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
     STATE(316), 1,
-      sym_else,
-    STATE(295), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(539), 3,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_RBRACE,
-    ACTIONS(541), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [17701] = 7,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9294] = 19,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(616), 1,
-      anon_sym_elseif,
-    ACTIONS(649), 1,
-      anon_sym_else,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(318), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9368] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
     STATE(312), 1,
-      sym_else,
-    STATE(323), 2,
-      sym_else_if,
-      aux_sym_if_else_repeat1,
-    ACTIONS(549), 3,
-      anon_sym_SEMI,
-      anon_sym_COMMA,
-      anon_sym_RBRACE,
-    ACTIONS(551), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [17746] = 3,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9442] = 17,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(653), 6,
-      anon_sym_RPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(515), 1,
+      sym_identifier,
+    ACTIONS(517), 1,
+      anon_sym_LPAREN,
+    STATE(105), 1,
+      sym_function_expression,
+    STATE(345), 1,
+      sym_expression,
+    STATE(415), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(104), 5,
+      sym_value,
+      sym_index,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9512] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(519), 1,
+      sym_identifier,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    STATE(49), 1,
+      sym_expression,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(437), 1,
+      sym_function_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(75), 2,
+      sym_value,
+      sym_index,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9586] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(328), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9660] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(319), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9734] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(519), 1,
+      sym_identifier,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    STATE(50), 1,
+      sym_expression,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(437), 1,
+      sym_function_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(75), 2,
+      sym_value,
+      sym_index,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9808] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(246), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9882] = 18,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(509), 1,
+      sym_identifier,
+    ACTIONS(511), 1,
+      anon_sym_LPAREN,
+    STATE(243), 1,
+      sym_function_expression,
+    STATE(336), 1,
+      sym_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(278), 2,
+      sym_value,
+      sym_index,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(239), 3,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [9954] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(317), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10028] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(286), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10102] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(284), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10176] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(519), 1,
+      sym_identifier,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    STATE(47), 1,
+      sym_expression,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(437), 1,
+      sym_function_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(75), 2,
+      sym_value,
+      sym_index,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10250] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(307), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10324] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(308), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10398] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(90), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10472] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(309), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10546] = 17,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    ACTIONS(523), 1,
+      sym_identifier,
+    ACTIONS(525), 1,
+      anon_sym_LPAREN,
+    STATE(79), 1,
+      sym_function_expression,
+    STATE(341), 1,
+      sym_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(59), 5,
+      sym_value,
+      sym_index,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10616] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(306), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10690] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(222), 1,
+      sym_expression,
+    STATE(423), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10764] = 17,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(515), 1,
+      sym_identifier,
+    ACTIONS(517), 1,
+      anon_sym_LPAREN,
+    STATE(105), 1,
+      sym_function_expression,
+    STATE(350), 1,
+      sym_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(104), 5,
+      sym_value,
+      sym_index,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10834] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(216), 1,
+      sym_expression,
+    STATE(423), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10908] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(313), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [10982] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(327), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11056] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(333), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11130] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(310), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11204] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(86), 1,
+      sym_expression,
+    STATE(415), 1,
+      sym_index_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11278] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(85), 1,
+      sym_expression,
+    STATE(415), 1,
+      sym_index_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11352] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(300), 1,
+      sym_expression,
+    STATE(423), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11426] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(301), 1,
+      sym_expression,
+    STATE(423), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11500] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(519), 1,
+      sym_identifier,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    STATE(46), 1,
+      sym_expression,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(430), 1,
+      sym_index_expression,
+    STATE(437), 1,
+      sym_function_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(75), 2,
+      sym_value,
+      sym_index,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11574] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(332), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11648] = 17,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(511), 1,
+      anon_sym_LPAREN,
+    ACTIONS(513), 1,
+      sym_identifier,
+    STATE(243), 1,
+      sym_function_expression,
+    STATE(338), 1,
+      sym_expression,
+    STATE(423), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(239), 5,
+      sym_value,
+      sym_index,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11718] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(326), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11792] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(519), 1,
+      sym_identifier,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    STATE(45), 1,
+      sym_expression,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(430), 1,
+      sym_index_expression,
+    STATE(437), 1,
+      sym_function_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(75), 2,
+      sym_value,
+      sym_index,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11866] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(527), 1,
+      sym_identifier,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(331), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(322), 2,
+      sym_value,
+      sym_index,
+    STATE(325), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [11940] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(87), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12014] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(314), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12088] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(121), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12162] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(120), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12236] = 17,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(511), 1,
+      anon_sym_LPAREN,
+    ACTIONS(513), 1,
+      sym_identifier,
+    STATE(243), 1,
+      sym_function_expression,
+    STATE(342), 1,
+      sym_expression,
+    STATE(420), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(239), 5,
+      sym_value,
+      sym_index,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12306] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(128), 1,
+      anon_sym_LPAREN,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(389), 1,
+      sym_identifier,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(88), 1,
+      sym_expression,
+    STATE(427), 1,
+      sym_function_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(103), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(114), 2,
+      sym_value,
+      sym_index,
+    STATE(106), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12380] = 18,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(517), 1,
+      anon_sym_LPAREN,
+    ACTIONS(529), 1,
+      sym_identifier,
+    STATE(105), 1,
+      sym_function_expression,
+    STATE(337), 1,
+      sym_expression,
+    STATE(435), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(125), 2,
+      sym_value,
+      sym_index,
+    STATE(104), 3,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12452] = 18,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    ACTIONS(525), 1,
+      anon_sym_LPAREN,
+    ACTIONS(531), 1,
+      sym_identifier,
+    STATE(79), 1,
+      sym_function_expression,
+    STATE(344), 1,
+      sym_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(89), 2,
+      sym_value,
+      sym_index,
+    STATE(59), 3,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12524] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(519), 1,
+      sym_identifier,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(80), 1,
+      sym_expression,
+    STATE(437), 1,
+      sym_function_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(75), 2,
+      sym_value,
+      sym_index,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12598] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(227), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12672] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(162), 1,
+      anon_sym_LPAREN,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(344), 1,
+      sym_identifier,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(315), 1,
+      sym_expression,
+    STATE(439), 1,
+      sym_function_expression,
+    STATE(442), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(237), 2,
+      sym_value,
+      sym_index,
+    STATE(241), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12746] = 19,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(7), 1,
+      anon_sym_LPAREN,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(519), 1,
+      sym_identifier,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    STATE(59), 1,
+      sym__function_expression_kind,
+    STATE(81), 1,
+      sym_expression,
+    STATE(437), 1,
+      sym_function_expression,
+    STATE(438), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(58), 2,
+      sym_function_call,
+      sym_yield,
+    STATE(75), 2,
+      sym_value,
+      sym_index,
+    STATE(66), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12820] = 17,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    ACTIONS(523), 1,
+      sym_identifier,
+    ACTIONS(525), 1,
+      anon_sym_LPAREN,
+    STATE(79), 1,
+      sym_function_expression,
+    STATE(340), 1,
+      sym_expression,
+    STATE(430), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(231), 3,
+      sym__expression_kind,
+      sym_math,
+      sym_logic,
+    STATE(59), 5,
+      sym_value,
+      sym_index,
+      sym__function_expression_kind,
+      sym_function_call,
+      sym_yield,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [12890] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(537), 1,
+      anon_sym_elseif,
+    ACTIONS(539), 1,
+      anon_sym_else,
+    STATE(260), 1,
+      sym_else,
+    STATE(213), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(533), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(535), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [12938] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(537), 1,
+      anon_sym_elseif,
+    ACTIONS(539), 1,
+      anon_sym_else,
+    STATE(252), 1,
+      sym_else,
+    STATE(214), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(541), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(543), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [12986] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(549), 1,
+      anon_sym_elseif,
+    STATE(214), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(545), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(547), 19,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [13029] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(310), 10,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+    ACTIONS(312), 19,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [13066] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(552), 1,
+      anon_sym_DASH_GT,
+    STATE(182), 1,
+      sym_logic_operator,
+    STATE(184), 1,
+      sym_math_operator,
+    ACTIONS(196), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(194), 19,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
       anon_sym_COMMA,
       anon_sym_LBRACE,
-      anon_sym_EQ,
+      anon_sym_RBRACE,
+      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,
-    ACTIONS(651), 22,
+      anon_sym_EQ_GT,
+  [13109] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(242), 10,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+    ACTIONS(244), 19,
       anon_sym_async,
-      sym__identifier_pattern,
-      anon_sym_assert,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [17782] = 7,
+  [13146] = 5,
     ACTIONS(3), 1,
       sym__comment,
+    STATE(182), 1,
+      sym_logic_operator,
+    STATE(184), 1,
+      sym_math_operator,
+    ACTIONS(192), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(190), 20,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13187] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(306), 10,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+    ACTIONS(308), 19,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [13224] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(554), 10,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+    ACTIONS(556), 19,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [13261] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(558), 10,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_elseif,
+      anon_sym_asyncfor,
+    ACTIONS(560), 19,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_else,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [13298] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(552), 1,
+      anon_sym_DASH_GT,
+    STATE(182), 1,
+      sym_logic_operator,
+    STATE(184), 1,
+      sym_math_operator,
+    ACTIONS(202), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(200), 19,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13341] = 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), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13377] = 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), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13413] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(562), 1,
+      anon_sym_DASH_GT,
+    STATE(158), 1,
+      sym_math_operator,
+    STATE(208), 1,
+      sym_logic_operator,
+    ACTIONS(196), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(194), 18,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_EQ_GT,
+  [13455] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(280), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(278), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13491] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(562), 1,
+      anon_sym_DASH_GT,
+    STATE(158), 1,
+      sym_math_operator,
+    STATE(208), 1,
+      sym_logic_operator,
+    ACTIONS(202), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(200), 18,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_EQ_GT,
+  [13533] = 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), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13569] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(226), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(224), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13605] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(232), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(230), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13641] = 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), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13677] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(248), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(246), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13713] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(240), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(238), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13749] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(236), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(234), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13785] = 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), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13821] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(272), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(270), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13857] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(210), 2,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+    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_SEMI,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13897] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(308), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(306), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13933] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(252), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(250), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [13969] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(268), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(266), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14005] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 2,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+    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), 19,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14043] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(290), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(214), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14079] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(316), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(314), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14115] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(288), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(286), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14151] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(244), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(242), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14187] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(158), 1,
+      sym_math_operator,
+    STATE(208), 1,
+      sym_logic_operator,
+    ACTIONS(192), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(190), 19,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_EQ_GT,
+      anon_sym_DASH_GT,
+  [14227] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(222), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(220), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14263] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(298), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(296), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14299] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(312), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(310), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14335] = 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), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14371] = 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), 21,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [14407] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(564), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(566), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14442] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(568), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(570), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14477] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(572), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(574), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14512] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(576), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(578), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14547] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(580), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(582), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14582] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(584), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(226), 7,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_EQ,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(224), 19,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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_EQ_GT,
+      anon_sym_DASH_GT,
+  [14619] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(586), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(588), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14654] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(590), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(592), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14689] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(541), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(543), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14724] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(332), 1,
+      anon_sym_SEMI,
+    ACTIONS(320), 8,
+      ts_builtin_sym_end,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(322), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14761] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(594), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(596), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14796] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(598), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(600), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14831] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(602), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(604), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14866] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(320), 9,
+      ts_builtin_sym_end,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(322), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14901] = 14,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(606), 1,
+      sym_identifier,
+    ACTIONS(608), 1,
+      anon_sym_LPAREN,
+    STATE(99), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(101), 2,
+      sym_value,
+      sym_index,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [14957] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(610), 1,
+      anon_sym_elseif,
+    ACTIONS(612), 1,
+      anon_sym_else,
+    STATE(293), 1,
+      sym_else,
+    STATE(270), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(533), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(535), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [14999] = 14,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(614), 1,
+      sym_identifier,
+    ACTIONS(616), 1,
+      anon_sym_LPAREN,
+    STATE(257), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(242), 2,
+      sym_value,
+      sym_index,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [15055] = 14,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(134), 1,
+      sym_integer,
+    ACTIONS(140), 1,
+      anon_sym_LBRACK,
+    ACTIONS(142), 1,
+      anon_sym_none,
+    ACTIONS(144), 1,
+      anon_sym_some,
+    ACTIONS(393), 1,
+      anon_sym_LBRACE,
+    ACTIONS(606), 1,
+      sym_identifier,
+    ACTIONS(608), 1,
+      anon_sym_LPAREN,
+    STATE(92), 1,
+      sym_index_expression,
+    ACTIONS(136), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(138), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(101), 2,
+      sym_value,
+      sym_index,
+    ACTIONS(158), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(110), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [15111] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(610), 1,
+      anon_sym_elseif,
+    ACTIONS(612), 1,
+      anon_sym_else,
+    STATE(294), 1,
+      sym_else,
+    STATE(275), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(541), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(543), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15153] = 14,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    ACTIONS(618), 1,
+      sym_identifier,
+    ACTIONS(620), 1,
+      anon_sym_LPAREN,
+    STATE(71), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(70), 2,
+      sym_value,
+      sym_index,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [15209] = 14,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(13), 1,
+      sym_integer,
+    ACTIONS(19), 1,
+      anon_sym_LBRACK,
+    ACTIONS(21), 1,
+      anon_sym_none,
+    ACTIONS(23), 1,
+      anon_sym_some,
+    ACTIONS(521), 1,
+      anon_sym_LBRACE,
+    ACTIONS(618), 1,
+      sym_identifier,
+    ACTIONS(620), 1,
+      anon_sym_LPAREN,
+    STATE(52), 1,
+      sym_index_expression,
+    ACTIONS(15), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(17), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(70), 2,
+      sym_value,
+      sym_index,
+    ACTIONS(37), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(67), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [15265] = 14,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(614), 1,
+      sym_identifier,
+    ACTIONS(616), 1,
+      anon_sym_LPAREN,
+    STATE(229), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(242), 2,
+      sym_value,
+      sym_index,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [15321] = 14,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(168), 1,
+      sym_integer,
+    ACTIONS(174), 1,
+      anon_sym_LBRACK,
+    ACTIONS(176), 1,
+      anon_sym_none,
+    ACTIONS(178), 1,
+      anon_sym_some,
+    ACTIONS(346), 1,
+      anon_sym_LBRACE,
+    ACTIONS(614), 1,
+      sym_identifier,
+    ACTIONS(616), 1,
+      anon_sym_LPAREN,
+    STATE(324), 1,
+      sym_index_expression,
+    ACTIONS(170), 2,
+      sym_float,
+      sym_string,
+    ACTIONS(172), 2,
+      anon_sym_true,
+      anon_sym_false,
+    STATE(242), 2,
+      sym_value,
+      sym_index,
+    ACTIONS(188), 6,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+    STATE(226), 6,
+      sym_boolean,
+      sym_list,
+      sym_map,
+      sym_option,
+      sym_function,
+      sym_built_in_value,
+  [15377] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(622), 1,
+      anon_sym_elseif,
+    STATE(275), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(545), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(547), 13,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_else,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15414] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(212), 1,
+      anon_sym_EQ,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(216), 1,
+      anon_sym_LT,
+    STATE(29), 1,
+      sym_assignment_operator,
+    STATE(374), 1,
+      sym_type_definition,
+    ACTIONS(218), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+    ACTIONS(208), 3,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+    ACTIONS(206), 14,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+      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_DASH_GT,
+  [15461] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(212), 1,
+      anon_sym_EQ,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    STATE(30), 1,
+      sym_assignment_operator,
+    ACTIONS(218), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+    ACTIONS(208), 4,
+      anon_sym_PLUS,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(206), 14,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+      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_DASH_GT,
+  [15503] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(338), 5,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(210), 18,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [15537] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(627), 6,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_asyncfor,
+    ACTIONS(625), 18,
+      anon_sym_async,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_if,
+      anon_sym_match,
+      anon_sym_while,
+      anon_sym_for,
+      anon_sym_return,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15569] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(306), 10,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+      anon_sym_elseif,
+    ACTIONS(308), 13,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_else,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15600] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(310), 10,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+      anon_sym_elseif,
+    ACTIONS(312), 13,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_else,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15631] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(242), 10,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+      anon_sym_elseif,
+    ACTIONS(244), 13,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_else,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15662] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(554), 10,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+      anon_sym_elseif,
+    ACTIONS(556), 13,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_else,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15693] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(196), 5,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(194), 15,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [15730] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(558), 10,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+      anon_sym_elseif,
+    ACTIONS(560), 13,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_else,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15761] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(202), 5,
+      anon_sym_async,
+      sym_identifier,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(200), 15,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      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,
+  [15798] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(568), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(570), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15827] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(580), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(582), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15856] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(320), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(322), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15885] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(602), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(604), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15914] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(572), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(574), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15943] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(401), 1,
+      anon_sym_SEMI,
+    ACTIONS(320), 8,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(322), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [15974] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(541), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(543), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16003] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(564), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(566), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16032] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(590), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(592), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16061] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(576), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(578), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16090] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(598), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(600), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16119] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(594), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(596), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16148] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(586), 9,
+      anon_sym_SEMI,
+      anon_sym_LPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(588), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16177] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(552), 1,
+      anon_sym_DASH_GT,
+    STATE(191), 1,
+      sym_logic_operator,
+    STATE(192), 1,
+      sym_math_operator,
+    ACTIONS(202), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(200), 14,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      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,
+  [16211] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(552), 1,
+      anon_sym_DASH_GT,
+    STATE(191), 1,
+      sym_logic_operator,
+    STATE(192), 1,
+      sym_math_operator,
+    ACTIONS(196), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(194), 14,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      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,
+  [16245] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(635), 1,
+      anon_sym_COMMA,
+    ACTIONS(633), 7,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(631), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16275] = 10,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(401), 1,
+      anon_sym_SEMI,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(320), 3,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+      sym_identifier,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16317] = 9,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(320), 4,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+      sym_identifier,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16357] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(191), 1,
+      sym_logic_operator,
+    STATE(192), 1,
+      sym_math_operator,
+    ACTIONS(192), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(190), 15,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      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,
+  [16389] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(637), 1,
+      anon_sym_DASH_GT,
+    STATE(181), 1,
+      sym_math_operator,
+    STATE(188), 1,
+      sym_logic_operator,
+    ACTIONS(196), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(194), 13,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      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,
+  [16422] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(639), 1,
+      anon_sym_async,
+    ACTIONS(641), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(220), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16465] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(643), 1,
+      anon_sym_async,
+    ACTIONS(645), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(285), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16508] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(647), 1,
+      anon_sym_async,
+    ACTIONS(649), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(295), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16551] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(637), 1,
+      anon_sym_DASH_GT,
+    STATE(181), 1,
+      sym_math_operator,
+    STATE(188), 1,
+      sym_logic_operator,
+    ACTIONS(202), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(200), 13,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      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,
+  [16584] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(653), 7,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      anon_sym_RBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_STAR,
+    ACTIONS(651), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16611] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
     ACTIONS(655), 1,
-      sym__identifier_pattern,
-    ACTIONS(658), 1,
+      anon_sym_async,
+    ACTIONS(657), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(287), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16654] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(181), 1,
+      sym_math_operator,
+    STATE(188), 1,
+      sym_logic_operator,
+    ACTIONS(192), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(190), 14,
+      anon_sym_LPAREN,
       anon_sym_RPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(326), 1,
-      aux_sym_function_repeat1,
-    STATE(430), 1,
-      sym_identifier,
-    ACTIONS(660), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [17823] = 7,
+      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,
+  [16685] = 11,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(663), 1,
-      anon_sym_RBRACE,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(333), 1,
-      aux_sym_map_repeat1,
-    STATE(419), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [17864] = 7,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(655), 1,
+      anon_sym_async,
+    ACTIONS(657), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(295), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16728] = 11,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    ACTIONS(665), 1,
-      anon_sym_RBRACE,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(333), 1,
-      aux_sym_map_repeat1,
-    STATE(419), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [17905] = 7,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(647), 1,
+      anon_sym_async,
+    ACTIONS(649), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(287), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16771] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(639), 1,
+      anon_sym_async,
+    ACTIONS(641), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(221), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16814] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(643), 1,
+      anon_sym_async,
+    ACTIONS(645), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(283), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16857] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(659), 1,
+      anon_sym_async,
+    ACTIONS(661), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(253), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16900] = 11,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(659), 1,
+      anon_sym_async,
+    ACTIONS(661), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    STATE(259), 1,
+      sym_block,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [16943] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(417), 6,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+    ACTIONS(663), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [16969] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(216), 1,
+      anon_sym_LT,
+    STATE(394), 1,
+      sym_type_definition,
+    ACTIONS(208), 2,
+      anon_sym_DASH,
+      anon_sym_GT,
+    ACTIONS(210), 2,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+    ACTIONS(206), 11,
+      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,
+  [17003] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(214), 1,
+      anon_sym_COLON,
+    ACTIONS(208), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(206), 13,
+      anon_sym_RPAREN,
+      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,
+  [17033] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(480), 6,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+    ACTIONS(665), 12,
+      sym_identifier,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
+      anon_sym_assert_equal,
+      anon_sym_env,
+      anon_sym_length,
+      anon_sym_output,
+      anon_sym_random,
+  [17059] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
     ACTIONS(667), 1,
+      anon_sym_DOT_DOT,
+    ACTIONS(226), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(224), 14,
+      anon_sym_LPAREN,
       anon_sym_RPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(326), 1,
-      aux_sym_function_repeat1,
-    STATE(430), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [17946] = 7,
+      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,
+  [17087] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(208), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(206), 14,
+      anon_sym_RPAREN,
+      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,
+  [17115] = 9,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
     ACTIONS(669), 1,
       anon_sym_RPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(326), 1,
-      aux_sym_function_repeat1,
-    STATE(430), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [17987] = 7,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
     ACTIONS(671), 1,
-      anon_sym_RBRACE,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(333), 1,
-      aux_sym_map_repeat1,
-    STATE(419), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18028] = 7,
+      anon_sym_DASH_GT,
+    STATE(186), 1,
+      sym_math_operator,
+    STATE(187), 1,
+      sym_logic_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17152] = 6,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
+    ACTIONS(671), 1,
+      anon_sym_DASH_GT,
+    STATE(186), 1,
+      sym_math_operator,
+    STATE(187), 1,
+      sym_logic_operator,
+    ACTIONS(196), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(194), 11,
+      anon_sym_RPAREN,
+      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,
+  [17183] = 9,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
     ACTIONS(673), 1,
-      anon_sym_RPAREN,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(326), 1,
-      aux_sym_function_repeat1,
-    STATE(430), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18069] = 7,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17220] = 9,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
     ACTIONS(675), 1,
-      sym__identifier_pattern,
-    ACTIONS(678), 1,
-      anon_sym_RBRACE,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(333), 1,
-      aux_sym_map_repeat1,
-    STATE(419), 1,
+      anon_sym_LBRACE,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17257] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(679), 5,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+    ACTIONS(677), 12,
       sym_identifier,
-    ACTIONS(680), 20,
-      anon_sym_assert,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18110] = 6,
+  [17282] = 9,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(328), 1,
-      aux_sym_map_repeat1,
-    STATE(419), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18148] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(327), 1,
-      aux_sym_map_repeat1,
-    STATE(419), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18186] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(331), 1,
-      aux_sym_map_repeat1,
-    STATE(419), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18224] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(461), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18259] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(685), 1,
-      anon_sym_COMMA,
-    ACTIONS(687), 1,
-      anon_sym_RBRACE,
-    ACTIONS(683), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18292] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(691), 1,
-      anon_sym_COMMA,
-    ACTIONS(693), 1,
-      anon_sym_RBRACE,
-    ACTIONS(689), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18325] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(453), 1,
-      sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18360] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(658), 1,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(671), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(681), 1,
       anon_sym_RPAREN,
-    ACTIONS(697), 1,
-      anon_sym_COMMA,
-    ACTIONS(695), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18393] = 5,
+    STATE(186), 1,
+      sym_math_operator,
+    STATE(187), 1,
+      sym_logic_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17319] = 9,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(5), 1,
-      sym__identifier_pattern,
-    STATE(50), 1,
-      sym_built_in_function,
-    STATE(447), 1,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(671), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(683), 1,
+      anon_sym_RPAREN,
+    STATE(186), 1,
+      sym_math_operator,
+    STATE(187), 1,
+      sym_logic_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17356] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(671), 1,
+      anon_sym_DASH_GT,
+    STATE(186), 1,
+      sym_math_operator,
+    STATE(187), 1,
+      sym_logic_operator,
+    ACTIONS(202), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(200), 11,
+      anon_sym_RPAREN,
+      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,
+  [17387] = 9,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(685), 1,
+      anon_sym_EQ_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17424] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(689), 5,
+      anon_sym_LPAREN,
+      anon_sym_LBRACE,
+      sym_float,
+      sym_string,
+      anon_sym_LBRACK,
+    ACTIONS(687), 12,
       sym_identifier,
-    ACTIONS(37), 20,
-      anon_sym_assert,
+      sym_integer,
+      anon_sym_true,
+      anon_sym_false,
+      anon_sym_none,
+      anon_sym_some,
+      anon_sym_args,
       anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
+      anon_sym_env,
       anon_sym_length,
-      anon_sym_metadata,
       anon_sym_output,
-      anon_sym_output_error,
       anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18428] = 3,
+  [17449] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(629), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17483] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(342), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17517] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(552), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17551] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(562), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17585] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(198), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17619] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(204), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17653] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(637), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17687] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(691), 1,
+      anon_sym_RPAREN,
+    ACTIONS(208), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(206), 11,
+      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,
+  [17715] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(318), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17749] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(334), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17783] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(693), 1,
+      anon_sym_RPAREN,
+    ACTIONS(208), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(206), 11,
+      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,
+  [17811] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(697), 1,
+      anon_sym_DASH_GT,
+    ACTIONS(695), 15,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_none,
+      anon_sym_GT,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+      anon_sym_option,
+  [17835] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(701), 1,
-      anon_sym_RBRACE,
-    ACTIONS(699), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18458] = 3,
+      anon_sym_DASH_GT,
+    ACTIONS(699), 15,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_none,
+      anon_sym_GT,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+      anon_sym_option,
+  [17859] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(687), 1,
-      anon_sym_RBRACE,
-    ACTIONS(683), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18488] = 3,
+    ACTIONS(210), 2,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+    ACTIONS(208), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(206), 11,
+      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,
+  [17885] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(336), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17919] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(671), 1,
+      anon_sym_DASH_GT,
+    STATE(173), 1,
+      sym_logic_operator,
+    STATE(174), 1,
+      sym_math_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17953] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(326), 1,
+      anon_sym_DASH,
+    ACTIONS(671), 1,
+      anon_sym_DASH_GT,
+    STATE(186), 1,
+      sym_math_operator,
+    STATE(187), 1,
+      sym_logic_operator,
+    ACTIONS(330), 2,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(324), 4,
+      anon_sym_PLUS,
+      anon_sym_STAR,
+      anon_sym_SLASH,
+      anon_sym_PERCENT,
+    ACTIONS(328), 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,
+  [17987] = 5,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(210), 1,
+      anon_sym_LPAREN,
+    ACTIONS(703), 1,
+      anon_sym_RPAREN,
+    ACTIONS(208), 3,
+      anon_sym_DASH,
+      anon_sym_GT,
+      anon_sym_LT,
+    ACTIONS(206), 11,
+      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,
+  [18015] = 4,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(705), 1,
       anon_sym_RPAREN,
-    ACTIONS(703), 21,
-      sym__identifier_pattern,
-      anon_sym_assert,
-      anon_sym_assert_equal,
-      anon_sym_bash,
-      anon_sym_download,
-      anon_sym_either_or,
-      anon_sym_fish,
-      anon_sym_from_json,
-      anon_sym_is_none,
-      anon_sym_is_some,
-      anon_sym_length,
-      anon_sym_metadata,
-      anon_sym_output,
-      anon_sym_output_error,
-      anon_sym_random,
-      anon_sym_random_boolean,
-      anon_sym_random_float,
-      anon_sym_random_integer,
-      anon_sym_read,
-      anon_sym_to_json,
-      anon_sym_write,
-  [18518] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(535), 1,
-      anon_sym_DASH_GT,
-    STATE(167), 1,
-      sym_math_operator,
-    STATE(169), 1,
-      sym_logic_operator,
-    ACTIONS(199), 3,
+    ACTIONS(276), 3,
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(197), 14,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      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,
-  [18552] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(535), 1,
-      anon_sym_DASH_GT,
-    STATE(167), 1,
-      sym_math_operator,
-    STATE(169), 1,
-      sym_logic_operator,
-    ACTIONS(205), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(203), 14,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      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,
-  [18586] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(167), 1,
-      sym_math_operator,
-    STATE(169), 1,
-      sym_logic_operator,
-    ACTIONS(209), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(207), 15,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COLON,
-      anon_sym_DOT_DOT,
+    ACTIONS(274), 11,
       anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
@@ -24429,422 +18740,16 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [18618] = 11,
+  [18040] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
     ACTIONS(707), 1,
-      anon_sym_async,
-    ACTIONS(709), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(292), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [18661] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(711), 1,
-      anon_sym_async,
-    ACTIONS(713), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(263), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [18704] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    STATE(204), 1,
-      sym_logic_operator,
-    STATE(205), 1,
-      sym_math_operator,
-    ACTIONS(209), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(207), 14,
-      anon_sym_LPAREN,
       anon_sym_RPAREN,
-      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,
-  [18735] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(707), 1,
-      anon_sym_async,
-    ACTIONS(709), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(281), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [18778] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(715), 1,
-      anon_sym_async,
-    ACTIONS(717), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(313), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [18821] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(719), 1,
-      anon_sym_async,
-    ACTIONS(721), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(308), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [18864] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(715), 1,
-      anon_sym_async,
-    ACTIONS(717), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(308), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [18907] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(723), 1,
-      anon_sym_async,
-    ACTIONS(725), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(299), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [18950] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(719), 1,
-      anon_sym_async,
-    ACTIONS(721), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(313), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [18993] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(711), 1,
-      anon_sym_async,
-    ACTIONS(713), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(268), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19036] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(727), 1,
-      anon_sym_DASH_GT,
-    STATE(204), 1,
-      sym_logic_operator,
-    STATE(205), 1,
-      sym_math_operator,
-    ACTIONS(205), 3,
+    ACTIONS(276), 3,
       anon_sym_DASH,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(203), 13,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      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,
-  [19069] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(727), 1,
-      anon_sym_DASH_GT,
-    STATE(204), 1,
-      sym_logic_operator,
-    STATE(205), 1,
-      sym_math_operator,
-    ACTIONS(199), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(197), 13,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      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,
-  [19102] = 11,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(723), 1,
-      anon_sym_async,
-    ACTIONS(725), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    STATE(300), 1,
-      sym_block,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19145] = 7,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(231), 1,
-      anon_sym_LT,
-    STATE(341), 1,
-      sym_type_definition,
-    ACTIONS(223), 2,
-      anon_sym_DASH,
-      anon_sym_GT,
-    ACTIONS(225), 2,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-    ACTIONS(221), 11,
+    ACTIONS(274), 11,
       anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
@@ -24856,428 +18761,10 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_GT_EQ,
       anon_sym_LT_EQ,
       anon_sym_DASH_GT,
-  [19179] = 4,
+  [18065] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(223), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(221), 14,
-      anon_sym_RPAREN,
-      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,
-  [19207] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(265), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(263), 14,
-      anon_sym_RPAREN,
-      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,
-  [19235] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(729), 1,
-      anon_sym_DOT_DOT,
-    ACTIONS(299), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(297), 14,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      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,
-  [19263] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(229), 1,
-      anon_sym_COLON,
-    ACTIONS(223), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(221), 13,
-      anon_sym_RPAREN,
-      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,
-  [19293] = 9,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(731), 1,
-      anon_sym_RPAREN,
-    ACTIONS(733), 1,
-      anon_sym_DASH_GT,
-    STATE(190), 1,
-      sym_math_operator,
-    STATE(191), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19330] = 9,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(733), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(735), 1,
-      anon_sym_RPAREN,
-    STATE(190), 1,
-      sym_math_operator,
-    STATE(191), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19367] = 9,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(733), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(737), 1,
-      anon_sym_RPAREN,
-    STATE(190), 1,
-      sym_math_operator,
-    STATE(191), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19404] = 9,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(739), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19441] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(733), 1,
-      anon_sym_DASH_GT,
-    STATE(190), 1,
-      sym_math_operator,
-    STATE(191), 1,
-      sym_logic_operator,
-    ACTIONS(205), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(203), 11,
-      anon_sym_RPAREN,
-      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,
-  [19472] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(733), 1,
-      anon_sym_DASH_GT,
-    STATE(190), 1,
-      sym_math_operator,
-    STATE(191), 1,
-      sym_logic_operator,
-    ACTIONS(199), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(197), 11,
-      anon_sym_RPAREN,
-      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,
-  [19503] = 9,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(741), 1,
-      anon_sym_LBRACE,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19540] = 9,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(743), 1,
-      anon_sym_EQ_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19577] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(733), 1,
-      anon_sym_DASH_GT,
-    STATE(190), 1,
-      sym_math_operator,
-    STATE(191), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19611] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
-    ACTIONS(745), 1,
-      anon_sym_RPAREN,
-    ACTIONS(223), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(221), 11,
-      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,
-  [19639] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(537), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19673] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(568), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19707] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(749), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(747), 15,
+    ACTIONS(709), 15,
       anon_sym_LPAREN,
       anon_sym_RPAREN,
       anon_sym_COMMA,
@@ -25293,1798 +18780,1656 @@ static const uint16_t ts_small_parse_table[] = {
       anon_sym_num,
       anon_sym_str,
       anon_sym_option,
-  [19731] = 8,
+  [18086] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(345), 1,
+    ACTIONS(711), 1,
+      anon_sym_RPAREN,
+    ACTIONS(276), 3,
       anon_sym_DASH,
-    ACTIONS(353), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
       anon_sym_GT,
       anon_sym_LT,
-    ACTIONS(343), 4,
+    ACTIONS(274), 11,
       anon_sym_PLUS,
       anon_sym_STAR,
       anon_sym_SLASH,
       anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19765] = 3,
+      anon_sym_DASH_GT,
+  [18111] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(699), 15,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_none,
+      anon_sym_GT,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+      anon_sym_option,
+  [18132] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(713), 15,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_none,
+      anon_sym_GT,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+      anon_sym_option,
+  [18153] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(715), 15,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACK,
+      anon_sym_RBRACK,
+      anon_sym_none,
+      anon_sym_GT,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+      anon_sym_option,
+  [18174] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(717), 1,
+      anon_sym_LPAREN,
+    ACTIONS(720), 1,
+      anon_sym_RPAREN,
+    ACTIONS(722), 1,
+      anon_sym_LBRACK,
+    ACTIONS(728), 1,
+      anon_sym_option,
+    STATE(361), 1,
+      aux_sym_type_repeat1,
+    STATE(364), 1,
+      sym_type,
+    ACTIONS(725), 8,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [18206] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(731), 1,
+      anon_sym_LPAREN,
+    ACTIONS(733), 1,
+      anon_sym_RPAREN,
+    ACTIONS(735), 1,
+      anon_sym_LBRACK,
+    ACTIONS(739), 1,
+      anon_sym_option,
+    STATE(361), 1,
+      aux_sym_type_repeat1,
+    STATE(364), 1,
+      sym_type,
+    ACTIONS(737), 8,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [18238] = 8,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(731), 1,
+      anon_sym_LPAREN,
+    ACTIONS(735), 1,
+      anon_sym_LBRACK,
+    ACTIONS(739), 1,
+      anon_sym_option,
+    ACTIONS(741), 1,
+      anon_sym_RPAREN,
+    STATE(362), 1,
+      aux_sym_type_repeat1,
+    STATE(364), 1,
+      sym_type,
+    ACTIONS(737), 8,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [18270] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(745), 1,
+      anon_sym_COMMA,
+    ACTIONS(743), 12,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+      anon_sym_option,
+  [18291] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(731), 1,
+      anon_sym_LPAREN,
+    ACTIONS(735), 1,
+      anon_sym_LBRACK,
+    ACTIONS(739), 1,
+      anon_sym_option,
+    STATE(356), 1,
+      sym_type,
+    ACTIONS(737), 8,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [18317] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(731), 1,
+      anon_sym_LPAREN,
+    ACTIONS(735), 1,
+      anon_sym_LBRACK,
+    ACTIONS(739), 1,
+      anon_sym_option,
+    STATE(360), 1,
+      sym_type,
+    ACTIONS(737), 8,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [18343] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(731), 1,
+      anon_sym_LPAREN,
+    ACTIONS(735), 1,
+      anon_sym_LBRACK,
+    ACTIONS(739), 1,
+      anon_sym_option,
+    STATE(419), 1,
+      sym_type,
+    ACTIONS(737), 8,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [18369] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(731), 1,
+      anon_sym_LPAREN,
+    ACTIONS(735), 1,
+      anon_sym_LBRACK,
+    ACTIONS(739), 1,
+      anon_sym_option,
+    STATE(426), 1,
+      sym_type,
+    ACTIONS(737), 8,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [18395] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(720), 12,
+      anon_sym_LPAREN,
+      anon_sym_RPAREN,
+      anon_sym_LBRACK,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+      anon_sym_option,
+  [18413] = 6,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(731), 1,
+      anon_sym_LPAREN,
+    ACTIONS(735), 1,
+      anon_sym_LBRACK,
+    ACTIONS(739), 1,
+      anon_sym_option,
+    STATE(421), 1,
+      sym_type,
+    ACTIONS(737), 8,
+      anon_sym_none,
+      anon_sym_any,
+      anon_sym_bool,
+      anon_sym_float,
+      anon_sym_int,
+      anon_sym_map,
+      anon_sym_num,
+      anon_sym_str,
+  [18439] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(543), 1,
+      sym_identifier,
+    ACTIONS(610), 1,
+      anon_sym_elseif,
+    ACTIONS(747), 1,
+      anon_sym_else,
+    STATE(294), 1,
+      sym_else,
+    STATE(275), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(541), 3,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [18464] = 7,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(535), 1,
+      sym_identifier,
+    ACTIONS(610), 1,
+      anon_sym_elseif,
+    ACTIONS(747), 1,
+      anon_sym_else,
+    STATE(293), 1,
+      sym_else,
+    STATE(371), 2,
+      sym_else_if,
+      aux_sym_if_else_repeat1,
+    ACTIONS(533), 3,
+      anon_sym_SEMI,
+      anon_sym_COMMA,
+      anon_sym_RBRACE,
+  [18489] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(749), 2,
+      anon_sym_async,
+      sym_identifier,
+    ACTIONS(751), 6,
+      anon_sym_RPAREN,
+      anon_sym_COMMA,
+      anon_sym_LBRACE,
+      anon_sym_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [18505] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(31), 1,
+      sym_assignment_operator,
+    ACTIONS(218), 3,
+      anon_sym_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [18517] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(42), 1,
+      sym_assignment_operator,
+    ACTIONS(218), 3,
+      anon_sym_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [18529] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    STATE(27), 1,
+      sym_assignment_operator,
+    ACTIONS(218), 3,
+      anon_sym_EQ,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [18541] = 4,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(753), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(751), 15,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_none,
-      anon_sym_GT,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-      anon_sym_option,
-  [19789] = 8,
+      anon_sym_EQ,
+    STATE(42), 1,
+      sym_assignment_operator,
+    ACTIONS(218), 2,
+      anon_sym_PLUS_EQ,
+      anon_sym_DASH_EQ,
+  [18555] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(535), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19823] = 8,
+    ACTIONS(659), 1,
+      anon_sym_async,
+    ACTIONS(661), 1,
+      anon_sym_LBRACE,
+    STATE(255), 1,
+      sym_block,
+  [18568] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(215), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19857] = 5,
+    ACTIONS(655), 1,
+      anon_sym_async,
+    ACTIONS(657), 1,
+      anon_sym_LBRACE,
+    STATE(296), 1,
+      sym_block,
+  [18581] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
     ACTIONS(755), 1,
-      anon_sym_RPAREN,
-    ACTIONS(223), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(221), 11,
-      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,
-  [19885] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 2,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-    ACTIONS(223), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(221), 11,
-      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,
-  [19911] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(727), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19945] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(733), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [19979] = 5,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(225), 1,
-      anon_sym_LPAREN,
+      sym_identifier,
     ACTIONS(757), 1,
-      anon_sym_RPAREN,
-    ACTIONS(223), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(221), 11,
-      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,
-  [20007] = 8,
+      anon_sym_RBRACE,
+    STATE(395), 1,
+      aux_sym_map_repeat1,
+  [18594] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(335), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [20041] = 8,
+    ACTIONS(647), 1,
+      anon_sym_async,
+    ACTIONS(649), 1,
+      anon_sym_LBRACE,
+    STATE(296), 1,
+      sym_block,
+  [18607] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(333), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [20075] = 8,
+    ACTIONS(647), 1,
+      anon_sym_async,
+    ACTIONS(649), 1,
+      anon_sym_LBRACE,
+    STATE(235), 1,
+      sym_block,
+  [18620] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    ACTIONS(413), 1,
-      anon_sym_DASH_GT,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [20109] = 8,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(201), 1,
-      anon_sym_DASH_GT,
-    ACTIONS(345), 1,
-      anon_sym_DASH,
-    STATE(195), 1,
-      sym_math_operator,
-    STATE(196), 1,
-      sym_logic_operator,
-    ACTIONS(349), 2,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(343), 4,
-      anon_sym_PLUS,
-      anon_sym_STAR,
-      anon_sym_SLASH,
-      anon_sym_PERCENT,
-    ACTIONS(347), 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,
-  [20143] = 4,
+    ACTIONS(659), 1,
+      anon_sym_async,
+    ACTIONS(661), 1,
+      anon_sym_LBRACE,
+    STATE(62), 1,
+      sym_block,
+  [18633] = 4,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(759), 1,
+      sym_identifier,
+    ACTIONS(761), 1,
       anon_sym_RPAREN,
-    ACTIONS(249), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(247), 11,
-      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,
-  [20168] = 2,
+    STATE(398), 1,
+      aux_sym_function_repeat1,
+  [18646] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(761), 15,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_none,
-      anon_sym_GT,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-      anon_sym_option,
-  [20189] = 2,
+    ACTIONS(647), 1,
+      anon_sym_async,
+    ACTIONS(649), 1,
+      anon_sym_LBRACE,
+    STATE(228), 1,
+      sym_block,
+  [18659] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(747), 15,
-      anon_sym_LPAREN,
+    ACTIONS(759), 1,
+      sym_identifier,
+    ACTIONS(763), 1,
       anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_none,
-      anon_sym_GT,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-      anon_sym_option,
-  [20210] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(763), 15,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_none,
-      anon_sym_GT,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-      anon_sym_option,
-  [20231] = 4,
+    STATE(398), 1,
+      aux_sym_function_repeat1,
+  [18672] = 4,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(755), 1,
+      sym_identifier,
     ACTIONS(765), 1,
-      anon_sym_RPAREN,
-    ACTIONS(249), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(247), 11,
-      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,
-  [20256] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(767), 15,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_COMMA,
-      anon_sym_LBRACK,
-      anon_sym_RBRACK,
-      anon_sym_none,
-      anon_sym_GT,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-      anon_sym_option,
-  [20277] = 4,
+      anon_sym_RBRACE,
+    STATE(395), 1,
+      aux_sym_map_repeat1,
+  [18685] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(769), 1,
-      anon_sym_RPAREN,
-    ACTIONS(249), 3,
-      anon_sym_DASH,
-      anon_sym_GT,
-      anon_sym_LT,
-    ACTIONS(247), 11,
-      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,
-  [20302] = 8,
+      anon_sym_COMMA,
+    ACTIONS(767), 2,
+      anon_sym_RBRACE,
+      sym_identifier,
+  [18696] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(655), 1,
+      anon_sym_async,
+    ACTIONS(657), 1,
+      anon_sym_LBRACE,
+    STATE(95), 1,
+      sym_block,
+  [18709] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(771), 1,
-      anon_sym_LPAREN,
     ACTIONS(773), 1,
-      anon_sym_RPAREN,
+      anon_sym_COMMA,
+    ACTIONS(771), 2,
+      anon_sym_RBRACE,
+      sym_identifier,
+  [18720] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(759), 1,
+      sym_identifier,
     ACTIONS(775), 1,
-      anon_sym_LBRACK,
-    ACTIONS(779), 1,
-      anon_sym_option,
-    STATE(401), 1,
-      aux_sym_type_repeat1,
-    STATE(403), 1,
-      sym_type,
-    ACTIONS(777), 8,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-  [20334] = 8,
+      anon_sym_RPAREN,
+    STATE(398), 1,
+      aux_sym_function_repeat1,
+  [18733] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(659), 1,
+      anon_sym_async,
+    ACTIONS(661), 1,
+      anon_sym_LBRACE,
+    STATE(60), 1,
+      sym_block,
+  [18746] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(755), 1,
+      sym_identifier,
+    ACTIONS(777), 1,
+      anon_sym_RBRACE,
+    STATE(395), 1,
+      aux_sym_map_repeat1,
+  [18759] = 3,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(781), 1,
-      anon_sym_LPAREN,
-    ACTIONS(784), 1,
+      anon_sym_COMMA,
+    ACTIONS(779), 2,
       anon_sym_RPAREN,
-    ACTIONS(786), 1,
-      anon_sym_LBRACK,
-    ACTIONS(792), 1,
-      anon_sym_option,
-    STATE(401), 1,
-      aux_sym_type_repeat1,
-    STATE(403), 1,
-      sym_type,
-    ACTIONS(789), 8,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-  [20366] = 8,
+      sym_identifier,
+  [18770] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(783), 1,
+      sym_identifier,
+    ACTIONS(786), 1,
+      anon_sym_RBRACE,
+    STATE(395), 1,
+      aux_sym_map_repeat1,
+  [18783] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(788), 1,
+      anon_sym_EQ,
+    ACTIONS(790), 1,
+      anon_sym_LT,
+    STATE(424), 1,
+      sym_type_definition,
+  [18796] = 4,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(655), 1,
+      anon_sym_async,
+    ACTIONS(657), 1,
+      anon_sym_LBRACE,
+    STATE(96), 1,
+      sym_block,
+  [18809] = 4,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(771), 1,
-      anon_sym_LPAREN,
-    ACTIONS(775), 1,
-      anon_sym_LBRACK,
     ACTIONS(779), 1,
-      anon_sym_option,
+      anon_sym_RPAREN,
+    ACTIONS(792), 1,
+      sym_identifier,
+    STATE(398), 1,
+      aux_sym_function_repeat1,
+  [18822] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(790), 1,
+      anon_sym_LT,
+    STATE(385), 1,
+      sym_type_definition,
+  [18832] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(755), 1,
+      sym_identifier,
+    STATE(387), 1,
+      aux_sym_map_repeat1,
+  [18842] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(250), 1,
+      anon_sym_LPAREN,
     ACTIONS(795), 1,
       anon_sym_RPAREN,
-    STATE(400), 1,
-      aux_sym_type_repeat1,
-    STATE(403), 1,
-      sym_type,
-    ACTIONS(777), 8,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-  [20398] = 3,
+  [18852] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(799), 1,
-      anon_sym_COMMA,
-    ACTIONS(797), 12,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_LBRACK,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-      anon_sym_option,
-  [20419] = 6,
+    ACTIONS(790), 1,
+      anon_sym_LT,
+    STATE(389), 1,
+      sym_type_definition,
+  [18862] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(771), 1,
-      anon_sym_LPAREN,
-    ACTIONS(775), 1,
-      anon_sym_LBRACK,
-    ACTIONS(779), 1,
-      anon_sym_option,
-    STATE(398), 1,
-      sym_type,
-    ACTIONS(777), 8,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-  [20445] = 6,
+    ACTIONS(790), 1,
+      anon_sym_LT,
+    STATE(392), 1,
+      sym_type_definition,
+  [18872] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(771), 1,
-      anon_sym_LPAREN,
-    ACTIONS(775), 1,
-      anon_sym_LBRACK,
-    ACTIONS(779), 1,
-      anon_sym_option,
-    STATE(450), 1,
-      sym_type,
-    ACTIONS(777), 8,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-  [20471] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(784), 12,
-      anon_sym_LPAREN,
-      anon_sym_RPAREN,
-      anon_sym_LBRACK,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-      anon_sym_option,
-  [20489] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(771), 1,
-      anon_sym_LPAREN,
-    ACTIONS(775), 1,
-      anon_sym_LBRACK,
-    ACTIONS(779), 1,
-      anon_sym_option,
-    STATE(437), 1,
-      sym_type,
-    ACTIONS(777), 8,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-  [20515] = 6,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(771), 1,
-      anon_sym_LPAREN,
-    ACTIONS(775), 1,
-      anon_sym_LBRACK,
-    ACTIONS(779), 1,
-      anon_sym_option,
+    ACTIONS(790), 1,
+      anon_sym_LT,
     STATE(394), 1,
-      sym_type,
-    ACTIONS(777), 8,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-  [20541] = 6,
+      sym_type_definition,
+  [18882] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(771), 1,
+    ACTIONS(790), 1,
+      anon_sym_LT,
+    STATE(383), 1,
+      sym_type_definition,
+  [18892] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(767), 2,
+      anon_sym_RBRACE,
+      sym_identifier,
+  [18900] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(797), 2,
+      anon_sym_RBRACE,
+      sym_identifier,
+  [18908] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(755), 1,
+      sym_identifier,
+    STATE(380), 1,
+      aux_sym_map_repeat1,
+  [18918] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(250), 1,
       anon_sym_LPAREN,
-    ACTIONS(775), 1,
-      anon_sym_LBRACK,
-    ACTIONS(779), 1,
-      anon_sym_option,
-    STATE(451), 1,
-      sym_type,
-    ACTIONS(777), 8,
-      anon_sym_none,
-      anon_sym_any,
-      anon_sym_bool,
-      anon_sym_float,
-      anon_sym_int,
-      anon_sym_map,
-      anon_sym_num,
-      anon_sym_str,
-  [20567] = 3,
+    ACTIONS(799), 1,
+      anon_sym_RPAREN,
+  [18928] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(31), 1,
-      sym_assignment_operator,
-    ACTIONS(233), 3,
-      anon_sym_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-  [20579] = 3,
+    ACTIONS(790), 1,
+      anon_sym_LT,
+    STATE(382), 1,
+      sym_type_definition,
+  [18938] = 3,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(30), 1,
-      sym_assignment_operator,
-    ACTIONS(233), 3,
-      anon_sym_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-  [20591] = 3,
+    ACTIONS(755), 1,
+      sym_identifier,
+    STATE(393), 1,
+      aux_sym_map_repeat1,
+  [18948] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    STATE(39), 1,
-      sym_assignment_operator,
-    ACTIONS(233), 3,
-      anon_sym_EQ,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-  [20603] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(801), 1,
-      anon_sym_EQ,
-    STATE(31), 1,
-      sym_assignment_operator,
-    ACTIONS(233), 2,
-      anon_sym_PLUS_EQ,
-      anon_sym_DASH_EQ,
-  [20617] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(719), 1,
-      anon_sym_async,
-    ACTIONS(721), 1,
-      anon_sym_LBRACE,
-    STATE(247), 1,
-      sym_block,
-  [20630] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(707), 1,
-      anon_sym_async,
-    ACTIONS(709), 1,
-      anon_sym_LBRACE,
-    STATE(58), 1,
-      sym_block,
-  [20643] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(719), 1,
-      anon_sym_async,
-    ACTIONS(721), 1,
-      anon_sym_LBRACE,
-    STATE(315), 1,
-      sym_block,
-  [20656] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(707), 1,
-      anon_sym_async,
-    ACTIONS(709), 1,
-      anon_sym_LBRACE,
-    STATE(67), 1,
-      sym_block,
-  [20669] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(715), 1,
-      anon_sym_async,
-    ACTIONS(717), 1,
-      anon_sym_LBRACE,
-    STATE(315), 1,
-      sym_block,
-  [20682] = 4,
+    ACTIONS(801), 2,
+      anon_sym_RPAREN,
+      sym_identifier,
+  [18956] = 3,
     ACTIONS(3), 1,
       sym__comment,
+    ACTIONS(250), 1,
+      anon_sym_LPAREN,
     ACTIONS(803), 1,
-      anon_sym_EQ,
-    ACTIONS(805), 1,
+      anon_sym_RPAREN,
+  [18966] = 3,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(790), 1,
       anon_sym_LT,
-    STATE(456), 1,
+    STATE(397), 1,
       sym_type_definition,
-  [20695] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(715), 1,
-      anon_sym_async,
-    ACTIONS(717), 1,
-      anon_sym_LBRACE,
-    STATE(97), 1,
-      sym_block,
-  [20708] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(719), 1,
-      anon_sym_async,
-    ACTIONS(721), 1,
-      anon_sym_LBRACE,
-    STATE(239), 1,
-      sym_block,
-  [20721] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(707), 1,
-      anon_sym_async,
-    ACTIONS(709), 1,
-      anon_sym_LBRACE,
-    STATE(285), 1,
-      sym_block,
-  [20734] = 4,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(715), 1,
-      anon_sym_async,
-    ACTIONS(717), 1,
-      anon_sym_LBRACE,
-    STATE(107), 1,
-      sym_block,
-  [20747] = 3,
+  [18976] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(805), 1,
-      anon_sym_LT,
-    STATE(414), 1,
-      sym_type_definition,
-  [20757] = 3,
+      anon_sym_COLON,
+  [18983] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(805), 1,
-      anon_sym_LT,
-    STATE(415), 1,
-      sym_type_definition,
-  [20767] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(239), 1,
-      anon_sym_LPAREN,
     ACTIONS(807), 1,
-      anon_sym_RPAREN,
-  [20777] = 3,
+      anon_sym_LBRACE,
+  [18990] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(239), 1,
-      anon_sym_LPAREN,
     ACTIONS(809), 1,
-      anon_sym_RPAREN,
-  [20787] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(805), 1,
-      anon_sym_LT,
-    STATE(420), 1,
-      sym_type_definition,
-  [20797] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(805), 1,
-      anon_sym_LT,
-    STATE(423), 1,
-      sym_type_definition,
-  [20807] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(805), 1,
-      anon_sym_LT,
-    STATE(341), 1,
-      sym_type_definition,
-  [20817] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(805), 1,
-      anon_sym_LT,
-    STATE(421), 1,
-      sym_type_definition,
-  [20827] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(805), 1,
-      anon_sym_LT,
-    STATE(417), 1,
-      sym_type_definition,
-  [20837] = 3,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(239), 1,
       anon_sym_LPAREN,
-    ACTIONS(811), 1,
-      anon_sym_RPAREN,
-  [20847] = 2,
+  [18997] = 2,
     ACTIONS(3), 1,
       sym__comment,
-    ACTIONS(743), 1,
-      anon_sym_EQ_GT,
-  [20854] = 2,
+    ACTIONS(811), 1,
+      anon_sym_in,
+  [19004] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(813), 1,
-      anon_sym_COLON,
-  [20861] = 2,
+      anon_sym_GT,
+  [19011] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(815), 1,
-      anon_sym_LBRACE,
-  [20868] = 2,
+      anon_sym_COLON,
+  [19018] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(817), 1,
       anon_sym_RBRACK,
-  [20875] = 2,
+  [19025] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(819), 1,
-      anon_sym_COLON,
-  [20882] = 2,
+      anon_sym_LBRACE,
+  [19032] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(821), 1,
-      anon_sym_LBRACE,
-  [20889] = 2,
+      anon_sym_COLON,
+  [19039] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(823), 1,
-      anon_sym_LBRACE,
-  [20896] = 2,
+      anon_sym_EQ,
+  [19046] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(825), 1,
-      anon_sym_COLON,
-  [20903] = 2,
+      anon_sym_in,
+  [19053] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(827), 1,
-      anon_sym_LPAREN,
-  [20910] = 2,
+      anon_sym_RPAREN,
+  [19060] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(829), 1,
-      anon_sym_LBRACE,
-  [20917] = 2,
+      anon_sym_LPAREN,
+  [19067] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(831), 1,
-      anon_sym_COLON,
-  [20924] = 2,
+      anon_sym_LBRACE,
+  [19074] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(833), 1,
-      anon_sym_LPAREN,
-  [20931] = 2,
+      anon_sym_in,
+  [19081] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(835), 1,
-      anon_sym_LPAREN,
-  [20938] = 2,
+      anon_sym_COLON,
+  [19088] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(837), 1,
-      anon_sym_in,
-  [20945] = 2,
+      anon_sym_LBRACE,
+  [19095] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(839), 1,
-      anon_sym_COLON,
-  [20952] = 2,
+      anon_sym_LPAREN,
+  [19102] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(841), 1,
-      anon_sym_LPAREN,
-  [20959] = 2,
+      sym_identifier,
+  [19109] = 2,
+    ACTIONS(3), 1,
+      sym__comment,
+    ACTIONS(685), 1,
+      anon_sym_EQ_GT,
+  [19116] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(843), 1,
-      anon_sym_GT,
-  [20966] = 2,
+      anon_sym_COLON,
+  [19123] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(845), 1,
-      anon_sym_RPAREN,
-  [20973] = 2,
+      anon_sym_LBRACE,
+  [19130] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(847), 1,
-      anon_sym_LBRACE,
-  [20980] = 2,
+      anon_sym_LPAREN,
+  [19137] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(849), 1,
-      anon_sym_in,
-  [20987] = 2,
+      anon_sym_COLON,
+  [19144] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(851), 1,
-      anon_sym_COLON,
-  [20994] = 2,
+      anon_sym_LPAREN,
+  [19151] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(853), 1,
       ts_builtin_sym_end,
-  [21001] = 2,
+  [19158] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(855), 1,
-      anon_sym_EQ,
-  [21008] = 2,
+      sym_identifier,
+  [19165] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(857), 1,
-      anon_sym_LPAREN,
-  [21015] = 2,
+      anon_sym_COLON,
+  [19172] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(859), 1,
       anon_sym_LPAREN,
-  [21022] = 2,
+  [19179] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(861), 1,
-      anon_sym_COLON,
-  [21029] = 2,
+      sym_identifier,
+  [19186] = 2,
     ACTIONS(3), 1,
       sym__comment,
     ACTIONS(863), 1,
       anon_sym_LPAREN,
-  [21036] = 2,
-    ACTIONS(3), 1,
-      sym__comment,
-    ACTIONS(865), 1,
-      anon_sym_in,
 };
 
 static const uint32_t ts_small_parse_table_map[] = {
-  [SMALL_STATE(84)] = 0,
-  [SMALL_STATE(85)] = 72,
-  [SMALL_STATE(86)] = 144,
-  [SMALL_STATE(87)] = 214,
-  [SMALL_STATE(88)] = 296,
-  [SMALL_STATE(89)] = 368,
-  [SMALL_STATE(90)] = 448,
-  [SMALL_STATE(91)] = 520,
-  [SMALL_STATE(92)] = 587,
-  [SMALL_STATE(93)] = 654,
-  [SMALL_STATE(94)] = 725,
-  [SMALL_STATE(95)] = 796,
-  [SMALL_STATE(96)] = 865,
-  [SMALL_STATE(97)] = 929,
-  [SMALL_STATE(98)] = 993,
-  [SMALL_STATE(99)] = 1057,
-  [SMALL_STATE(100)] = 1121,
-  [SMALL_STATE(101)] = 1185,
-  [SMALL_STATE(102)] = 1249,
-  [SMALL_STATE(103)] = 1313,
-  [SMALL_STATE(104)] = 1377,
-  [SMALL_STATE(105)] = 1441,
-  [SMALL_STATE(106)] = 1505,
-  [SMALL_STATE(107)] = 1569,
-  [SMALL_STATE(108)] = 1633,
-  [SMALL_STATE(109)] = 1697,
-  [SMALL_STATE(110)] = 1761,
-  [SMALL_STATE(111)] = 1825,
-  [SMALL_STATE(112)] = 1889,
-  [SMALL_STATE(113)] = 1955,
-  [SMALL_STATE(114)] = 2019,
-  [SMALL_STATE(115)] = 2087,
-  [SMALL_STATE(116)] = 2151,
-  [SMALL_STATE(117)] = 2215,
-  [SMALL_STATE(118)] = 2279,
-  [SMALL_STATE(119)] = 2343,
-  [SMALL_STATE(120)] = 2409,
-  [SMALL_STATE(121)] = 2473,
-  [SMALL_STATE(122)] = 2537,
-  [SMALL_STATE(123)] = 2601,
-  [SMALL_STATE(124)] = 2667,
-  [SMALL_STATE(125)] = 2731,
-  [SMALL_STATE(126)] = 2797,
-  [SMALL_STATE(127)] = 2861,
-  [SMALL_STATE(128)] = 2938,
-  [SMALL_STATE(129)] = 3046,
-  [SMALL_STATE(130)] = 3118,
-  [SMALL_STATE(131)] = 3226,
-  [SMALL_STATE(132)] = 3334,
-  [SMALL_STATE(133)] = 3443,
-  [SMALL_STATE(134)] = 3552,
-  [SMALL_STATE(135)] = 3657,
-  [SMALL_STATE(136)] = 3762,
-  [SMALL_STATE(137)] = 3871,
-  [SMALL_STATE(138)] = 3938,
-  [SMALL_STATE(139)] = 4005,
-  [SMALL_STATE(140)] = 4114,
-  [SMALL_STATE(141)] = 4219,
-  [SMALL_STATE(142)] = 4324,
-  [SMALL_STATE(143)] = 4429,
-  [SMALL_STATE(144)] = 4534,
-  [SMALL_STATE(145)] = 4639,
-  [SMALL_STATE(146)] = 4744,
-  [SMALL_STATE(147)] = 4853,
-  [SMALL_STATE(148)] = 4958,
-  [SMALL_STATE(149)] = 5063,
-  [SMALL_STATE(150)] = 5168,
-  [SMALL_STATE(151)] = 5277,
-  [SMALL_STATE(152)] = 5382,
-  [SMALL_STATE(153)] = 5487,
-  [SMALL_STATE(154)] = 5592,
-  [SMALL_STATE(155)] = 5701,
-  [SMALL_STATE(156)] = 5806,
-  [SMALL_STATE(157)] = 5915,
-  [SMALL_STATE(158)] = 6024,
-  [SMALL_STATE(159)] = 6129,
-  [SMALL_STATE(160)] = 6234,
-  [SMALL_STATE(161)] = 6339,
-  [SMALL_STATE(162)] = 6444,
-  [SMALL_STATE(163)] = 6506,
-  [SMALL_STATE(164)] = 6568,
-  [SMALL_STATE(165)] = 6661,
-  [SMALL_STATE(166)] = 6734,
-  [SMALL_STATE(167)] = 6833,
-  [SMALL_STATE(168)] = 6932,
-  [SMALL_STATE(169)] = 7007,
-  [SMALL_STATE(170)] = 7106,
-  [SMALL_STATE(171)] = 7205,
-  [SMALL_STATE(172)] = 7304,
-  [SMALL_STATE(173)] = 7403,
-  [SMALL_STATE(174)] = 7502,
-  [SMALL_STATE(175)] = 7601,
-  [SMALL_STATE(176)] = 7700,
-  [SMALL_STATE(177)] = 7799,
-  [SMALL_STATE(178)] = 7892,
-  [SMALL_STATE(179)] = 7991,
-  [SMALL_STATE(180)] = 8090,
-  [SMALL_STATE(181)] = 8183,
-  [SMALL_STATE(182)] = 8282,
-  [SMALL_STATE(183)] = 8381,
-  [SMALL_STATE(184)] = 8480,
-  [SMALL_STATE(185)] = 8573,
-  [SMALL_STATE(186)] = 8672,
-  [SMALL_STATE(187)] = 8771,
-  [SMALL_STATE(188)] = 8870,
-  [SMALL_STATE(189)] = 8967,
-  [SMALL_STATE(190)] = 9064,
-  [SMALL_STATE(191)] = 9163,
-  [SMALL_STATE(192)] = 9262,
-  [SMALL_STATE(193)] = 9355,
-  [SMALL_STATE(194)] = 9454,
-  [SMALL_STATE(195)] = 9547,
-  [SMALL_STATE(196)] = 9646,
-  [SMALL_STATE(197)] = 9745,
-  [SMALL_STATE(198)] = 9844,
-  [SMALL_STATE(199)] = 9943,
-  [SMALL_STATE(200)] = 10042,
-  [SMALL_STATE(201)] = 10141,
-  [SMALL_STATE(202)] = 10240,
-  [SMALL_STATE(203)] = 10339,
-  [SMALL_STATE(204)] = 10438,
-  [SMALL_STATE(205)] = 10537,
-  [SMALL_STATE(206)] = 10636,
-  [SMALL_STATE(207)] = 10735,
-  [SMALL_STATE(208)] = 10834,
-  [SMALL_STATE(209)] = 10933,
-  [SMALL_STATE(210)] = 11032,
-  [SMALL_STATE(211)] = 11131,
-  [SMALL_STATE(212)] = 11230,
-  [SMALL_STATE(213)] = 11329,
-  [SMALL_STATE(214)] = 11428,
-  [SMALL_STATE(215)] = 11521,
-  [SMALL_STATE(216)] = 11618,
-  [SMALL_STATE(217)] = 11717,
-  [SMALL_STATE(218)] = 11816,
-  [SMALL_STATE(219)] = 11913,
-  [SMALL_STATE(220)] = 12012,
-  [SMALL_STATE(221)] = 12086,
-  [SMALL_STATE(222)] = 12160,
-  [SMALL_STATE(223)] = 12221,
-  [SMALL_STATE(224)] = 12284,
-  [SMALL_STATE(225)] = 12347,
-  [SMALL_STATE(226)] = 12403,
-  [SMALL_STATE(227)] = 12459,
-  [SMALL_STATE(228)] = 12517,
-  [SMALL_STATE(229)] = 12573,
-  [SMALL_STATE(230)] = 12629,
-  [SMALL_STATE(231)] = 12689,
-  [SMALL_STATE(232)] = 12745,
-  [SMALL_STATE(233)] = 12801,
-  [SMALL_STATE(234)] = 12857,
-  [SMALL_STATE(235)] = 12913,
-  [SMALL_STATE(236)] = 12969,
-  [SMALL_STATE(237)] = 13025,
-  [SMALL_STATE(238)] = 13081,
-  [SMALL_STATE(239)] = 13137,
-  [SMALL_STATE(240)] = 13193,
-  [SMALL_STATE(241)] = 13255,
-  [SMALL_STATE(242)] = 13311,
-  [SMALL_STATE(243)] = 13369,
-  [SMALL_STATE(244)] = 13425,
-  [SMALL_STATE(245)] = 13481,
-  [SMALL_STATE(246)] = 13537,
-  [SMALL_STATE(247)] = 13593,
-  [SMALL_STATE(248)] = 13649,
-  [SMALL_STATE(249)] = 13705,
-  [SMALL_STATE(250)] = 13761,
-  [SMALL_STATE(251)] = 13821,
-  [SMALL_STATE(252)] = 13879,
-  [SMALL_STATE(253)] = 13935,
-  [SMALL_STATE(254)] = 13997,
-  [SMALL_STATE(255)] = 14053,
-  [SMALL_STATE(256)] = 14109,
-  [SMALL_STATE(257)] = 14165,
-  [SMALL_STATE(258)] = 14221,
-  [SMALL_STATE(259)] = 14284,
-  [SMALL_STATE(260)] = 14341,
-  [SMALL_STATE(261)] = 14404,
-  [SMALL_STATE(262)] = 14462,
-  [SMALL_STATE(263)] = 14529,
-  [SMALL_STATE(264)] = 14581,
-  [SMALL_STATE(265)] = 14635,
-  [SMALL_STATE(266)] = 14687,
-  [SMALL_STATE(267)] = 14741,
-  [SMALL_STATE(268)] = 14793,
-  [SMALL_STATE(269)] = 14845,
-  [SMALL_STATE(270)] = 14897,
-  [SMALL_STATE(271)] = 14959,
-  [SMALL_STATE(272)] = 15016,
-  [SMALL_STATE(273)] = 15093,
-  [SMALL_STATE(274)] = 15150,
-  [SMALL_STATE(275)] = 15227,
-  [SMALL_STATE(276)] = 15304,
-  [SMALL_STATE(277)] = 15381,
-  [SMALL_STATE(278)] = 15458,
-  [SMALL_STATE(279)] = 15535,
-  [SMALL_STATE(280)] = 15612,
-  [SMALL_STATE(281)] = 15662,
-  [SMALL_STATE(282)] = 15712,
-  [SMALL_STATE(283)] = 15762,
-  [SMALL_STATE(284)] = 15812,
-  [SMALL_STATE(285)] = 15864,
-  [SMALL_STATE(286)] = 15914,
-  [SMALL_STATE(287)] = 15964,
-  [SMALL_STATE(288)] = 16014,
-  [SMALL_STATE(289)] = 16064,
-  [SMALL_STATE(290)] = 16114,
-  [SMALL_STATE(291)] = 16164,
-  [SMALL_STATE(292)] = 16214,
-  [SMALL_STATE(293)] = 16264,
-  [SMALL_STATE(294)] = 16321,
-  [SMALL_STATE(295)] = 16378,
-  [SMALL_STATE(296)] = 16430,
-  [SMALL_STATE(297)] = 16492,
-  [SMALL_STATE(298)] = 16556,
-  [SMALL_STATE(299)] = 16603,
-  [SMALL_STATE(300)] = 16649,
-  [SMALL_STATE(301)] = 16695,
-  [SMALL_STATE(302)] = 16741,
-  [SMALL_STATE(303)] = 16787,
-  [SMALL_STATE(304)] = 16833,
-  [SMALL_STATE(305)] = 16877,
-  [SMALL_STATE(306)] = 16921,
-  [SMALL_STATE(307)] = 16967,
-  [SMALL_STATE(308)] = 17011,
-  [SMALL_STATE(309)] = 17055,
-  [SMALL_STATE(310)] = 17099,
-  [SMALL_STATE(311)] = 17143,
-  [SMALL_STATE(312)] = 17187,
-  [SMALL_STATE(313)] = 17231,
-  [SMALL_STATE(314)] = 17275,
-  [SMALL_STATE(315)] = 17319,
-  [SMALL_STATE(316)] = 17363,
-  [SMALL_STATE(317)] = 17407,
-  [SMALL_STATE(318)] = 17452,
-  [SMALL_STATE(319)] = 17494,
-  [SMALL_STATE(320)] = 17535,
-  [SMALL_STATE(321)] = 17576,
-  [SMALL_STATE(322)] = 17616,
-  [SMALL_STATE(323)] = 17656,
-  [SMALL_STATE(324)] = 17701,
-  [SMALL_STATE(325)] = 17746,
-  [SMALL_STATE(326)] = 17782,
-  [SMALL_STATE(327)] = 17823,
-  [SMALL_STATE(328)] = 17864,
-  [SMALL_STATE(329)] = 17905,
-  [SMALL_STATE(330)] = 17946,
-  [SMALL_STATE(331)] = 17987,
-  [SMALL_STATE(332)] = 18028,
-  [SMALL_STATE(333)] = 18069,
-  [SMALL_STATE(334)] = 18110,
-  [SMALL_STATE(335)] = 18148,
-  [SMALL_STATE(336)] = 18186,
-  [SMALL_STATE(337)] = 18224,
-  [SMALL_STATE(338)] = 18259,
-  [SMALL_STATE(339)] = 18292,
-  [SMALL_STATE(340)] = 18325,
-  [SMALL_STATE(341)] = 18360,
-  [SMALL_STATE(342)] = 18393,
-  [SMALL_STATE(343)] = 18428,
-  [SMALL_STATE(344)] = 18458,
-  [SMALL_STATE(345)] = 18488,
-  [SMALL_STATE(346)] = 18518,
-  [SMALL_STATE(347)] = 18552,
-  [SMALL_STATE(348)] = 18586,
-  [SMALL_STATE(349)] = 18618,
-  [SMALL_STATE(350)] = 18661,
-  [SMALL_STATE(351)] = 18704,
-  [SMALL_STATE(352)] = 18735,
-  [SMALL_STATE(353)] = 18778,
-  [SMALL_STATE(354)] = 18821,
-  [SMALL_STATE(355)] = 18864,
-  [SMALL_STATE(356)] = 18907,
-  [SMALL_STATE(357)] = 18950,
-  [SMALL_STATE(358)] = 18993,
-  [SMALL_STATE(359)] = 19036,
-  [SMALL_STATE(360)] = 19069,
-  [SMALL_STATE(361)] = 19102,
-  [SMALL_STATE(362)] = 19145,
-  [SMALL_STATE(363)] = 19179,
-  [SMALL_STATE(364)] = 19207,
-  [SMALL_STATE(365)] = 19235,
-  [SMALL_STATE(366)] = 19263,
-  [SMALL_STATE(367)] = 19293,
-  [SMALL_STATE(368)] = 19330,
-  [SMALL_STATE(369)] = 19367,
-  [SMALL_STATE(370)] = 19404,
-  [SMALL_STATE(371)] = 19441,
-  [SMALL_STATE(372)] = 19472,
-  [SMALL_STATE(373)] = 19503,
-  [SMALL_STATE(374)] = 19540,
-  [SMALL_STATE(375)] = 19577,
-  [SMALL_STATE(376)] = 19611,
-  [SMALL_STATE(377)] = 19639,
-  [SMALL_STATE(378)] = 19673,
-  [SMALL_STATE(379)] = 19707,
-  [SMALL_STATE(380)] = 19731,
-  [SMALL_STATE(381)] = 19765,
-  [SMALL_STATE(382)] = 19789,
-  [SMALL_STATE(383)] = 19823,
-  [SMALL_STATE(384)] = 19857,
-  [SMALL_STATE(385)] = 19885,
-  [SMALL_STATE(386)] = 19911,
-  [SMALL_STATE(387)] = 19945,
-  [SMALL_STATE(388)] = 19979,
-  [SMALL_STATE(389)] = 20007,
-  [SMALL_STATE(390)] = 20041,
-  [SMALL_STATE(391)] = 20075,
-  [SMALL_STATE(392)] = 20109,
-  [SMALL_STATE(393)] = 20143,
-  [SMALL_STATE(394)] = 20168,
-  [SMALL_STATE(395)] = 20189,
-  [SMALL_STATE(396)] = 20210,
-  [SMALL_STATE(397)] = 20231,
-  [SMALL_STATE(398)] = 20256,
-  [SMALL_STATE(399)] = 20277,
-  [SMALL_STATE(400)] = 20302,
-  [SMALL_STATE(401)] = 20334,
-  [SMALL_STATE(402)] = 20366,
-  [SMALL_STATE(403)] = 20398,
-  [SMALL_STATE(404)] = 20419,
-  [SMALL_STATE(405)] = 20445,
-  [SMALL_STATE(406)] = 20471,
-  [SMALL_STATE(407)] = 20489,
-  [SMALL_STATE(408)] = 20515,
-  [SMALL_STATE(409)] = 20541,
-  [SMALL_STATE(410)] = 20567,
-  [SMALL_STATE(411)] = 20579,
-  [SMALL_STATE(412)] = 20591,
-  [SMALL_STATE(413)] = 20603,
-  [SMALL_STATE(414)] = 20617,
-  [SMALL_STATE(415)] = 20630,
-  [SMALL_STATE(416)] = 20643,
-  [SMALL_STATE(417)] = 20656,
-  [SMALL_STATE(418)] = 20669,
-  [SMALL_STATE(419)] = 20682,
-  [SMALL_STATE(420)] = 20695,
-  [SMALL_STATE(421)] = 20708,
-  [SMALL_STATE(422)] = 20721,
-  [SMALL_STATE(423)] = 20734,
-  [SMALL_STATE(424)] = 20747,
-  [SMALL_STATE(425)] = 20757,
-  [SMALL_STATE(426)] = 20767,
-  [SMALL_STATE(427)] = 20777,
-  [SMALL_STATE(428)] = 20787,
-  [SMALL_STATE(429)] = 20797,
-  [SMALL_STATE(430)] = 20807,
-  [SMALL_STATE(431)] = 20817,
-  [SMALL_STATE(432)] = 20827,
-  [SMALL_STATE(433)] = 20837,
-  [SMALL_STATE(434)] = 20847,
-  [SMALL_STATE(435)] = 20854,
-  [SMALL_STATE(436)] = 20861,
-  [SMALL_STATE(437)] = 20868,
-  [SMALL_STATE(438)] = 20875,
-  [SMALL_STATE(439)] = 20882,
-  [SMALL_STATE(440)] = 20889,
-  [SMALL_STATE(441)] = 20896,
-  [SMALL_STATE(442)] = 20903,
-  [SMALL_STATE(443)] = 20910,
-  [SMALL_STATE(444)] = 20917,
-  [SMALL_STATE(445)] = 20924,
-  [SMALL_STATE(446)] = 20931,
-  [SMALL_STATE(447)] = 20938,
-  [SMALL_STATE(448)] = 20945,
-  [SMALL_STATE(449)] = 20952,
-  [SMALL_STATE(450)] = 20959,
-  [SMALL_STATE(451)] = 20966,
-  [SMALL_STATE(452)] = 20973,
-  [SMALL_STATE(453)] = 20980,
-  [SMALL_STATE(454)] = 20987,
-  [SMALL_STATE(455)] = 20994,
-  [SMALL_STATE(456)] = 21001,
-  [SMALL_STATE(457)] = 21008,
-  [SMALL_STATE(458)] = 21015,
-  [SMALL_STATE(459)] = 21022,
-  [SMALL_STATE(460)] = 21029,
-  [SMALL_STATE(461)] = 21036,
+  [SMALL_STATE(27)] = 0,
+  [SMALL_STATE(28)] = 113,
+  [SMALL_STATE(29)] = 226,
+  [SMALL_STATE(30)] = 339,
+  [SMALL_STATE(31)] = 452,
+  [SMALL_STATE(32)] = 565,
+  [SMALL_STATE(33)] = 678,
+  [SMALL_STATE(34)] = 791,
+  [SMALL_STATE(35)] = 904,
+  [SMALL_STATE(36)] = 1017,
+  [SMALL_STATE(37)] = 1130,
+  [SMALL_STATE(38)] = 1243,
+  [SMALL_STATE(39)] = 1356,
+  [SMALL_STATE(40)] = 1469,
+  [SMALL_STATE(41)] = 1582,
+  [SMALL_STATE(42)] = 1695,
+  [SMALL_STATE(43)] = 1808,
+  [SMALL_STATE(44)] = 1921,
+  [SMALL_STATE(45)] = 1981,
+  [SMALL_STATE(46)] = 2043,
+  [SMALL_STATE(47)] = 2105,
+  [SMALL_STATE(48)] = 2166,
+  [SMALL_STATE(49)] = 2235,
+  [SMALL_STATE(50)] = 2296,
+  [SMALL_STATE(51)] = 2355,
+  [SMALL_STATE(52)] = 2409,
+  [SMALL_STATE(53)] = 2465,
+  [SMALL_STATE(54)] = 2519,
+  [SMALL_STATE(55)] = 2573,
+  [SMALL_STATE(56)] = 2627,
+  [SMALL_STATE(57)] = 2681,
+  [SMALL_STATE(58)] = 2735,
+  [SMALL_STATE(59)] = 2791,
+  [SMALL_STATE(60)] = 2845,
+  [SMALL_STATE(61)] = 2899,
+  [SMALL_STATE(62)] = 2953,
+  [SMALL_STATE(63)] = 3007,
+  [SMALL_STATE(64)] = 3061,
+  [SMALL_STATE(65)] = 3115,
+  [SMALL_STATE(66)] = 3179,
+  [SMALL_STATE(67)] = 3233,
+  [SMALL_STATE(68)] = 3287,
+  [SMALL_STATE(69)] = 3341,
+  [SMALL_STATE(70)] = 3395,
+  [SMALL_STATE(71)] = 3449,
+  [SMALL_STATE(72)] = 3503,
+  [SMALL_STATE(73)] = 3557,
+  [SMALL_STATE(74)] = 3611,
+  [SMALL_STATE(75)] = 3665,
+  [SMALL_STATE(76)] = 3723,
+  [SMALL_STATE(77)] = 3791,
+  [SMALL_STATE(78)] = 3845,
+  [SMALL_STATE(79)] = 3899,
+  [SMALL_STATE(80)] = 3953,
+  [SMALL_STATE(81)] = 4010,
+  [SMALL_STATE(82)] = 4067,
+  [SMALL_STATE(83)] = 4132,
+  [SMALL_STATE(84)] = 4199,
+  [SMALL_STATE(85)] = 4254,
+  [SMALL_STATE(86)] = 4311,
+  [SMALL_STATE(87)] = 4368,
+  [SMALL_STATE(88)] = 4424,
+  [SMALL_STATE(89)] = 4480,
+  [SMALL_STATE(90)] = 4532,
+  [SMALL_STATE(91)] = 4586,
+  [SMALL_STATE(92)] = 4635,
+  [SMALL_STATE(93)] = 4684,
+  [SMALL_STATE(94)] = 4733,
+  [SMALL_STATE(95)] = 4782,
+  [SMALL_STATE(96)] = 4831,
+  [SMALL_STATE(97)] = 4880,
+  [SMALL_STATE(98)] = 4929,
+  [SMALL_STATE(99)] = 4978,
+  [SMALL_STATE(100)] = 5029,
+  [SMALL_STATE(101)] = 5078,
+  [SMALL_STATE(102)] = 5127,
+  [SMALL_STATE(103)] = 5176,
+  [SMALL_STATE(104)] = 5227,
+  [SMALL_STATE(105)] = 5276,
+  [SMALL_STATE(106)] = 5325,
+  [SMALL_STATE(107)] = 5374,
+  [SMALL_STATE(108)] = 5423,
+  [SMALL_STATE(109)] = 5472,
+  [SMALL_STATE(110)] = 5521,
+  [SMALL_STATE(111)] = 5570,
+  [SMALL_STATE(112)] = 5619,
+  [SMALL_STATE(113)] = 5668,
+  [SMALL_STATE(114)] = 5717,
+  [SMALL_STATE(115)] = 5770,
+  [SMALL_STATE(116)] = 5819,
+  [SMALL_STATE(117)] = 5868,
+  [SMALL_STATE(118)] = 5917,
+  [SMALL_STATE(119)] = 5979,
+  [SMALL_STATE(120)] = 6036,
+  [SMALL_STATE(121)] = 6088,
+  [SMALL_STATE(122)] = 6140,
+  [SMALL_STATE(123)] = 6223,
+  [SMALL_STATE(124)] = 6306,
+  [SMALL_STATE(125)] = 6389,
+  [SMALL_STATE(126)] = 6436,
+  [SMALL_STATE(127)] = 6516,
+  [SMALL_STATE(128)] = 6596,
+  [SMALL_STATE(129)] = 6676,
+  [SMALL_STATE(130)] = 6756,
+  [SMALL_STATE(131)] = 6814,
+  [SMALL_STATE(132)] = 6894,
+  [SMALL_STATE(133)] = 6954,
+  [SMALL_STATE(134)] = 7036,
+  [SMALL_STATE(135)] = 7118,
+  [SMALL_STATE(136)] = 7200,
+  [SMALL_STATE(137)] = 7282,
+  [SMALL_STATE(138)] = 7362,
+  [SMALL_STATE(139)] = 7442,
+  [SMALL_STATE(140)] = 7522,
+  [SMALL_STATE(141)] = 7602,
+  [SMALL_STATE(142)] = 7682,
+  [SMALL_STATE(143)] = 7764,
+  [SMALL_STATE(144)] = 7844,
+  [SMALL_STATE(145)] = 7924,
+  [SMALL_STATE(146)] = 8006,
+  [SMALL_STATE(147)] = 8086,
+  [SMALL_STATE(148)] = 8166,
+  [SMALL_STATE(149)] = 8246,
+  [SMALL_STATE(150)] = 8328,
+  [SMALL_STATE(151)] = 8410,
+  [SMALL_STATE(152)] = 8492,
+  [SMALL_STATE(153)] = 8572,
+  [SMALL_STATE(154)] = 8652,
+  [SMALL_STATE(155)] = 8732,
+  [SMALL_STATE(156)] = 8812,
+  [SMALL_STATE(157)] = 8871,
+  [SMALL_STATE(158)] = 8930,
+  [SMALL_STATE(159)] = 9004,
+  [SMALL_STATE(160)] = 9076,
+  [SMALL_STATE(161)] = 9150,
+  [SMALL_STATE(162)] = 9220,
+  [SMALL_STATE(163)] = 9294,
+  [SMALL_STATE(164)] = 9368,
+  [SMALL_STATE(165)] = 9442,
+  [SMALL_STATE(166)] = 9512,
+  [SMALL_STATE(167)] = 9586,
+  [SMALL_STATE(168)] = 9660,
+  [SMALL_STATE(169)] = 9734,
+  [SMALL_STATE(170)] = 9808,
+  [SMALL_STATE(171)] = 9882,
+  [SMALL_STATE(172)] = 9954,
+  [SMALL_STATE(173)] = 10028,
+  [SMALL_STATE(174)] = 10102,
+  [SMALL_STATE(175)] = 10176,
+  [SMALL_STATE(176)] = 10250,
+  [SMALL_STATE(177)] = 10324,
+  [SMALL_STATE(178)] = 10398,
+  [SMALL_STATE(179)] = 10472,
+  [SMALL_STATE(180)] = 10546,
+  [SMALL_STATE(181)] = 10616,
+  [SMALL_STATE(182)] = 10690,
+  [SMALL_STATE(183)] = 10764,
+  [SMALL_STATE(184)] = 10834,
+  [SMALL_STATE(185)] = 10908,
+  [SMALL_STATE(186)] = 10982,
+  [SMALL_STATE(187)] = 11056,
+  [SMALL_STATE(188)] = 11130,
+  [SMALL_STATE(189)] = 11204,
+  [SMALL_STATE(190)] = 11278,
+  [SMALL_STATE(191)] = 11352,
+  [SMALL_STATE(192)] = 11426,
+  [SMALL_STATE(193)] = 11500,
+  [SMALL_STATE(194)] = 11574,
+  [SMALL_STATE(195)] = 11648,
+  [SMALL_STATE(196)] = 11718,
+  [SMALL_STATE(197)] = 11792,
+  [SMALL_STATE(198)] = 11866,
+  [SMALL_STATE(199)] = 11940,
+  [SMALL_STATE(200)] = 12014,
+  [SMALL_STATE(201)] = 12088,
+  [SMALL_STATE(202)] = 12162,
+  [SMALL_STATE(203)] = 12236,
+  [SMALL_STATE(204)] = 12306,
+  [SMALL_STATE(205)] = 12380,
+  [SMALL_STATE(206)] = 12452,
+  [SMALL_STATE(207)] = 12524,
+  [SMALL_STATE(208)] = 12598,
+  [SMALL_STATE(209)] = 12672,
+  [SMALL_STATE(210)] = 12746,
+  [SMALL_STATE(211)] = 12820,
+  [SMALL_STATE(212)] = 12890,
+  [SMALL_STATE(213)] = 12938,
+  [SMALL_STATE(214)] = 12986,
+  [SMALL_STATE(215)] = 13029,
+  [SMALL_STATE(216)] = 13066,
+  [SMALL_STATE(217)] = 13109,
+  [SMALL_STATE(218)] = 13146,
+  [SMALL_STATE(219)] = 13187,
+  [SMALL_STATE(220)] = 13224,
+  [SMALL_STATE(221)] = 13261,
+  [SMALL_STATE(222)] = 13298,
+  [SMALL_STATE(223)] = 13341,
+  [SMALL_STATE(224)] = 13377,
+  [SMALL_STATE(225)] = 13413,
+  [SMALL_STATE(226)] = 13455,
+  [SMALL_STATE(227)] = 13491,
+  [SMALL_STATE(228)] = 13533,
+  [SMALL_STATE(229)] = 13569,
+  [SMALL_STATE(230)] = 13605,
+  [SMALL_STATE(231)] = 13641,
+  [SMALL_STATE(232)] = 13677,
+  [SMALL_STATE(233)] = 13713,
+  [SMALL_STATE(234)] = 13749,
+  [SMALL_STATE(235)] = 13785,
+  [SMALL_STATE(236)] = 13821,
+  [SMALL_STATE(237)] = 13857,
+  [SMALL_STATE(238)] = 13897,
+  [SMALL_STATE(239)] = 13933,
+  [SMALL_STATE(240)] = 13969,
+  [SMALL_STATE(241)] = 14005,
+  [SMALL_STATE(242)] = 14043,
+  [SMALL_STATE(243)] = 14079,
+  [SMALL_STATE(244)] = 14115,
+  [SMALL_STATE(245)] = 14151,
+  [SMALL_STATE(246)] = 14187,
+  [SMALL_STATE(247)] = 14227,
+  [SMALL_STATE(248)] = 14263,
+  [SMALL_STATE(249)] = 14299,
+  [SMALL_STATE(250)] = 14335,
+  [SMALL_STATE(251)] = 14371,
+  [SMALL_STATE(252)] = 14407,
+  [SMALL_STATE(253)] = 14442,
+  [SMALL_STATE(254)] = 14477,
+  [SMALL_STATE(255)] = 14512,
+  [SMALL_STATE(256)] = 14547,
+  [SMALL_STATE(257)] = 14582,
+  [SMALL_STATE(258)] = 14619,
+  [SMALL_STATE(259)] = 14654,
+  [SMALL_STATE(260)] = 14689,
+  [SMALL_STATE(261)] = 14724,
+  [SMALL_STATE(262)] = 14761,
+  [SMALL_STATE(263)] = 14796,
+  [SMALL_STATE(264)] = 14831,
+  [SMALL_STATE(265)] = 14866,
+  [SMALL_STATE(266)] = 14901,
+  [SMALL_STATE(267)] = 14957,
+  [SMALL_STATE(268)] = 14999,
+  [SMALL_STATE(269)] = 15055,
+  [SMALL_STATE(270)] = 15111,
+  [SMALL_STATE(271)] = 15153,
+  [SMALL_STATE(272)] = 15209,
+  [SMALL_STATE(273)] = 15265,
+  [SMALL_STATE(274)] = 15321,
+  [SMALL_STATE(275)] = 15377,
+  [SMALL_STATE(276)] = 15414,
+  [SMALL_STATE(277)] = 15461,
+  [SMALL_STATE(278)] = 15503,
+  [SMALL_STATE(279)] = 15537,
+  [SMALL_STATE(280)] = 15569,
+  [SMALL_STATE(281)] = 15600,
+  [SMALL_STATE(282)] = 15631,
+  [SMALL_STATE(283)] = 15662,
+  [SMALL_STATE(284)] = 15693,
+  [SMALL_STATE(285)] = 15730,
+  [SMALL_STATE(286)] = 15761,
+  [SMALL_STATE(287)] = 15798,
+  [SMALL_STATE(288)] = 15827,
+  [SMALL_STATE(289)] = 15856,
+  [SMALL_STATE(290)] = 15885,
+  [SMALL_STATE(291)] = 15914,
+  [SMALL_STATE(292)] = 15943,
+  [SMALL_STATE(293)] = 15974,
+  [SMALL_STATE(294)] = 16003,
+  [SMALL_STATE(295)] = 16032,
+  [SMALL_STATE(296)] = 16061,
+  [SMALL_STATE(297)] = 16090,
+  [SMALL_STATE(298)] = 16119,
+  [SMALL_STATE(299)] = 16148,
+  [SMALL_STATE(300)] = 16177,
+  [SMALL_STATE(301)] = 16211,
+  [SMALL_STATE(302)] = 16245,
+  [SMALL_STATE(303)] = 16275,
+  [SMALL_STATE(304)] = 16317,
+  [SMALL_STATE(305)] = 16357,
+  [SMALL_STATE(306)] = 16389,
+  [SMALL_STATE(307)] = 16422,
+  [SMALL_STATE(308)] = 16465,
+  [SMALL_STATE(309)] = 16508,
+  [SMALL_STATE(310)] = 16551,
+  [SMALL_STATE(311)] = 16584,
+  [SMALL_STATE(312)] = 16611,
+  [SMALL_STATE(313)] = 16654,
+  [SMALL_STATE(314)] = 16685,
+  [SMALL_STATE(315)] = 16728,
+  [SMALL_STATE(316)] = 16771,
+  [SMALL_STATE(317)] = 16814,
+  [SMALL_STATE(318)] = 16857,
+  [SMALL_STATE(319)] = 16900,
+  [SMALL_STATE(320)] = 16943,
+  [SMALL_STATE(321)] = 16969,
+  [SMALL_STATE(322)] = 17003,
+  [SMALL_STATE(323)] = 17033,
+  [SMALL_STATE(324)] = 17059,
+  [SMALL_STATE(325)] = 17087,
+  [SMALL_STATE(326)] = 17115,
+  [SMALL_STATE(327)] = 17152,
+  [SMALL_STATE(328)] = 17183,
+  [SMALL_STATE(329)] = 17220,
+  [SMALL_STATE(330)] = 17257,
+  [SMALL_STATE(331)] = 17282,
+  [SMALL_STATE(332)] = 17319,
+  [SMALL_STATE(333)] = 17356,
+  [SMALL_STATE(334)] = 17387,
+  [SMALL_STATE(335)] = 17424,
+  [SMALL_STATE(336)] = 17449,
+  [SMALL_STATE(337)] = 17483,
+  [SMALL_STATE(338)] = 17517,
+  [SMALL_STATE(339)] = 17551,
+  [SMALL_STATE(340)] = 17585,
+  [SMALL_STATE(341)] = 17619,
+  [SMALL_STATE(342)] = 17653,
+  [SMALL_STATE(343)] = 17687,
+  [SMALL_STATE(344)] = 17715,
+  [SMALL_STATE(345)] = 17749,
+  [SMALL_STATE(346)] = 17783,
+  [SMALL_STATE(347)] = 17811,
+  [SMALL_STATE(348)] = 17835,
+  [SMALL_STATE(349)] = 17859,
+  [SMALL_STATE(350)] = 17885,
+  [SMALL_STATE(351)] = 17919,
+  [SMALL_STATE(352)] = 17953,
+  [SMALL_STATE(353)] = 17987,
+  [SMALL_STATE(354)] = 18015,
+  [SMALL_STATE(355)] = 18040,
+  [SMALL_STATE(356)] = 18065,
+  [SMALL_STATE(357)] = 18086,
+  [SMALL_STATE(358)] = 18111,
+  [SMALL_STATE(359)] = 18132,
+  [SMALL_STATE(360)] = 18153,
+  [SMALL_STATE(361)] = 18174,
+  [SMALL_STATE(362)] = 18206,
+  [SMALL_STATE(363)] = 18238,
+  [SMALL_STATE(364)] = 18270,
+  [SMALL_STATE(365)] = 18291,
+  [SMALL_STATE(366)] = 18317,
+  [SMALL_STATE(367)] = 18343,
+  [SMALL_STATE(368)] = 18369,
+  [SMALL_STATE(369)] = 18395,
+  [SMALL_STATE(370)] = 18413,
+  [SMALL_STATE(371)] = 18439,
+  [SMALL_STATE(372)] = 18464,
+  [SMALL_STATE(373)] = 18489,
+  [SMALL_STATE(374)] = 18505,
+  [SMALL_STATE(375)] = 18517,
+  [SMALL_STATE(376)] = 18529,
+  [SMALL_STATE(377)] = 18541,
+  [SMALL_STATE(378)] = 18555,
+  [SMALL_STATE(379)] = 18568,
+  [SMALL_STATE(380)] = 18581,
+  [SMALL_STATE(381)] = 18594,
+  [SMALL_STATE(382)] = 18607,
+  [SMALL_STATE(383)] = 18620,
+  [SMALL_STATE(384)] = 18633,
+  [SMALL_STATE(385)] = 18646,
+  [SMALL_STATE(386)] = 18659,
+  [SMALL_STATE(387)] = 18672,
+  [SMALL_STATE(388)] = 18685,
+  [SMALL_STATE(389)] = 18696,
+  [SMALL_STATE(390)] = 18709,
+  [SMALL_STATE(391)] = 18720,
+  [SMALL_STATE(392)] = 18733,
+  [SMALL_STATE(393)] = 18746,
+  [SMALL_STATE(394)] = 18759,
+  [SMALL_STATE(395)] = 18770,
+  [SMALL_STATE(396)] = 18783,
+  [SMALL_STATE(397)] = 18796,
+  [SMALL_STATE(398)] = 18809,
+  [SMALL_STATE(399)] = 18822,
+  [SMALL_STATE(400)] = 18832,
+  [SMALL_STATE(401)] = 18842,
+  [SMALL_STATE(402)] = 18852,
+  [SMALL_STATE(403)] = 18862,
+  [SMALL_STATE(404)] = 18872,
+  [SMALL_STATE(405)] = 18882,
+  [SMALL_STATE(406)] = 18892,
+  [SMALL_STATE(407)] = 18900,
+  [SMALL_STATE(408)] = 18908,
+  [SMALL_STATE(409)] = 18918,
+  [SMALL_STATE(410)] = 18928,
+  [SMALL_STATE(411)] = 18938,
+  [SMALL_STATE(412)] = 18948,
+  [SMALL_STATE(413)] = 18956,
+  [SMALL_STATE(414)] = 18966,
+  [SMALL_STATE(415)] = 18976,
+  [SMALL_STATE(416)] = 18983,
+  [SMALL_STATE(417)] = 18990,
+  [SMALL_STATE(418)] = 18997,
+  [SMALL_STATE(419)] = 19004,
+  [SMALL_STATE(420)] = 19011,
+  [SMALL_STATE(421)] = 19018,
+  [SMALL_STATE(422)] = 19025,
+  [SMALL_STATE(423)] = 19032,
+  [SMALL_STATE(424)] = 19039,
+  [SMALL_STATE(425)] = 19046,
+  [SMALL_STATE(426)] = 19053,
+  [SMALL_STATE(427)] = 19060,
+  [SMALL_STATE(428)] = 19067,
+  [SMALL_STATE(429)] = 19074,
+  [SMALL_STATE(430)] = 19081,
+  [SMALL_STATE(431)] = 19088,
+  [SMALL_STATE(432)] = 19095,
+  [SMALL_STATE(433)] = 19102,
+  [SMALL_STATE(434)] = 19109,
+  [SMALL_STATE(435)] = 19116,
+  [SMALL_STATE(436)] = 19123,
+  [SMALL_STATE(437)] = 19130,
+  [SMALL_STATE(438)] = 19137,
+  [SMALL_STATE(439)] = 19144,
+  [SMALL_STATE(440)] = 19151,
+  [SMALL_STATE(441)] = 19158,
+  [SMALL_STATE(442)] = 19165,
+  [SMALL_STATE(443)] = 19172,
+  [SMALL_STATE(444)] = 19179,
+  [SMALL_STATE(445)] = 19186,
 };
 
 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(50),
-  [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146),
-  [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(439),
-  [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5),
-  [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(61),
-  [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61),
-  [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(62),
-  [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140),
-  [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(79),
-  [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(460),
-  [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(206),
-  [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(203),
-  [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(193),
-  [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(340),
-  [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340),
-  [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(28),
-  [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48),
-  [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(70),
-  [41] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2),
-  [43] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(50),
-  [46] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(146),
-  [49] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(439),
-  [52] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(5),
-  [55] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(61),
-  [58] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(61),
-  [61] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(62),
-  [64] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(140),
-  [67] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(79),
-  [70] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(460),
-  [73] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(206),
-  [76] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(203),
-  [79] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(193),
-  [82] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(340),
-  [85] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(340),
-  [88] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(28),
-  [91] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(48),
-  [94] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(70),
-  [97] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254),
-  [99] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99),
-  [101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66),
-  [103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96),
-  [105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100),
-  [107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302),
-  [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303),
-  [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53),
-  [113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301),
-  [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244),
-  [117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256),
-  [119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267),
-  [121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265),
-  [123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269),
-  [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82),
-  [127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_root, 1),
-  [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113),
-  [131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154),
-  [133] = {.entry = {.count = 1, .reusable = false}}, SHIFT(440),
-  [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4),
-  [137] = {.entry = {.count = 1, .reusable = false}}, SHIFT(110),
-  [139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110),
-  [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(104),
-  [143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149),
-  [145] = {.entry = {.count = 1, .reusable = false}}, SHIFT(103),
-  [147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(457),
-  [149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(198),
-  [151] = {.entry = {.count = 1, .reusable = false}}, SHIFT(207),
-  [153] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176),
-  [155] = {.entry = {.count = 1, .reusable = false}}, SHIFT(342),
-  [157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(342),
-  [159] = {.entry = {.count = 1, .reusable = false}}, SHIFT(32),
-  [161] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102),
-  [163] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101),
-  [165] = {.entry = {.count = 1, .reusable = false}}, SHIFT(245),
-  [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157),
-  [169] = {.entry = {.count = 1, .reusable = false}}, SHIFT(436),
-  [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3),
-  [173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(232),
-  [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232),
-  [177] = {.entry = {.count = 1, .reusable = false}}, SHIFT(228),
-  [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155),
-  [181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(235),
-  [183] = {.entry = {.count = 1, .reusable = false}}, SHIFT(445),
-  [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(213),
-  [187] = {.entry = {.count = 1, .reusable = false}}, SHIFT(337),
-  [189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337),
-  [191] = {.entry = {.count = 1, .reusable = false}}, SHIFT(38),
-  [193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(257),
-  [195] = {.entry = {.count = 1, .reusable = false}}, SHIFT(243),
-  [197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math, 3),
-  [199] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math, 3),
-  [201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184),
-  [203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic, 3),
-  [205] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic, 3),
-  [207] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index, 5),
-  [209] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index, 5),
-  [211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_built_in_function, 1),
-  [213] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_built_in_function, 1),
-  [215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177),
-  [217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 1),
-  [219] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 1),
-  [221] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_kind, 1),
-  [223] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_kind, 1),
-  [225] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_expression_kind, 1),
-  [227] = {.entry = {.count = 1, .reusable = false}}, SHIFT(298),
-  [229] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_expression, 1),
-  [231] = {.entry = {.count = 1, .reusable = false}}, SHIFT(405),
-  [233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298),
-  [235] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4),
-  [237] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4),
-  [239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 1),
-  [241] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 1),
-  [243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 2),
-  [245] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 2),
-  [247] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1),
-  [249] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1),
-  [251] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 5),
-  [253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 5),
-  [255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4),
-  [257] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4),
-  [259] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_option, 4),
-  [261] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_option, 4),
-  [263] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_value, 1),
-  [265] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_value, 1),
-  [267] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1),
-  [269] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1),
-  [271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 3),
-  [273] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 3),
-  [275] = {.entry = {.count = 1, .reusable = false}}, SHIFT(35),
-  [277] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2),
-  [279] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 2),
-  [281] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 4),
-  [283] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 4),
-  [285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3),
-  [287] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3),
-  [289] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_built_in_value, 1),
-  [291] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_built_in_value, 1),
-  [293] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield, 6),
-  [295] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield, 6),
-  [297] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index, 3),
-  [299] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index, 3),
-  [301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187),
-  [303] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_expression, 1),
-  [305] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 3),
-  [307] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 3),
-  [309] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield, 3),
-  [311] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield, 3),
-  [313] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 3),
-  [315] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 3),
-  [317] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_expression, 3),
-  [319] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_expression, 3),
-  [321] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_option, 1),
-  [323] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_option, 1),
-  [325] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 3),
-  [327] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 3),
-  [329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3),
-  [331] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3),
-  [333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180),
-  [335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188),
-  [337] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 1),
-  [339] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 1),
-  [341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287),
-  [343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322),
-  [345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322),
-  [347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321),
-  [349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(321),
-  [351] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_expression_kind, 1),
-  [353] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164),
-  [355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178),
-  [357] = {.entry = {.count = 1, .reusable = true}}, SHIFT(334),
-  [359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310),
-  [361] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434),
-  [363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286),
-  [365] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(245),
-  [368] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(157),
-  [371] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(334),
-  [374] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2),
-  [376] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(232),
-  [379] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(232),
-  [382] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(228),
-  [385] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(155),
-  [388] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(235),
-  [391] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(445),
-  [394] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(434),
-  [397] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(257),
-  [400] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(243),
-  [403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(432),
-  [405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225),
-  [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335),
-  [409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246),
-  [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431),
-  [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218),
-  [415] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428),
-  [417] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55),
-  [419] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69),
-  [421] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(113),
-  [424] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(154),
-  [427] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list, 2),
-  [429] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(335),
-  [432] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(110),
-  [435] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(110),
-  [438] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(104),
-  [441] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(149),
-  [444] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(103),
-  [447] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(457),
-  [450] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(102),
-  [453] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(101),
-  [456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120),
-  [458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111),
-  [460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59),
-  [462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238),
-  [464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116),
-  [466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71),
-  [468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226),
-  [470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64),
-  [472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231),
-  [474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108),
-  [476] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(113),
-  [479] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(154),
-  [482] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(335),
-  [485] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(110),
-  [488] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(110),
-  [491] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(104),
-  [494] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(149),
-  [497] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2),
-  [499] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(103),
-  [502] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(457),
-  [505] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(102),
-  [508] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(101),
-  [511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98),
-  [513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139),
-  [515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336),
-  [517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304),
-  [519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132),
-  [521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156),
-  [523] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 1),
-  [525] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list, 1),
-  [527] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320),
-  [529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 1),
-  [531] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 1),
-  [533] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319),
-  [535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214),
-  [537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192),
-  [539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 2),
-  [541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 2),
-  [543] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208),
-  [545] = {.entry = {.count = 1, .reusable = false}}, SHIFT(422),
-  [547] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197),
-  [549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 1),
-  [551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 1),
-  [553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2),
-  [555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_else_repeat1, 2),
-  [557] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(208),
-  [560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if, 3),
-  [562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if, 3),
-  [564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if, 3),
-  [566] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if, 3),
-  [568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215),
-  [570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136),
-  [572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150),
-  [574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133),
-  [576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for, 5),
-  [578] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for, 5),
-  [580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3),
-  [582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3),
-  [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 3),
-  [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 3),
-  [588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else, 2),
-  [590] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else, 2),
-  [592] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match, 5),
-  [594] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match, 5),
-  [596] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2),
-  [598] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2),
-  [600] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_assignment, 3),
-  [602] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_assignment, 3),
-  [604] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return, 2),
-  [606] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return, 2),
-  [608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 4),
-  [610] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 4),
-  [612] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while, 3),
-  [614] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while, 3),
-  [616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209),
-  [618] = {.entry = {.count = 1, .reusable = false}}, SHIFT(418),
-  [620] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(209),
-  [623] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_operator, 1),
-  [625] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_operator, 1),
-  [627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 3),
-  [629] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 3),
-  [631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318),
-  [633] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 4),
-  [635] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 4),
-  [637] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2),
-  [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 2),
-  [641] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic_operator, 1),
-  [643] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic_operator, 1),
-  [645] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math_operator, 1),
-  [647] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math_operator, 1),
-  [649] = {.entry = {.count = 1, .reusable = false}}, SHIFT(416),
-  [651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_definition, 3),
-  [653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_definition, 3),
-  [655] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_function_repeat1, 2), SHIFT_REPEAT(50),
-  [658] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2),
-  [660] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_function_repeat1, 2), SHIFT_REPEAT(48),
-  [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121),
-  [665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237),
-  [667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(424),
-  [669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429),
-  [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80),
-  [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425),
-  [675] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_map_repeat1, 2), SHIFT_REPEAT(50),
-  [678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 2),
-  [680] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_map_repeat1, 2), SHIFT_REPEAT(48),
-  [683] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_map_repeat1, 4),
-  [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343),
-  [687] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 4),
-  [689] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_map_repeat1, 3),
-  [691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(344),
-  [693] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 3),
-  [695] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_function_repeat1, 2),
-  [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(345),
-  [699] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_map_repeat1, 5),
-  [701] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 5),
-  [703] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_function_repeat1, 3),
-  [705] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 3),
-  [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(439),
-  [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11),
-  [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(452),
-  [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18),
-  [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(440),
-  [717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23),
-  [719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(436),
-  [721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19),
-  [723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(443),
-  [725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8),
-  [727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194),
-  [729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201),
-  [731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60),
-  [733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189),
-  [735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109),
-  [737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241),
-  [739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145),
-  [741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161),
-  [743] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27),
-  [745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124),
-  [747] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 3),
-  [749] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408),
-  [751] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 2),
-  [753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404),
-  [755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236),
-  [757] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78),
-  [759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255),
-  [761] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 5),
-  [763] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1),
-  [765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75),
-  [767] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 4),
-  [769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118),
-  [771] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402),
-  [773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379),
-  [775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407),
-  [777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396),
-  [779] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449),
-  [781] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(402),
-  [784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2),
-  [786] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(407),
-  [789] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(396),
-  [792] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(449),
-  [795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(381),
-  [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 1),
-  [799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(406),
-  [801] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40),
-  [803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42),
-  [805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405),
-  [807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126),
-  [809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234),
-  [811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77),
-  [813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272),
-  [815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16),
-  [817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(395),
-  [819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276),
-  [821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21),
-  [823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25),
-  [825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279),
-  [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141),
-  [829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9),
-  [831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275),
-  [833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212),
-  [835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148),
-  [837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183),
-  [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277),
-  [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409),
-  [843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325),
-  [845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(398),
-  [847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26),
-  [849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217),
-  [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278),
+  [5] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48),
+  [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149),
+  [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(436),
+  [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4),
+  [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(67),
+  [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67),
+  [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(53),
+  [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129),
+  [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55),
+  [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(445),
+  [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(162),
+  [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167),
+  [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168),
+  [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(441),
+  [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(441),
+  [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40),
+  [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(64),
+  [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(76),
+  [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115),
+  [43] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238),
+  [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77),
+  [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(48),
+  [52] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(149),
+  [55] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(436),
+  [58] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(4),
+  [61] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(67),
+  [64] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(67),
+  [67] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(53),
+  [70] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(129),
+  [73] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(55),
+  [76] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(445),
+  [79] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(162),
+  [82] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(167),
+  [85] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(168),
+  [88] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(441),
+  [91] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(441),
+  [94] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(40),
+  [97] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_root_repeat1, 2), SHIFT_REPEAT(64),
+  [100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78),
+  [102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282),
+  [104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280),
+  [106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215),
+  [108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108),
+  [110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117),
+  [112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217),
+  [114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281),
+  [116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245),
+  [118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56),
+  [120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249),
+  [122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219),
+  [124] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_root, 1),
+  [126] = {.entry = {.count = 1, .reusable = false}}, SHIFT(118),
+  [128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142),
+  [130] = {.entry = {.count = 1, .reusable = false}}, SHIFT(428),
+  [132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2),
+  [134] = {.entry = {.count = 1, .reusable = false}}, SHIFT(110),
+  [136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110),
+  [138] = {.entry = {.count = 1, .reusable = false}}, SHIFT(111),
+  [140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148),
+  [142] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112),
+  [144] = {.entry = {.count = 1, .reusable = false}}, SHIFT(443),
+  [146] = {.entry = {.count = 1, .reusable = false}}, SHIFT(177),
+  [148] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160),
+  [150] = {.entry = {.count = 1, .reusable = false}}, SHIFT(200),
+  [152] = {.entry = {.count = 1, .reusable = false}}, SHIFT(444),
+  [154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(444),
+  [156] = {.entry = {.count = 1, .reusable = false}}, SHIFT(35),
+  [158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113),
+  [160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(276),
+  [162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133),
+  [164] = {.entry = {.count = 1, .reusable = false}}, SHIFT(431),
+  [166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3),
+  [168] = {.entry = {.count = 1, .reusable = false}}, SHIFT(226),
+  [170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226),
+  [172] = {.entry = {.count = 1, .reusable = false}}, SHIFT(230),
+  [174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128),
+  [176] = {.entry = {.count = 1, .reusable = false}}, SHIFT(233),
+  [178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(432),
+  [180] = {.entry = {.count = 1, .reusable = false}}, SHIFT(179),
+  [182] = {.entry = {.count = 1, .reusable = false}}, SHIFT(433),
+  [184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433),
+  [186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(36),
+  [188] = {.entry = {.count = 1, .reusable = false}}, SHIFT(236),
+  [190] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index, 5),
+  [192] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index, 5),
+  [194] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math, 3),
+  [196] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math, 3),
+  [198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211),
+  [200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic, 3),
+  [202] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic, 3),
+  [204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180),
+  [206] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression_kind, 1),
+  [208] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression_kind, 1),
+  [210] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_expression_kind, 1),
+  [212] = {.entry = {.count = 1, .reusable = false}}, SHIFT(279),
+  [214] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_expression, 1),
+  [216] = {.entry = {.count = 1, .reusable = false}}, SHIFT(367),
+  [218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279),
+  [220] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 3),
+  [222] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 3),
+  [224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index, 3),
+  [226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index, 3),
+  [228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169),
+  [230] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1),
+  [232] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1),
+  [234] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_option, 4),
+  [236] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_option, 4),
+  [238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_option, 1),
+  [240] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_option, 1),
+  [242] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 4),
+  [244] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 4),
+  [246] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4),
+  [248] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4),
+  [250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 1),
+  [252] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 1),
+  [254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 4),
+  [256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 4),
+  [258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield, 6),
+  [260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield, 6),
+  [262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function, 5),
+  [264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function, 5),
+  [266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3),
+  [268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3),
+  [270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_built_in_value, 1),
+  [272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_built_in_value, 1),
+  [274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1),
+  [276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1),
+  [278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_value, 1),
+  [280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_value, 1),
+  [282] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map, 3),
+  [284] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map, 3),
+  [286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 2),
+  [288] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 2),
+  [290] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_expression, 1),
+  [292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 3),
+  [294] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 3),
+  [296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 3),
+  [298] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 3),
+  [300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_expression, 3),
+  [302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_expression, 3),
+  [304] = {.entry = {.count = 1, .reusable = false}}, SHIFT(33),
+  [306] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 2),
+  [308] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 2),
+  [310] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_block, 3),
+  [312] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_block, 3),
+  [314] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_yield, 3),
+  [316] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_yield, 3),
+  [318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206),
+  [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(330),
+  [326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(330),
+  [328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335),
+  [330] = {.entry = {.count = 1, .reusable = false}}, SHIFT(335),
+  [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262),
+  [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165),
+  [336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183),
+  [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_expression_kind, 1),
+  [340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178),
+  [342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205),
+  [344] = {.entry = {.count = 1, .reusable = false}}, SHIFT(237),
+  [346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408),
+  [348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256),
+  [350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(434),
+  [352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288),
+  [354] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(237),
+  [357] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(133),
+  [360] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(408),
+  [363] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2),
+  [365] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(226),
+  [368] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(226),
+  [371] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(230),
+  [374] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(128),
+  [377] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(233),
+  [380] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(432),
+  [383] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(434),
+  [386] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 2), SHIFT_REPEAT(236),
+  [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(114),
+  [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97),
+  [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(411),
+  [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98),
+  [397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244),
+  [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69),
+  [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298),
+  [403] = {.entry = {.count = 1, .reusable = false}}, SHIFT(321),
+  [405] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410),
+  [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414),
+  [409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(403),
+  [411] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(114),
+  [414] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(142),
+  [417] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list, 2),
+  [419] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(411),
+  [422] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(110),
+  [425] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(110),
+  [428] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(111),
+  [431] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(148),
+  [434] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(112),
+  [437] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(443),
+  [440] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__expression_list, 2), SHIFT_REPEAT(113),
+  [443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51),
+  [445] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57),
+  [447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232),
+  [449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247),
+  [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107),
+  [453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63),
+  [455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240),
+  [457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102),
+  [459] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(114),
+  [462] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(142),
+  [465] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(411),
+  [468] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(110),
+  [471] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(110),
+  [474] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(111),
+  [477] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(148),
+  [480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 2),
+  [482] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(112),
+  [485] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(443),
+  [488] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2), SHIFT_REPEAT(113),
+  [491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61),
+  [493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223),
+  [495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91),
+  [497] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 1),
+  [499] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__expression_list, 1),
+  [501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320),
+  [503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 1),
+  [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_list_repeat1, 1),
+  [507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323),
+  [509] = {.entry = {.count = 1, .reusable = false}}, SHIFT(278),
+  [511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135),
+  [513] = {.entry = {.count = 1, .reusable = false}}, SHIFT(239),
+  [515] = {.entry = {.count = 1, .reusable = false}}, SHIFT(104),
+  [517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134),
+  [519] = {.entry = {.count = 1, .reusable = false}}, SHIFT(75),
+  [521] = {.entry = {.count = 1, .reusable = true}}, SHIFT(400),
+  [523] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59),
+  [525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136),
+  [527] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322),
+  [529] = {.entry = {.count = 1, .reusable = false}}, SHIFT(125),
+  [531] = {.entry = {.count = 1, .reusable = false}}, SHIFT(89),
+  [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 1),
+  [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 1),
+  [537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176),
+  [539] = {.entry = {.count = 1, .reusable = false}}, SHIFT(378),
+  [541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 2),
+  [543] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 2),
+  [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2),
+  [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_else_repeat1, 2),
+  [549] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(176),
+  [552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195),
+  [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if, 3),
+  [556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if, 3),
+  [558] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if, 3),
+  [560] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if, 3),
+  [562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161),
+  [564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_else, 3),
+  [566] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_else, 3),
+  [568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for, 5),
+  [570] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for, 5),
+  [572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 4),
+  [574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 4),
+  [576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else, 2),
+  [578] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else, 2),
+  [580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match, 5),
+  [582] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match, 5),
+  [584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170),
+  [586] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_index_assignment, 3),
+  [588] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_assignment, 3),
+  [590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_while, 3),
+  [592] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_while, 3),
+  [594] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_statement, 2),
+  [596] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_statement, 2),
+  [598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3),
+  [600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3),
+  [602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return, 2),
+  [604] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return, 2),
+  [606] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101),
+  [608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145),
+  [610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172),
+  [612] = {.entry = {.count = 1, .reusable = false}}, SHIFT(379),
+  [614] = {.entry = {.count = 1, .reusable = false}}, SHIFT(242),
+  [616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150),
+  [618] = {.entry = {.count = 1, .reusable = false}}, SHIFT(70),
+  [620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151),
+  [622] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_if_else_repeat1, 2), SHIFT_REPEAT(172),
+  [625] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_operator, 1),
+  [627] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_operator, 1),
+  [629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171),
+  [631] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 3),
+  [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 3),
+  [635] = {.entry = {.count = 1, .reusable = true}}, SHIFT(311),
+  [637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203),
+  [639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(422),
+  [641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24),
+  [643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416),
+  [645] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9),
+  [647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431),
+  [649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16),
+  [651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_match_repeat1, 4),
+  [653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_repeat1, 4),
+  [655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428),
+  [657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18),
+  [659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(436),
+  [661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21),
+  [663] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__expression_list, 2),
+  [665] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_list_repeat1, 2),
+  [667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185),
+  [669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54),
+  [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159),
+  [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131),
+  [675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137),
+  [677] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_math_operator, 1),
+  [679] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_math_operator, 1),
+  [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94),
+  [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234),
+  [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34),
+  [687] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logic_operator, 1),
+  [689] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logic_operator, 1),
+  [691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74),
+  [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93),
+  [695] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 2),
+  [697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366),
+  [699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 3),
+  [701] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365),
+  [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250),
+  [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72),
+  [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100),
+  [709] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 5),
+  [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224),
+  [713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1),
+  [715] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 4),
+  [717] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(363),
+  [720] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2),
+  [722] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(370),
+  [725] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(359),
+  [728] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 2), SHIFT_REPEAT(417),
+  [731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(363),
+  [733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348),
+  [735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370),
+  [737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359),
+  [739] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417),
+  [741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347),
+  [743] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_type_repeat1, 1),
+  [745] = {.entry = {.count = 1, .reusable = true}}, SHIFT(369),
+  [747] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381),
+  [749] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type_definition, 3),
+  [751] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_definition, 3),
+  [753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43),
+  [755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396),
+  [757] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251),
+  [759] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404),
+  [761] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399),
+  [763] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405),
+  [765] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68),
+  [767] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 4),
+  [769] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407),
+  [771] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 3),
+  [773] = {.entry = {.count = 1, .reusable = true}}, SHIFT(406),
+  [775] = {.entry = {.count = 1, .reusable = true}}, SHIFT(402),
+  [777] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116),
+  [779] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2),
+  [781] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412),
+  [783] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 2), SHIFT_REPEAT(396),
+  [786] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 2),
+  [788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38),
+  [790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(367),
+  [792] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 2), SHIFT_REPEAT(404),
+  [795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248),
+  [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_map_repeat1, 5),
+  [799] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109),
+  [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_repeat1, 3),
+  [803] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73),
+  [805] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269),
+  [807] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25),
+  [809] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368),
+  [811] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164),
+  [813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373),
+  [815] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274),
+  [817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358),
+  [819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10),
+  [821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273),
+  [823] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39),
+  [825] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209),
+  [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360),
+  [829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127),
+  [831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15),
+  [833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163),
+  [835] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271),
+  [837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23),
+  [839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194),
+  [841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425),
+  [843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266),
+  [845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6),
+  [847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146),
+  [849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272),
+  [851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147),
   [853] = {.entry = {.count = 1, .reusable = true}},  ACCEPT_INPUT(),
-  [855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29),
-  [857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175),
-  [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144),
-  [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274),
-  [863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179),
-  [865] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185),
+  [855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(429),
+  [857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268),
+  [859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198),
+  [861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418),
+  [863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196),
 };
 
 #ifdef __cplusplus
@@ -27118,7 +20463,7 @@ extern const TSLanguage *tree_sitter_dust(void) {
     .lex_modes = ts_lex_modes,
     .lex_fn = ts_lex,
     .keyword_lex_fn = ts_lex_keywords,
-    .keyword_capture_token = sym__identifier_pattern,
+    .keyword_capture_token = sym_identifier,
     .primary_state_ids = ts_primary_state_ids,
   };
   return &language;