diff --git a/README.md b/README.md index 07231d8..5040597 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,8 @@ It is designed around a lightweight Rust library: - no filesystem access in the library core - concrete and abstract values with constraints and defaults - asymmetric range refinement with `narrower as wider` -- homogeneous associative-array schemas with `{...valueSchema}` +- homogeneous associative-array schemas with `{...valueSchema}` and object rest constraints +- the safe top range `Unknown`, which remains abstract until refined, defaulted, or supplied concretely - deterministic expression evaluation - optional regex support behind a Cargo feature - browser playground support through WebAssembly @@ -26,6 +27,7 @@ decodal = "0.3.0" ## Derive support For embedded Rust applications, Decodal can generate a schema and typed decoder from a Rust struct with the `derive` feature. +Map fields marked with `#[decodal(rest)]` receive additional object fields; `BTreeMap` corresponds to `...Unknown`. ```toml [dependencies] @@ -47,7 +49,7 @@ struct Service { The derive implements: -- `DecodalSchema`, which produces a host schema for `Engine::bind_global` +- `DecodalSchema`, which produces a `Value` range for `Engine::bind_global` - `DecodalDecode`, which converts materialized `Data` into the Rust struct ## CLI diff --git a/crates/decodal-cli/src/main.rs b/crates/decodal-cli/src/main.rs index 423a8ed..6ed264e 100644 --- a/crates/decodal-cli/src/main.rs +++ b/crates/decodal-cli/src/main.rs @@ -5,10 +5,16 @@ use std::{ }; use decodal::{ - Data, Diagnostic, DiagnosticKind, Engine, ImportLoader, LoadedImport, LoadedSource, SourceId, - Span, format_diagnostic_with, + Data, Diagnostic, DiagnosticKind, Engine, ImportLoader, LoadedImport, SourceId, Span, + format_diagnostic_with, }; +struct SourceInput { + key: String, + name: String, + source: String, +} + fn main() -> ExitCode { match run() { Ok(()) => ExitCode::SUCCESS, @@ -69,7 +75,7 @@ fn materialize_path(path: &str) -> Result { .map_err(|error| engine.format_diagnostic(&error)) } -fn read_root_source(path: &str) -> Result { +fn read_root_source(path: &str) -> Result { if path == "-" { use std::io::Read; let mut source = String::new(); @@ -82,7 +88,7 @@ fn read_root_source(path: &str) -> Result { format!("failed to read stdin: {error}"), ) })?; - Ok(LoadedSource { + Ok(SourceInput { key: String::from(""), name: String::from(""), source, @@ -112,11 +118,11 @@ impl ImportLoader for FsLoader { } else { PathBuf::from(path) }; - load_path(&path).map(LoadedImport::Source) + load_path(&path).map(|source| LoadedImport::source(source.key, source.name, source.source)) } } -fn load_path(path: &Path) -> Result { +fn load_path(path: &Path) -> Result { let canonical = path.canonicalize().map_err(|error| { Diagnostic::new( DiagnosticKind::Import, @@ -132,7 +138,7 @@ fn load_path(path: &Path) -> Result { ) })?; let key = canonical.to_string_lossy().into_owned(); - Ok(LoadedSource { + Ok(SourceInput { name: key.clone(), key, source, diff --git a/crates/decodal-core/examples/host_prelude.rs b/crates/decodal-core/examples/host_prelude.rs index 803c90a..a5416a9 100644 --- a/crates/decodal-core/examples/host_prelude.rs +++ b/crates/decodal-core/examples/host_prelude.rs @@ -1,14 +1,14 @@ -use decodal::{Data, EmptyLoader, Engine, HostValue}; +use decodal::{Data, EmptyLoader, Engine, Value}; fn main() -> decodal::Result<()> { let mut engine = Engine::new(EmptyLoader); engine.bind_global( "Service", - HostValue::object([ - ("name", HostValue::string_type()), - ("port", HostValue::int_type().gt(443).default_int(8443)?), - ("enabled", HostValue::bool_type().default_bool(true)?), + Value::object([ + ("name", Value::string_type()), + ("port", Value::int_type().gt(443).default_int(8443)?), + ("enabled", Value::bool_type().default_bool(true)?), ]), )?; diff --git a/crates/decodal-core/examples/structured_import.rs b/crates/decodal-core/examples/structured_import.rs index b0d12a8..1a9df82 100644 --- a/crates/decodal-core/examples/structured_import.rs +++ b/crates/decodal-core/examples/structured_import.rs @@ -1,6 +1,4 @@ -use decodal::{ - Data, Diagnostic, DiagnosticKind, Engine, HostValue, ImportLoader, LoadedImport, Span, -}; +use decodal::{Data, Diagnostic, DiagnosticKind, Engine, ImportLoader, LoadedImport, Span, Value}; const POST: &str = r#"--- title: Hello @@ -33,22 +31,22 @@ impl ImportLoader for ContentLoader { } } -fn parse_markdown(source: &str) -> decodal::Result { +fn parse_markdown(source: &str) -> decodal::Result { let source = source.strip_prefix("---\n").ok_or_else(frontmatter_error)?; let (frontmatter, body) = source.split_once("\n---\n").ok_or_else(frontmatter_error)?; let mut fields = Vec::new(); for line in frontmatter.lines() { let (name, value) = line.split_once(':').ok_or_else(frontmatter_error)?; let value = match value.trim() { - "true" => HostValue::bool(true), - "false" => HostValue::bool(false), - value => HostValue::string(value), + "true" => Value::bool(true), + "false" => Value::bool(false), + value => Value::string(value), }; fields.push((name.trim(), value)); } - Ok(HostValue::object([ - ("frontmatter", HostValue::object(fields)), - ("body", HostValue::string(body)), + Ok(Value::object([ + ("frontmatter", Value::object(fields)), + ("body", Value::string(body)), ])) } diff --git a/crates/decodal-core/src/ast.rs b/crates/decodal-core/src/ast.rs index fc001d9..6d29e43 100644 --- a/crates/decodal-core/src/ast.rs +++ b/crates/decodal-core/src/ast.rs @@ -48,7 +48,10 @@ pub struct SpannedExpr { pub enum Expr { Literal(Literal), Ident(String), - Object(Vec), + Object { + fields: Vec, + rest: Option, + }, Array(Vec), ArrayConstraint { item: ExprId, @@ -116,6 +119,12 @@ pub struct Field { pub span: Span, } +#[derive(Debug, Clone, PartialEq)] +pub struct ObjectRest { + pub value: ExprId, + pub span: Span, +} + #[derive(Debug, Clone, PartialEq)] pub struct Param { pub name: String, diff --git a/crates/decodal-core/src/constraints.rs b/crates/decodal-core/src/constraints.rs index 157568d..b5a0482 100644 --- a/crates/decodal-core/src/constraints.rs +++ b/crates/decodal-core/src/constraints.rs @@ -19,6 +19,10 @@ pub fn normalize_constraints( for entry in constraints { match entry.constraint { + Constraint::Unknown => rest.push(ConstraintEntry { + constraint: Constraint::Unknown, + span: entry.span, + }), Constraint::Type(next) => match primitive { Some((current, current_span)) if current != next => { return Err(Diagnostic::new( diff --git a/crates/decodal-core/src/eval.rs b/crates/decodal-core/src/eval.rs index 636ef3b..ed98194 100644 --- a/crates/decodal-core/src/eval.rs +++ b/crates/decodal-core/src/eval.rs @@ -5,14 +5,15 @@ use crate::{ ast::{Ast, BinaryOp, CompareOp, Expr, Field, Literal, UnaryOp}, constraints::normalize_constraints, diagnostic::{Diagnostic, DiagnosticKind, Result}, - embedding::HostValue, - module::{EmptyLoader, ImportLoader, LoadedImport, LoadedSource, LoadedValue, Module}, + module::{EmptyLoader, ImportLoader, LoadedImport, Module}, parse_source_with_source_id, runtime::{ AbstractValue, Binding, ConcreteValue, Constraint, ConstraintEntry, Data, DataField, Env, EnvId, ExprRef, FunctionParam, FunctionValue, LiteralValue, ModuleId, ObjectField, - ObjectValue, PrimitiveType, RuntimeValue, Thunk, ThunkId, ThunkKind, ThunkState, + ObjectRest as RuntimeObjectRest, ObjectValue, PrimitiveType, RuntimeValue, Thunk, ThunkId, + ThunkKind, ThunkState, }, + value::Value, }; pub struct Engine { @@ -94,8 +95,8 @@ impl Engine { } } - pub fn bind_global(&mut self, name: impl Into, value: HostValue) -> Result { - let value = self.internalize_host_value(value)?; + pub fn bind_global(&mut self, name: impl Into, value: Value) -> Result { + let value = self.internalize_value(value)?; let thunk = self.add_value_thunk(value); self.bind(self.prelude_env, name.into(), thunk); Ok(thunk) @@ -280,9 +281,9 @@ impl Engine { let module = ModuleId(self.modules.len() as u32); let root_env = self.new_env(Some(self.prelude_env)); let root_thunk = if source_form == SourceForm::Fields { - if let Expr::Object(fields) = ast.get(root).expr.clone() { + if let Expr::Object { fields, rest } = ast.get(root).expr.clone() { let object = self - .build_object(module, &fields, root_env) + .build_object(module, &fields, rest.as_ref(), root_env) .expect("module object construction should not fail for parsed fields"); for field in &object.fields { self.bind(root_env, field.name.clone(), field.value); @@ -318,14 +319,14 @@ impl Engine { let current_key = self.modules[current.0 as usize].key.clone(); let loaded = self.loader.load(Some(¤t_key), specifier)?; match loaded { - LoadedImport::Source(LoadedSource { key, name, source }) => { + LoadedImport::Source { key, name, source } => { if let Some(value) = self.find_imported_value(&key) { return self.force(value); } let module = self.add_source(key, name, &source)?; self.eval_module(module) } - LoadedImport::Value(LoadedValue { key, value }) => { + LoadedImport::Value { key, value } => { if let Some(module) = self.find_module(&key) { return self.eval_module(module); } @@ -333,7 +334,7 @@ impl Engine { return self.force(value); } let origin = ImportedValueOrigin::root(key.clone()); - let value = self.internalize_host_value_with_origin(value, Some(&origin))?; + let value = self.internalize_value_with_origin(value, Some(&origin))?; let root = self.add_value_thunk_with_import_origin(value, origin); self.imported_values.push(ImportedValue { key, root }); self.force(root) @@ -354,8 +355,8 @@ impl Engine { match expr { Expr::Literal(literal) => Ok(RuntimeValue::Concrete(literal_to_concrete(literal))), Expr::Ident(name) => self.eval_ident(&name, env, span), - Expr::Object(fields) => self - .build_object(reference.module, &fields, env) + Expr::Object { fields, rest } => self + .build_object(reference.module, &fields, rest.as_ref(), env) .map(|object| RuntimeValue::Concrete(ConcreteValue::Object(object))), Expr::Array(items) => { let thunks = items @@ -699,6 +700,15 @@ impl Engine { } fn eval_ident(&mut self, name: &str, env: EnvId, span: Span) -> Result { + if name == "Unknown" { + return Ok(RuntimeValue::Abstract(AbstractValue { + constraints: vec![ConstraintEntry { + constraint: Constraint::Unknown, + span, + }], + default: None, + })); + } if let Some(primitive) = primitive_type(name) { return Ok(RuntimeValue::Abstract(AbstractValue { constraints: vec![ConstraintEntry { @@ -738,9 +748,23 @@ impl Engine { &mut self, module: ModuleId, fields: &[Field], + rest: Option<&crate::ast::ObjectRest>, env: EnvId, ) -> Result { - let mut object = ObjectValue { fields: Vec::new() }; + let mut object = ObjectValue { + fields: Vec::new(), + rest: rest.map(|rest| RuntimeObjectRest { + value: self.add_expr_thunk_with_span( + ExprRef { + module, + expr: rest.value, + }, + env, + rest.span, + ), + span: rest.span, + }), + }; for field in fields { self.insert_field( &mut object, @@ -805,7 +829,10 @@ impl Engine { return Ok(()); } - let mut nested = ObjectValue { fields: Vec::new() }; + let mut nested = ObjectValue { + fields: Vec::new(), + rest: None, + }; self.insert_field(&mut nested, module, &path[1..], expr, env, span)?; object.fields.push(ObjectField { name: name.clone(), @@ -1032,6 +1059,7 @@ impl Engine { ) -> Result<()> { for wider_entry in &wider.constraints { let implied = match &wider_entry.constraint { + Constraint::Unknown => true, Constraint::Type(wider_type) => narrower.constraints.iter().any(|entry| { matches!(entry.constraint, Constraint::Type(narrower_type) if narrower_type == *wider_type) }), @@ -1145,11 +1173,20 @@ impl Engine { )); }; - for narrower_field in &narrower.fields { - if wider - .fields + let ObjectValue { + fields: narrower_fields, + rest: narrower_rest, + } = narrower; + let ObjectValue { + fields: wider_fields, + rest: wider_rest, + } = wider; + + for narrower_field in &narrower_fields { + if wider_fields .iter() .all(|wider_field| wider_field.name != narrower_field.name) + && wider_rest.is_none() { let origin = self.thunk_import_origin(narrower_field.value).cloned(); let diagnostic_span = if origin.is_some() { @@ -1172,10 +1209,33 @@ impl Engine { } } - let mut refined = ObjectValue { fields: Vec::new() }; - for wider_field in wider.fields { - let Some(narrower_field) = narrower - .fields + if let Some(narrower_rest) = &narrower_rest + && wider_rest.is_none() + { + let diagnostic = Diagnostic::new( + DiagnosticKind::ConstraintViolation, + source_span_or(narrower_rest.span, narrower_diagnostic_span), + "left side of `as` permits additional fields but the right side is closed", + ) + .with_label(operation_span, "`as` applied here"); + let diagnostic = with_source_label( + diagnostic, + narrower_rest.span, + "narrower object rest range declared here", + ); + return Err(with_source_label( + diagnostic, + wider_span, + "closed wider object declared here", + )); + } + + let mut refined = ObjectValue { + fields: Vec::new(), + rest: None, + }; + for wider_field in wider_fields.iter().cloned() { + let Some(narrower_field) = narrower_fields .iter() .find(|narrower_field| narrower_field.name == wider_field.name) else { @@ -1227,6 +1287,82 @@ impl Engine { span: narrower_field.span, }); } + + if let Some(wider_rest) = &wider_rest { + let wider_rest_value = self.force(wider_rest.value)?; + for narrower_field in narrower_fields.iter().filter(|narrower_field| { + wider_fields + .iter() + .all(|wider_field| wider_field.name != narrower_field.name) + }) { + let narrower_origin = self.thunk_import_origin(narrower_field.value).cloned(); + let narrower_value = self.force(narrower_field.value)?; + let field_name = narrower_field.name.clone(); + let narrowed = self + .apply_as( + narrower_value.clone(), + wider_rest_value.clone(), + operation_span, + narrower_field.span, + wider_rest.span, + ) + .map_err(|diagnostic| { + let diagnostic = with_source_label( + diagnostic, + wider_rest.span, + "wider object rest range declared here", + ); + if narrower_origin.is_some() { + annotate_imported_value( + diagnostic, + narrower_origin.as_ref(), + Some(&narrower_value), + ) + } else { + with_source_label( + diagnostic, + narrower_field.span, + format!("additional field `{field_name}` checked here"), + ) + } + })?; + refined.fields.push(ObjectField { + name: field_name, + value: self.add_value_thunk_with_span_and_import_origin( + narrowed, + narrower_field.span, + narrower_origin, + ), + span: narrower_field.span, + }); + } + } + + refined.rest = match (narrower_rest, wider_rest) { + (Some(narrower_rest), Some(wider_rest)) => { + let narrower_origin = self.thunk_import_origin(narrower_rest.value).cloned(); + let narrower_value = self.force(narrower_rest.value)?; + let wider_value = self.force(wider_rest.value)?; + let narrowed = self.apply_as( + narrower_value, + wider_value, + operation_span, + narrower_rest.span, + wider_rest.span, + )?; + Some(RuntimeObjectRest { + value: self.add_value_thunk_with_span_and_import_origin( + narrowed, + narrower_rest.span, + narrower_origin, + ), + span: narrower_rest.span, + }) + } + (None, Some(wider_rest)) => Some(wider_rest), + (None, None) => None, + (Some(_), None) => unreachable!("open narrower object was rejected above"), + }; Ok(RuntimeValue::Concrete(ConcreteValue::Object(refined))) } @@ -1321,7 +1457,46 @@ impl Engine { rhs: ObjectValue, span: Span, ) -> Result { - for rhs_field in rhs.fields { + let lhs_rest = lhs.rest.take(); + let rhs_rest = rhs.rest; + let rhs_field_names = rhs + .fields + .iter() + .map(|field| field.name.clone()) + .collect::>(); + + if let Some(rhs_rest) = &rhs_rest { + let rhs_rest_value = self.force(rhs_rest.value)?; + for lhs_field in lhs + .fields + .iter_mut() + .filter(|field| !rhs_field_names.contains(&field.name)) + { + let lhs_origin = self.thunk_import_origin(lhs_field.value).cloned(); + let lhs_value = self.force(lhs_field.value)?; + let value = self + .compose_and(lhs_value.clone(), rhs_rest_value.clone(), span) + .map_err(|diagnostic| { + let diagnostic = with_source_label( + diagnostic, + rhs_rest.span, + "right object rest constraint declared here", + ); + with_source_label( + diagnostic, + lhs_field.span, + format!("left field `{}` constrained here", lhs_field.name), + ) + })?; + lhs_field.value = self.add_value_thunk_with_span_and_import_origin( + value, + lhs_field.span, + lhs_origin, + ); + } + } + + for mut rhs_field in rhs.fields { if let Some(index) = lhs .fields .iter() @@ -1381,9 +1556,65 @@ impl Engine { lhs.fields[index].span = rhs_field.span; } } else { + if let Some(lhs_rest) = &lhs_rest { + let rhs_origin = self.thunk_import_origin(rhs_field.value).cloned(); + let rhs_value = self.force(rhs_field.value)?; + let lhs_rest_value = self.force(lhs_rest.value)?; + let value = self.compose_and(rhs_value, lhs_rest_value, span).map_err( + |diagnostic| { + let diagnostic = with_source_label( + diagnostic, + lhs_rest.span, + "left object rest constraint declared here", + ); + with_source_label( + diagnostic, + rhs_field.span, + format!("right field `{}` constrained here", rhs_field.name), + ) + }, + )?; + rhs_field.value = self.add_value_thunk_with_span_and_import_origin( + value, + rhs_field.span, + rhs_origin, + ); + } lhs.fields.push(rhs_field); } } + + lhs.rest = match (lhs_rest, rhs_rest) { + (Some(lhs_rest), Some(rhs_rest)) => { + let lhs_origin = self.thunk_import_origin(lhs_rest.value).cloned(); + let lhs_value = self.force(lhs_rest.value)?; + let rhs_value = self.force(rhs_rest.value)?; + let value = self + .compose_and(lhs_value, rhs_value, span) + .map_err(|diagnostic| { + let diagnostic = with_source_label( + diagnostic, + lhs_rest.span, + "left object rest constraint declared here", + ); + with_source_label( + diagnostic, + rhs_rest.span, + "right object rest constraint declared here", + ) + })?; + Some(RuntimeObjectRest { + value: self.add_value_thunk_with_span_and_import_origin( + value, + rhs_rest.span, + lhs_origin, + ), + span: rhs_rest.span, + }) + } + (Some(rest), None) | (None, Some(rest)) => Some(rest), + (None, None) => None, + }; Ok(RuntimeValue::Concrete(ConcreteValue::Object(lhs))) } @@ -1398,6 +1629,7 @@ impl Engine { } fn patch_objects(&mut self, mut lhs: ObjectValue, rhs: ObjectValue) -> Result { + let rhs_rest = rhs.rest; for rhs_field in rhs.fields { if let Some(index) = lhs .fields @@ -1418,6 +1650,9 @@ impl Engine { lhs.fields.push(rhs_field); } } + if rhs_rest.is_some() { + lhs.rest = rhs_rest; + } Ok(RuntimeValue::Concrete(ConcreteValue::Object(lhs))) } @@ -1459,6 +1694,7 @@ impl Engine { constraint.span }; match constraint_value { + Constraint::Unknown => Ok(value), Constraint::Type(primitive) => { if value_matches_primitive(&value, *primitive) { Ok(value) @@ -1547,8 +1783,12 @@ impl Engine { )); }; let value_schema = self.force(*value_constraint)?; - let mut constrained_fields = Vec::with_capacity(object.fields.len()); - for field in object.fields { + let ObjectValue { + fields, + rest: object_rest, + } = object; + let mut constrained_fields = Vec::with_capacity(fields.len()); + for field in fields { let field_span = self.thunk_span(field.value); let field_origin = self.thunk_import_origin(field.value).cloned(); let field_value = self.force(field.value)?; @@ -1592,8 +1832,30 @@ impl Engine { span: field.span, }); } + let constrained_rest = if let Some(object_rest) = object_rest { + let rest_origin = self.thunk_import_origin(object_rest.value).cloned(); + let rest_value = self.force(object_rest.value)?; + let constrained = self.apply_as( + rest_value, + value_schema, + span, + object_rest.span, + constraint_span, + )?; + Some(RuntimeObjectRest { + value: self.add_value_thunk_with_span_and_import_origin( + constrained, + object_rest.span, + rest_origin, + ), + span: object_rest.span, + }) + } else { + None + }; Ok(RuntimeValue::Concrete(ConcreteValue::Object(ObjectValue { fields: constrained_fields, + rest: constrained_rest, }))) } Constraint::Compare(op, expected) => compare_value(&value, *op, expected) @@ -1671,40 +1933,39 @@ impl Engine { } } - fn internalize_host_value(&mut self, value: HostValue) -> Result { - self.internalize_host_value_with_origin(value, None) + fn internalize_value(&mut self, value: Value) -> Result { + self.internalize_value_with_origin(value, None) } - fn internalize_host_value_with_origin( + fn internalize_value_with_origin( &mut self, - value: HostValue, + value: Value, origin: Option<&ImportedValueOrigin>, ) -> Result { match value { - HostValue::String(value) => Ok(RuntimeValue::Concrete(ConcreteValue::String(value))), - HostValue::Int(value) => Ok(RuntimeValue::Concrete(ConcreteValue::Int(value))), - HostValue::Float(value) => Ok(RuntimeValue::Concrete(ConcreteValue::Float(value))), - HostValue::Bool(value) => Ok(RuntimeValue::Concrete(ConcreteValue::Bool(value))), - HostValue::Array(items) => { + Value::String(value) => Ok(RuntimeValue::Concrete(ConcreteValue::String(value))), + Value::Int(value) => Ok(RuntimeValue::Concrete(ConcreteValue::Int(value))), + Value::Float(value) => Ok(RuntimeValue::Concrete(ConcreteValue::Float(value))), + Value::Bool(value) => Ok(RuntimeValue::Concrete(ConcreteValue::Bool(value))), + Value::Array(items) => { let mut thunks = Vec::new(); for (index, item) in items.into_iter().enumerate() { let item_origin = origin.map(|origin| origin.index(index)); - let value = - self.internalize_host_value_with_origin(item, item_origin.as_ref())?; + let value = self.internalize_value_with_origin(item, item_origin.as_ref())?; thunks .push(self.add_value_thunk_with_optional_import_origin(value, item_origin)); } Ok(RuntimeValue::Concrete(ConcreteValue::Array(thunks))) } - HostValue::ArrayConstraint { + Value::ArrayRange { item, mut constraints, default, } => { - let item = self.internalize_host_value_with_origin(*item, origin)?; + let item = self.internalize_value_with_origin(*item, origin)?; let item = self.add_value_thunk_with_optional_import_origin(item, origin.cloned()); let default = if let Some(default) = default { - let value = self.internalize_host_value_with_origin(*default, origin)?; + let value = self.internalize_value_with_origin(*default, origin)?; Some(self.add_value_thunk_with_optional_import_origin(value, origin.cloned())) } else { None @@ -1723,16 +1984,16 @@ impl Engine { default, })) } - HostValue::MapConstraint { + Value::MapRange { value, mut constraints, default, } => { - let value = self.internalize_host_value_with_origin(*value, origin)?; + let value = self.internalize_value_with_origin(*value, origin)?; let value = self.add_value_thunk_with_optional_import_origin(value, origin.cloned()); let default = if let Some(default) = default { - let value = self.internalize_host_value_with_origin(*default, origin)?; + let value = self.internalize_value_with_origin(*default, origin)?; Some(self.add_value_thunk_with_optional_import_origin(value, origin.cloned())) } else { None @@ -1751,8 +2012,11 @@ impl Engine { default, })) } - HostValue::Object(fields) => { - let mut object = ObjectValue { fields: Vec::new() }; + Value::Object { fields, rest } => { + let mut object = ObjectValue { + fields: Vec::new(), + rest: None, + }; for field in fields { let field_origin = origin.map(|origin| origin.field(field.name.clone())); if object @@ -1763,7 +2027,7 @@ impl Engine { let diagnostic = Diagnostic::new( DiagnosticKind::Conflict, Span::default(), - format!("duplicate host object field `{}`", field.name), + format!("duplicate object field `{}`", field.name), ); return Err(annotate_imported_value( diagnostic, @@ -1771,8 +2035,8 @@ impl Engine { None, )); } - let value = self - .internalize_host_value_with_origin(field.value, field_origin.as_ref())?; + let value = + self.internalize_value_with_origin(field.value, field_origin.as_ref())?; let value = self.add_value_thunk_with_optional_import_origin(value, field_origin); object.fields.push(ObjectField { @@ -1781,14 +2045,22 @@ impl Engine { span: Span::default(), }); } + if let Some(rest) = rest { + let rest = self.internalize_value_with_origin(*rest, origin)?; + object.rest = Some(RuntimeObjectRest { + value: self + .add_value_thunk_with_optional_import_origin(rest, origin.cloned()), + span: Span::default(), + }); + } Ok(RuntimeValue::Concrete(ConcreteValue::Object(object))) } - HostValue::Abstract { + Value::Range { constraints, default, } => { let default = if let Some(default) = default { - let value = self.internalize_host_value_with_origin(*default, origin)?; + let value = self.internalize_value_with_origin(*default, origin)?; Some(self.add_value_thunk_with_optional_import_origin(value, origin.cloned())) } else { None @@ -2252,6 +2524,7 @@ fn upper_bound_implies( fn constraint_description(constraint: &Constraint) -> String { match constraint { + Constraint::Unknown => String::from("the unknown top range"), Constraint::Type(primitive) => format!("type {primitive:?}"), Constraint::ArrayItems(_) => String::from("an array element range"), Constraint::MapValues(_) => String::from("a map value range"), @@ -2590,7 +2863,7 @@ fn concrete_scalar_eq(lhs: &ConcreteValue, rhs: &ConcreteValue) -> bool { #[cfg(test)] mod tests { use super::*; - use crate::{LoadedSource, parse_source}; + use crate::parse_source; fn eval_data(source: &str) -> Data { let parsed = parse_source(source).unwrap(); @@ -2887,6 +3160,29 @@ mod tests { assert!(value.default.is_none()); } + #[test] + fn unknown_is_the_unmaterializable_top_range() { + assert_eq!(eval_data("42 as Unknown"), Data::Int(42)); + assert_eq!(eval_data("Unknown default {}"), Data::Object(Vec::new())); + + let parsed = parse_source("Unknown").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let value = engine.eval_root().unwrap(); + let error = engine.materialize(&value).unwrap_err(); + assert_eq!(error.kind, DiagnosticKind::Materialize); + assert!(error.message.contains("unresolved abstract value")); + + let parsed = parse_source("Unknown as Int").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let error = engine.eval_root().unwrap_err(); + assert!(error.message.contains("not known to be narrower")); + + let parsed = parse_source("{...Unknown}").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let value = engine.eval_root().unwrap(); + assert!(engine.materialize(&value).is_err()); + } + #[test] fn abstract_collection_ranges_can_be_proven_narrower() { let parsed = parse_source("[...(Int & > 10)] as [...Int]").unwrap(); @@ -2980,6 +3276,100 @@ mod tests { assert_eq!(eval_data("{} as {...String}"), Data::Object(vec![])); } + #[test] + fn object_rest_constraint_accepts_and_preserves_additional_fields() { + let data = eval_data( + r#" + { + hoge = 1; + fuga = "two"; + extra = true; + } as { + hoge = Int; + fuga = String; + ...Unknown + } + "#, + ); + assert_eq!( + data, + Data::Object(vec![ + DataField { + name: String::from("hoge"), + value: Data::Int(1), + }, + DataField { + name: String::from("fuga"), + value: Data::String(String::from("two")), + }, + DataField { + name: String::from("extra"), + value: Data::Bool(true), + }, + ]) + ); + + assert_eq!( + eval_data("{ hoge = 1; ...Unknown }"), + Data::Object(vec![DataField { + name: String::from("hoge"), + value: Data::Int(1), + }]) + ); + } + + #[test] + fn object_rest_constraint_rejects_invalid_additional_fields() { + let parsed = + parse_source(r#"{ hoge = 1; extra = "no"; } as { hoge = Int; ...Int }"#).unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let error = engine.eval_root().unwrap_err(); + assert_eq!(error.kind, DiagnosticKind::ConstraintViolation); + assert!(error.message.contains("expected Int")); + assert!( + error + .labels + .iter() + .any(|label| label.message.contains("object rest range")) + ); + + let parsed = parse_source("{ hoge = 1; ...Unknown } as { hoge = Int; }").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let error = engine.eval_root().unwrap_err(); + assert!(error.message.contains("permits additional fields")); + } + + #[test] + fn object_rest_constraints_compose_as_ranges() { + assert_eq!( + eval_data("{ fixed = 1; ...Unknown } & { additional = 2; ...Unknown }"), + Data::Object(vec![ + DataField { + name: String::from("fixed"), + value: Data::Int(1), + }, + DataField { + name: String::from("additional"), + value: Data::Int(2), + }, + ]) + ); + + let parsed = + parse_source("{ fixed = Int; ...Int } as { fixed = Unknown; ...Unknown }").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + assert!(matches!( + engine.eval_root().unwrap(), + RuntimeValue::Concrete(ConcreteValue::Object(_)) + )); + + let parsed = + parse_source("{ fixed = Int; ...Unknown } as { fixed = Unknown; ...Int }").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let error = engine.eval_root().unwrap_err(); + assert!(error.message.contains("not known to be narrower")); + } + #[test] fn removed_array_primitive_reports_migration() { let parsed = parse_source("Array").unwrap(); @@ -3100,11 +3490,11 @@ mod tests { .ok_or_else(|| { Diagnostic::new(DiagnosticKind::Import, Span::default(), "missing source") })?; - Ok(LoadedImport::Source(LoadedSource { + Ok(LoadedImport::Source { key: specifier.into(), name: specifier.into(), source, - })) + }) } } @@ -3147,7 +3537,7 @@ mod tests { } } - fn parse_test_markdown(source: &str) -> Result { + fn parse_test_markdown(source: &str) -> Result { let source = source.strip_prefix("---\n").ok_or_else(|| { Diagnostic::new( DiagnosticKind::Import, @@ -3172,15 +3562,15 @@ mod tests { ) })?; let value = match value.trim() { - "true" => HostValue::bool(true), - "false" => HostValue::bool(false), - value => HostValue::string(value.trim_matches('"')), + "true" => Value::bool(true), + "false" => Value::bool(false), + value => Value::string(value.trim_matches('"')), }; fields.push((name.trim(), value)); } - Ok(HostValue::object([ - ("frontmatter", HostValue::object(fields)), - ("body", HostValue::string(body)), + Ok(Value::object([ + ("frontmatter", Value::object(fields)), + ("body", Value::string(body)), ])) } @@ -3275,9 +3665,9 @@ mod tests { fn load(&mut self, _current_key: Option<&str>, _specifier: &str) -> Result { Ok(LoadedImport::value( "content/navigation.json", - HostValue::object([( + Value::object([( "items", - HostValue::array([HostValue::string("home"), HostValue::int(2)]), + Value::array([Value::string("home"), Value::int(2)]), )]), )) } @@ -3308,7 +3698,7 @@ mod tests { fn load(&mut self, _current_key: Option<&str>, _specifier: &str) -> Result { Ok(LoadedImport::value( "shared-value", - HostValue::int_type().default_int(1)?, + Value::int_type().default_int(1)?, )) } } @@ -3351,16 +3741,10 @@ mod tests { engine .bind_global( "Service", - HostValue::object([ - ("name", HostValue::string_type()), - ( - "port", - HostValue::int_type().gt(443).default_int(8443).unwrap(), - ), - ( - "enabled", - HostValue::bool_type().default_bool(true).unwrap(), - ), + Value::object([ + ("name", Value::string_type()), + ("port", Value::int_type().gt(443).default_int(8443).unwrap()), + ("enabled", Value::bool_type().default_bool(true).unwrap()), ]), ) .unwrap(); @@ -3385,12 +3769,9 @@ mod tests { engine .bind_global( "Services", - HostValue::map_of(HostValue::object([ - ("port", HostValue::int_type()), - ( - "enabled", - HostValue::bool_type().default_bool(true).unwrap(), - ), + Value::map_of(Value::object([ + ("port", Value::int_type()), + ("enabled", Value::bool_type().default_bool(true).unwrap()), ])), ) .unwrap(); @@ -3410,14 +3791,35 @@ mod tests { } #[test] - fn host_schema_errors_point_to_the_dcdl_application() { + fn host_prelude_provides_object_rest_and_unknown_ranges() { let mut engine = Engine::new(EmptyLoader); engine .bind_global( - "Service", - HostValue::object([("port", HostValue::int_type())]), + "OpenService", + Value::object_with_rest([("name", Value::string_type())], Value::unknown()), ) .unwrap(); + let module = engine + .add_root_source( + "main", + "main", + r#"{ name = "api"; metadata = { owner = "platform"; }; } as OpenService"#, + ) + .unwrap(); + let value = engine.eval_module(module).unwrap(); + let data = engine.materialize(&value).unwrap(); + let Data::Object(fields) = data else { panic!() }; + assert_eq!(fields.len(), 2); + assert_eq!(fields[0].value, Data::String(String::from("api"))); + assert!(matches!(fields[1].value, Data::Object(_))); + } + + #[test] + fn host_schema_errors_point_to_the_dcdl_application() { + let mut engine = Engine::new(EmptyLoader); + engine + .bind_global("Service", Value::object([("port", Value::int_type())])) + .unwrap(); let module = engine .add_root_source("main", "main", r#"{ port = "not-an-int"; } as Service"#) .unwrap(); @@ -3435,7 +3837,7 @@ mod tests { #[test] fn module_binding_shadows_host_prelude() { let mut engine = Engine::new(EmptyLoader); - engine.bind_global("Service", HostValue::int(1)).unwrap(); + engine.bind_global("Service", Value::int(1)).unwrap(); let module = engine .add_root_source("main", "main", r#"Service = "local"; result = Service;"#) .unwrap(); diff --git a/crates/decodal-core/src/lib.rs b/crates/decodal-core/src/lib.rs index 0eb112a..e88c196 100644 --- a/crates/decodal-core/src/lib.rs +++ b/crates/decodal-core/src/lib.rs @@ -5,7 +5,6 @@ extern crate alloc; pub mod ast; pub mod constraints; pub mod diagnostic; -pub mod embedding; pub mod environment; pub mod eval; mod lexer; @@ -14,29 +13,28 @@ pub mod parser; pub mod runtime; pub mod span; pub mod typed; +pub mod value; -pub use ast::{Ast, BinaryOp, CompareOp, Expr, ExprId, Field, Literal, Param}; +pub use ast::{Ast, BinaryOp, CompareOp, Expr, ExprId, Field, Literal, ObjectRest, Param}; pub use constraints::normalize_constraints; #[cfg(feature = "derive")] pub use decodal_derive::Decodal; pub use diagnostic::{Diagnostic, DiagnosticKind, Result}; -pub use embedding::{HostField, HostValue}; pub use environment::HostEnvironment; pub use eval::{Engine, format_diagnostic_with}; pub use lexer::{ Token as SyntaxToken, TokenKind as SyntaxTokenKind, tokenize_source, tokenize_source_with_source_id, }; -pub use module::{ - EmptyLoader, ImportCandidate, ImportLoader, LoadedImport, LoadedSource, LoadedValue, Module, -}; +pub use module::{EmptyLoader, ImportCandidate, ImportLoader, LoadedImport, Module}; pub use parser::{ParseOutput, Parser, SourceForm, parse_source, parse_source_with_source_id}; -pub use runtime::{Constraint, Data, ExprRef, LiteralValue, ModuleId, PrimitiveType, RuntimeValue}; +pub use runtime::{Constraint, Data, ExprRef, LiteralValue, ModuleId, PrimitiveType}; pub use span::{SourceId, Span}; pub use typed::{ - DecodalDecode, DecodalSchema, DecodeError, DecodeResult, IntoHostValue, data_at_path, + DecodalDecode, DecodalRest, DecodalSchema, DecodeError, DecodeResult, IntoValue, data_at_path, decode_path, prefix_decode_error, }; +pub use value::{Value, ValueField}; pub fn version() -> &'static str { env!("CARGO_PKG_VERSION") diff --git a/crates/decodal-core/src/module.rs b/crates/decodal-core/src/module.rs index bbda6a4..ee71602 100644 --- a/crates/decodal-core/src/module.rs +++ b/crates/decodal-core/src/module.rs @@ -1,7 +1,7 @@ use alloc::{string::String, vec::Vec}; use crate::{ - Ast, ExprId, HostValue, SourceForm, SourceId, + Ast, ExprId, SourceForm, SourceId, Value, runtime::{EnvId, ThunkId}, }; @@ -17,23 +17,18 @@ pub struct Module { pub root_thunk: ThunkId, } -#[derive(Debug, Clone)] -pub struct LoadedSource { - pub key: String, - pub name: String, - pub source: String, -} - -#[derive(Debug, Clone)] -pub struct LoadedValue { - pub key: String, - pub value: HostValue, -} - +/// Content resolved by an [`ImportLoader`]. #[derive(Debug, Clone)] pub enum LoadedImport { - Source(LoadedSource), - Value(LoadedValue), + Source { + key: String, + name: String, + source: String, + }, + Value { + key: String, + value: Value, + }, } /// An import specifier offered by host-owned language tooling. @@ -63,18 +58,18 @@ impl LoadedImport { name: impl Into, source: impl Into, ) -> Self { - Self::Source(LoadedSource { + Self::Source { key: key.into(), name: name.into(), source: source.into(), - }) + } } - pub fn value(key: impl Into, value: HostValue) -> Self { - Self::Value(LoadedValue { + pub fn value(key: impl Into, value: Value) -> Self { + Self::Value { key: key.into(), value, - }) + } } } diff --git a/crates/decodal-core/src/parser.rs b/crates/decodal-core/src/parser.rs index 5e795a7..ec9c0f1 100644 --- a/crates/decodal-core/src/parser.rs +++ b/crates/decodal-core/src/parser.rs @@ -2,7 +2,10 @@ use alloc::{string::String, vec::Vec}; use crate::{ SourceId, Span, - ast::{Ast, BinaryOp, CompareOp, Expr, ExprId, Field, Literal, MatchArm, Param, UnaryOp}, + ast::{ + Ast, BinaryOp, CompareOp, Expr, ExprId, Field, Literal, MatchArm, ObjectRest, Param, + UnaryOp, + }, diagnostic::{Diagnostic, Result}, lexer::{Lexer, Token, TokenKind}, }; @@ -59,7 +62,7 @@ impl Parser { }) .unwrap_or_else(|| self.peek().span); ( - self.ast.push(Expr::Object(fields), span), + self.ast.push(Expr::Object { fields, rest: None }, span), SourceForm::Fields, ) } else { @@ -338,23 +341,38 @@ impl Parser { let mut fields = Vec::new(); if self.consume_kind(&TokenKind::RBrace).is_some() { - return Ok(self - .ast - .push(Expr::Object(fields), start_span.join(self.previous_span()))); + return Ok(self.ast.push( + Expr::Object { fields, rest: None }, + start_span.join(self.previous_span()), + )); } + let mut rest = None; loop { fields.push(self.parse_field()?); if self.consume_kind(&TokenKind::Semicolon).is_some() { if self.consume_kind(&TokenKind::RBrace).is_some() { break; } + if let Some(ellipsis) = self.consume_kind(&TokenKind::Ellipsis) { + let value = self.parse_expr(0)?; + rest = Some(ObjectRest { + value, + span: ellipsis.join(self.ast.span(value)), + }); + let _ = self.consume_kind(&TokenKind::Semicolon); + self.expect_kind( + &TokenKind::RBrace, + "expected '}' after object rest constraint", + )?; + break; + } continue; } self.expect_kind(&TokenKind::RBrace, "expected ';' or '}' after object field")?; break; } let span = start_span.join(self.previous_span()); - Ok(self.ast.push(Expr::Object(fields), span)) + Ok(self.ast.push(Expr::Object { fields, rest }, span)) } fn parse_array_after_lbracket(&mut self, start_span: Span) -> Result { @@ -697,13 +715,16 @@ mod tests { #[test] fn parses_top_level_fields_as_object() { let parsed = parse_source("port = Int & >= 1 default 8080;").unwrap(); - assert!(matches!(parsed.ast.get(parsed.root).expr, Expr::Object(_))); + assert!(matches!( + parsed.ast.get(parsed.root).expr, + Expr::Object { .. } + )); } #[test] fn parses_object_dot_field() { let parsed = parse_source("{ feature.enable = false; }").unwrap(); - let Expr::Object(fields) = &parsed.ast.get(parsed.root).expr else { + let Expr::Object { fields, .. } = &parsed.ast.get(parsed.root).expr else { panic!() }; assert_eq!(fields[0].path, ["feature", "enable"]); @@ -726,7 +747,7 @@ mod tests { fn parser_accepts_the_public_lossless_token_stream() { let tokens = crate::tokenize_source("value = (# note\n 1);").unwrap(); let parsed = Parser::new(tokens).parse().unwrap(); - let Expr::Object(fields) = &parsed.ast.get(parsed.root).expr else { + let Expr::Object { fields, .. } = &parsed.ast.get(parsed.root).expr else { panic!() }; assert!(matches!( @@ -749,6 +770,17 @@ mod tests { assert!(matches!(parsed.ast.get(value).expr, Expr::Ident(_))); } + #[test] + fn parses_object_rest_constraint_after_named_fields() { + let parsed = parse_source("{ hoge = Int; fuga = String; ...Unknown }").unwrap(); + let Expr::Object { fields, rest } = &parsed.ast.get(parsed.root).expr else { + panic!() + }; + assert_eq!(fields.len(), 2); + let rest = rest.as_ref().expect("object has a rest constraint"); + assert!(matches!(parsed.ast.get(rest.value).expr, Expr::Ident(_))); + } + #[test] fn parses_as_below_composition() { let parsed = parse_source("value & override as Schema").unwrap(); diff --git a/crates/decodal-core/src/runtime.rs b/crates/decodal-core/src/runtime.rs index f8979cd..d135f99 100644 --- a/crates/decodal-core/src/runtime.rs +++ b/crates/decodal-core/src/runtime.rs @@ -11,6 +11,9 @@ pub struct ExprRef { pub expr: ExprId, } +/// Evaluator-owned representation of a lazy concrete value or unresolved range. +/// +/// Embedders normally construct [`crate::Value`] and consume [`Data`] instead. #[derive(Debug, Clone, PartialEq)] pub enum RuntimeValue { Concrete(ConcreteValue), @@ -31,6 +34,13 @@ pub enum ConcreteValue { #[derive(Debug, Clone, PartialEq)] pub struct ObjectValue { pub fields: Vec, + pub rest: Option, +} + +#[derive(Debug, Clone, PartialEq)] +pub struct ObjectRest { + pub value: ThunkId, + pub span: Span, } #[derive(Debug, Clone, PartialEq)] @@ -67,6 +77,7 @@ pub struct ConstraintEntry { #[derive(Debug, Clone, PartialEq)] pub enum Constraint { + Unknown, Type(PrimitiveType), ArrayItems(ThunkId), MapValues(ThunkId), @@ -91,6 +102,7 @@ pub enum LiteralValue { Bool(bool), } +/// Fully materialized Decodal data. #[derive(Debug, Clone, PartialEq)] pub enum Data { String(String), diff --git a/crates/decodal-core/src/typed.rs b/crates/decodal-core/src/typed.rs index 3637358..dbd1428 100644 --- a/crates/decodal-core/src/typed.rs +++ b/crates/decodal-core/src/typed.rs @@ -1,17 +1,24 @@ use alloc::{collections::BTreeMap, format, string::String, vec::Vec}; -use crate::{Data, HostValue}; +use crate::{Data, Value, runtime::DataField}; pub trait DecodalSchema { - fn decodal_schema() -> HostValue; + fn decodal_schema() -> Value; } pub trait DecodalDecode: Sized { fn decodal_decode(data: &Data) -> DecodeResult; } -pub trait IntoHostValue { - fn into_host_value(self) -> HostValue; +pub trait IntoValue { + fn into_value(self) -> Value; +} + +/// A map-like receiver for fields not named by a derived struct schema. +pub trait DecodalRest: Sized { + fn decodal_rest_schema() -> Value; + + fn decodal_decode_rest(data: &Data, known_fields: &[&str]) -> DecodeResult; } pub type DecodeResult = core::result::Result; @@ -80,9 +87,38 @@ fn prefix_error(path: &str, mut error: DecodeError) -> DecodeError { error } +impl DecodalSchema for Data { + fn decodal_schema() -> Value { + Value::unknown() + } +} + +impl DecodalDecode for Data { + fn decodal_decode(data: &Data) -> DecodeResult { + Ok(data.clone()) + } +} + +impl IntoValue for Data { + fn into_value(self) -> Value { + match self { + Data::String(value) => Value::string(value), + Data::Int(value) => Value::int(value), + Data::Float(value) => Value::float(value), + Data::Bool(value) => Value::bool(value), + Data::Array(items) => Value::array(items.into_iter().map(IntoValue::into_value)), + Data::Object(fields) => Value::object( + fields + .into_iter() + .map(|field| (field.name, field.value.into_value())), + ), + } + } +} + impl DecodalSchema for String { - fn decodal_schema() -> HostValue { - HostValue::string_type() + fn decodal_schema() -> Value { + Value::string_type() } } @@ -95,15 +131,15 @@ impl DecodalDecode for String { } } -impl IntoHostValue for String { - fn into_host_value(self) -> HostValue { - HostValue::string(self) +impl IntoValue for String { + fn into_value(self) -> Value { + Value::string(self) } } -impl IntoHostValue for &str { - fn into_host_value(self) -> HostValue { - HostValue::string(self) +impl IntoValue for &str { + fn into_value(self) -> Value { + Value::string(self) } } @@ -111,8 +147,8 @@ macro_rules! impl_int_decode { ($($ty:ty),* $(,)?) => { $( impl DecodalSchema for $ty { - fn decodal_schema() -> HostValue { - HostValue::int_type() + fn decodal_schema() -> Value { + Value::int_type() } } @@ -126,9 +162,9 @@ macro_rules! impl_int_decode { } } - impl IntoHostValue for $ty { - fn into_host_value(self) -> HostValue { - HostValue::int(self as i64) + impl IntoValue for $ty { + fn into_value(self) -> Value { + Value::int(self as i64) } } )* @@ -138,8 +174,8 @@ macro_rules! impl_int_decode { impl_int_decode!(i8, i16, i32, i64, u8, u16, u32); impl DecodalSchema for f64 { - fn decodal_schema() -> HostValue { - HostValue::float_type() + fn decodal_schema() -> Value { + Value::float_type() } } @@ -153,15 +189,15 @@ impl DecodalDecode for f64 { } } -impl IntoHostValue for f64 { - fn into_host_value(self) -> HostValue { - HostValue::float(self) +impl IntoValue for f64 { + fn into_value(self) -> Value { + Value::float(self) } } impl DecodalSchema for f32 { - fn decodal_schema() -> HostValue { - HostValue::float_type() + fn decodal_schema() -> Value { + Value::float_type() } } @@ -171,15 +207,15 @@ impl DecodalDecode for f32 { } } -impl IntoHostValue for f32 { - fn into_host_value(self) -> HostValue { - HostValue::float(f64::from(self)) +impl IntoValue for f32 { + fn into_value(self) -> Value { + Value::float(f64::from(self)) } } impl DecodalSchema for bool { - fn decodal_schema() -> HostValue { - HostValue::bool_type() + fn decodal_schema() -> Value { + Value::bool_type() } } @@ -192,15 +228,15 @@ impl DecodalDecode for bool { } } -impl IntoHostValue for bool { - fn into_host_value(self) -> HostValue { - HostValue::bool(self) +impl IntoValue for bool { + fn into_value(self) -> Value { + Value::bool(self) } } impl DecodalSchema for Vec { - fn decodal_schema() -> HostValue { - HostValue::array_of(T::decodal_schema()) + fn decodal_schema() -> Value { + Value::array_of(T::decodal_schema()) } } @@ -220,15 +256,15 @@ impl DecodalDecode for Vec { } } -impl IntoHostValue for Vec { - fn into_host_value(self) -> HostValue { - HostValue::array(self.into_iter().map(IntoHostValue::into_host_value)) +impl IntoValue for Vec { + fn into_value(self) -> Value { + Value::array(self.into_iter().map(IntoValue::into_value)) } } impl DecodalSchema for BTreeMap { - fn decodal_schema() -> HostValue { - HostValue::map_of(T::decodal_schema()) + fn decodal_schema() -> Value { + Value::map_of(T::decodal_schema()) } } @@ -248,19 +284,36 @@ impl DecodalDecode for BTreeMap { } } -impl IntoHostValue for BTreeMap { - fn into_host_value(self) -> HostValue { - HostValue::object( +impl IntoValue for BTreeMap { + fn into_value(self) -> Value { + Value::object( self.into_iter() - .map(|(name, value)| (name, value.into_host_value())), + .map(|(name, value)| (name, value.into_value())), ) } } +impl DecodalRest for BTreeMap { + fn decodal_rest_schema() -> Value { + T::decodal_schema() + } + + fn decodal_decode_rest(data: &Data, known_fields: &[&str]) -> DecodeResult { + let Data::Object(fields) = data else { + return Err(DecodeError::at_type("", "Object")); + }; + fields + .iter() + .filter(|field| !known_fields.contains(&field.name.as_str())) + .map(decode_rest_field::) + .collect() + } +} + #[cfg(feature = "std")] impl DecodalSchema for std::collections::HashMap { - fn decodal_schema() -> HostValue { - HostValue::map_of(T::decodal_schema()) + fn decodal_schema() -> Value { + Value::map_of(T::decodal_schema()) } } @@ -282,17 +335,41 @@ impl DecodalDecode for std::collections::HashMap { } #[cfg(feature = "std")] -impl IntoHostValue for std::collections::HashMap { - fn into_host_value(self) -> HostValue { +impl IntoValue for std::collections::HashMap { + fn into_value(self) -> Value { let mut fields: Vec<_> = self .into_iter() - .map(|(name, value)| (name, value.into_host_value())) + .map(|(name, value)| (name, value.into_value())) .collect(); fields.sort_by(|left, right| left.0.cmp(&right.0)); - HostValue::object(fields) + Value::object(fields) } } +#[cfg(feature = "std")] +impl DecodalRest for std::collections::HashMap { + fn decodal_rest_schema() -> Value { + T::decodal_schema() + } + + fn decodal_decode_rest(data: &Data, known_fields: &[&str]) -> DecodeResult { + let Data::Object(fields) = data else { + return Err(DecodeError::at_type("", "Object")); + }; + fields + .iter() + .filter(|field| !known_fields.contains(&field.name.as_str())) + .map(decode_rest_field::) + .collect() + } +} + +fn decode_rest_field(field: &DataField) -> DecodeResult<(String, T)> { + T::decodal_decode(&field.value) + .map(|value| (field.name.clone(), value)) + .map_err(|error| prefix_error(&field.name, error)) +} + #[cfg(test)] mod tests { use super::*; @@ -302,10 +379,10 @@ mod tests { fn string_maps_expose_map_schemas_and_decode_objects() { assert!(matches!( BTreeMap::::decodal_schema(), - HostValue::MapConstraint { value, .. } + Value::MapRange { value, .. } if matches!( *value, - HostValue::Abstract { ref constraints, .. } + Value::Range { ref constraints, .. } if constraints == &[Constraint::Type(PrimitiveType::Int)] ) )); @@ -317,4 +394,52 @@ mod tests { let decoded = BTreeMap::::decodal_decode(&data).unwrap(); assert_eq!(decoded.get("api"), Some(&8080)); } + + #[test] + fn data_is_the_unknown_schema_and_round_trips_values() { + assert!(matches!( + Data::decodal_schema(), + Value::Range { ref constraints, .. } + if constraints == &[Constraint::Unknown] + )); + + let data = Data::Object(alloc::vec![DataField { + name: String::from("nested"), + value: Data::Array(alloc::vec![Data::Bool(true), Data::Int(2)]), + }]); + assert_eq!(Data::decodal_decode(&data).unwrap(), data); + assert!(matches!(data.into_value(), Value::Object { .. })); + } + + #[test] + fn rest_maps_decode_only_fields_outside_the_known_domain() { + let data = Data::Object(alloc::vec![ + DataField { + name: String::from("name"), + value: Data::String(String::from("api")), + }, + DataField { + name: String::from("priority"), + value: Data::Int(3), + }, + ]); + let decoded = BTreeMap::::decodal_decode_rest(&data, &["name"]).unwrap(); + assert_eq!(decoded.len(), 1); + assert_eq!(decoded.get("priority"), Some(&Data::Int(3))); + } + + #[cfg(feature = "std")] + #[test] + fn hash_maps_can_receive_rest_fields() { + let data = Data::Object(alloc::vec![DataField { + name: String::from("region"), + value: Data::String(String::from("ap-northeast-1")), + }]); + let decoded = + std::collections::HashMap::::decodal_decode_rest(&data, &[]).unwrap(); + assert_eq!( + decoded.get("region").map(String::as_str), + Some("ap-northeast-1") + ); + } } diff --git a/crates/decodal-core/src/embedding.rs b/crates/decodal-core/src/value.rs similarity index 56% rename from crates/decodal-core/src/embedding.rs rename to crates/decodal-core/src/value.rs index bb522a6..f08ff2a 100644 --- a/crates/decodal-core/src/embedding.rs +++ b/crates/decodal-core/src/value.rs @@ -3,37 +3,46 @@ use alloc::{boxed::Box, string::String, vec::Vec}; use crate::runtime::{Constraint, LiteralValue, PrimitiveType}; use crate::{CompareOp, Diagnostic, DiagnosticKind, Result, Span}; +/// A Decodal value supplied through the embedding API. +/// +/// Unlike [`crate::Data`], a `Value` may contain unresolved ranges and +/// defaults. The evaluator converts it into its lazy runtime representation +/// when it is bound as a global or returned from an import loader. #[derive(Debug, Clone, PartialEq)] -pub enum HostValue { +pub enum Value { String(String), Int(i64), Float(f64), Bool(bool), - Array(Vec), - ArrayConstraint { - item: Box, + Array(Vec), + ArrayRange { + item: Box, constraints: Vec, - default: Option>, + default: Option>, }, - MapConstraint { - value: Box, + MapRange { + value: Box, constraints: Vec, - default: Option>, + default: Option>, }, - Object(Vec), - Abstract { + Object { + fields: Vec, + rest: Option>, + }, + Range { constraints: Vec, - default: Option>, + default: Option>, }, } +/// A named field in a [`Value::Object`]. #[derive(Debug, Clone, PartialEq)] -pub struct HostField { +pub struct ValueField { pub name: String, - pub value: HostValue, + pub value: Value, } -impl HostValue { +impl Value { pub fn string(value: impl Into) -> Self { Self::String(value.into()) } @@ -52,65 +61,105 @@ impl HostValue { pub fn array(items: I) -> Self where - I: IntoIterator, + I: IntoIterator, { Self::Array(items.into_iter().collect()) } pub fn object(fields: I) -> Self where - I: IntoIterator, + I: IntoIterator, N: Into, { - Self::Object( - fields + Self::Object { + fields: fields .into_iter() - .map(|(name, value)| HostField { + .map(|(name, value)| ValueField { name: name.into(), value, }) .collect(), - ) + rest: None, + } } pub fn object_from_paths(fields: I) -> Self where - I: IntoIterator, + I: IntoIterator, N: Into, { let mut root = Vec::new(); for (path, value) in fields { insert_path(&mut root, &path.into(), value); } - Self::Object(root) + Self::Object { + fields: root, + rest: None, + } + } + + pub fn object_from_paths_with_rest(fields: I, rest: Value) -> Self + where + I: IntoIterator, + N: Into, + { + let mut root = Vec::new(); + for (path, value) in fields { + insert_path(&mut root, &path.into(), value); + } + Self::Object { + fields: root, + rest: Some(Box::new(rest)), + } + } + + pub fn object_with_rest(fields: I, rest: Value) -> Self + where + I: IntoIterator, + N: Into, + { + Self::Object { + fields: fields + .into_iter() + .map(|(name, value)| ValueField { + name: name.into(), + value, + }) + .collect(), + rest: Some(Box::new(rest)), + } + } + + pub fn unknown() -> Self { + Self::range_with_constraint(Constraint::Unknown) } pub fn string_type() -> Self { - Self::abstract_with_constraint(Constraint::Type(PrimitiveType::String)) + Self::range_with_constraint(Constraint::Type(PrimitiveType::String)) } pub fn int_type() -> Self { - Self::abstract_with_constraint(Constraint::Type(PrimitiveType::Int)) + Self::range_with_constraint(Constraint::Type(PrimitiveType::Int)) } pub fn float_type() -> Self { - Self::abstract_with_constraint(Constraint::Type(PrimitiveType::Float)) + Self::range_with_constraint(Constraint::Type(PrimitiveType::Float)) } pub fn bool_type() -> Self { - Self::abstract_with_constraint(Constraint::Type(PrimitiveType::Bool)) + Self::range_with_constraint(Constraint::Type(PrimitiveType::Bool)) } - pub fn array_of(item: HostValue) -> Self { - Self::ArrayConstraint { + pub fn array_of(item: Value) -> Self { + Self::ArrayRange { item: Box::new(item), constraints: Vec::new(), default: None, } } - pub fn map_of(value: HostValue) -> Self { - Self::MapConstraint { + pub fn map_of(value: Value) -> Self { + Self::MapRange { value: Box::new(value), constraints: Vec::new(), default: None, @@ -118,11 +167,11 @@ impl HostValue { } pub fn builtin_predicate(name: impl Into) -> Self { - Self::abstract_with_constraint(Constraint::BuiltinPredicate(name.into())) + Self::range_with_constraint(Constraint::BuiltinPredicate(name.into())) } - pub fn abstract_with_constraint(constraint: Constraint) -> Self { - Self::Abstract { + pub fn range_with_constraint(constraint: Constraint) -> Self { + Self::Range { constraints: alloc::vec![constraint], default: None, } @@ -130,12 +179,12 @@ impl HostValue { pub fn with_constraint(mut self, constraint: Constraint) -> Self { match &mut self { - Self::Abstract { constraints, .. } => constraints.push(constraint), - Self::ArrayConstraint { constraints, .. } | Self::MapConstraint { constraints, .. } => { + Self::Range { constraints, .. } => constraints.push(constraint), + Self::ArrayRange { constraints, .. } | Self::MapRange { constraints, .. } => { constraints.push(constraint) } _ => { - self = Self::Abstract { + self = Self::Range { constraints: alloc::vec![constraint], default: Some(Box::new(self)), }; @@ -166,53 +215,53 @@ impl HostValue { )) } - pub fn default(self, value: HostValue) -> Result { + pub fn default(self, value: Value) -> Result { match self { - Self::ArrayConstraint { + Self::ArrayRange { item, constraints, default: None, - } => Ok(Self::ArrayConstraint { + } => Ok(Self::ArrayRange { item, constraints, default: Some(Box::new(value)), }), - Self::ArrayConstraint { + Self::ArrayRange { default: Some(_), .. } => Err(Diagnostic::new( DiagnosticKind::DefaultConflict, Span::default(), - "host value already has a default", + "value already has a default", )), - Self::MapConstraint { + Self::MapRange { value: map_value, constraints, default: None, - } => Ok(Self::MapConstraint { + } => Ok(Self::MapRange { value: map_value, constraints, default: Some(Box::new(value)), }), - Self::MapConstraint { + Self::MapRange { default: Some(_), .. } => Err(Diagnostic::new( DiagnosticKind::DefaultConflict, Span::default(), - "host value already has a default", + "value already has a default", )), - Self::Abstract { + Self::Range { constraints, default: None, - } => Ok(Self::Abstract { + } => Ok(Self::Range { constraints, default: Some(Box::new(value)), }), - Self::Abstract { .. } => Err(Diagnostic::new( + Self::Range { .. } => Err(Diagnostic::new( DiagnosticKind::DefaultConflict, Span::default(), - "host value already has a default", + "value already has a default", )), - concrete => Ok(Self::Abstract { + concrete => Ok(Self::Range { constraints: Vec::new(), default: Some(Box::new(concrete)), }), @@ -236,8 +285,8 @@ impl HostValue { } } -impl HostField { - pub fn new(name: impl Into, value: HostValue) -> Self { +impl ValueField { + pub fn new(name: impl Into, value: Value) -> Self { Self { name: name.into(), value, @@ -245,28 +294,40 @@ impl HostField { } } -fn insert_path(fields: &mut Vec, path: &str, value: HostValue) { +fn insert_path(fields: &mut Vec, path: &str, value: Value) { let mut parts = path.splitn(2, '.'); let Some(head) = parts.next().filter(|part| !part.is_empty()) else { return; }; if let Some(tail) = parts.next() { if let Some(field) = fields.iter_mut().find(|field| field.name == head) { - if let HostValue::Object(children) = &mut field.value { + if let Value::Object { + fields: children, .. + } = &mut field.value + { insert_path(children, tail, value); } else { let mut children = Vec::new(); insert_path(&mut children, tail, value); - field.value = HostValue::Object(children); + field.value = Value::Object { + fields: children, + rest: None, + }; } } else { let mut children = Vec::new(); insert_path(&mut children, tail, value); - fields.push(HostField::new(head, HostValue::Object(children))); + fields.push(ValueField::new( + head, + Value::Object { + fields: children, + rest: None, + }, + )); } } else if let Some(field) = fields.iter_mut().find(|field| field.name == head) { field.value = value; } else { - fields.push(HostField::new(head, value)); + fields.push(ValueField::new(head, value)); } } diff --git a/crates/decodal-derive/src/lib.rs b/crates/decodal-derive/src/lib.rs index 6f1f5a5..585e4e1 100644 --- a/crates/decodal-derive/src/lib.rs +++ b/crates/decodal-derive/src/lib.rs @@ -35,12 +35,38 @@ fn expand_decodal(input: DeriveInput) -> Result { let mut schema_fields = Vec::new(); let mut decode_fields = Vec::new(); + let mut known_field_roots = Vec::new(); + let mut rest_field = None; for field in fields { let ident = field.ident.expect("named field"); let ty = field.ty; let attrs = FieldAttrs::from_attrs(&field.attrs, &ident.to_string())?; + + if attrs.rest { + if attrs.rename_explicit || attrs.default.is_some() || !attrs.constraints.is_empty() { + return Err(syn::Error::new( + ident.span(), + "`rest` cannot be combined with rename, default, or field constraints", + )); + } + if rest_field.is_some() { + return Err(syn::Error::new( + ident.span(), + "Decodal derive supports only one `rest` field", + )); + } + rest_field = Some((ident, ty)); + continue; + } + let path = attrs.rename.clone(); + known_field_roots.push( + path.split('.') + .next() + .expect("field paths are non-empty") + .to_owned(), + ); let schema_value = schema_expr(&ty, &attrs)?; let decode_value = decode_expr(&ty, &path, &attrs); @@ -52,14 +78,40 @@ fn expand_decodal(input: DeriveInput) -> Result { }); } + if let Some((ident, ty)) = &rest_field { + decode_fields.push(quote! { + #ident: <#ty as ::decodal::DecodalRest>::decodal_decode_rest( + data, + &[#(#known_field_roots),*], + )? + }); + } + + let schema_entries = if schema_fields.is_empty() { + quote! { ::core::iter::empty::<(&'static str, ::decodal::Value)>() } + } else { + quote! { [#(#schema_fields),*] } + }; + + let build_schema = if let Some((_, ty)) = &rest_field { + quote! { + ::decodal::Value::object_from_paths_with_rest( + #schema_entries, + <#ty as ::decodal::DecodalRest>::decodal_rest_schema(), + ) + } + } else { + quote! { + ::decodal::Value::object_from_paths(#schema_entries) + } + }; + let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl(); Ok(quote! { impl #impl_generics ::decodal::DecodalSchema for #name #ty_generics #where_clause { - fn decodal_schema() -> ::decodal::HostValue { - ::decodal::HostValue::object_from_paths([ - #(#schema_fields),* - ]) + fn decodal_schema() -> ::decodal::Value { + #build_schema } } @@ -76,6 +128,8 @@ fn expand_decodal(input: DeriveInput) -> Result { #[derive(Default)] struct FieldAttrs { rename: String, + rename_explicit: bool, + rest: bool, default: Option, constraints: Vec, } @@ -95,6 +149,14 @@ impl FieldAttrs { if meta.path.is_ident("rename") { let value: LitStr = meta.value()?.parse()?; output.rename = value.value(); + output.rename_explicit = true; + return Ok(()); + } + if meta.path.is_ident("rest") { + if meta.input.peek(syn::Token![=]) || meta.input.peek(syn::token::Paren) { + return Err(meta.error("`rest` does not accept a value")); + } + output.rest = true; return Ok(()); } if meta.path.is_ident("default") { @@ -182,7 +244,7 @@ fn schema_expr(ty: &Type, attrs: &FieldAttrs) -> Result { }; tokens.extend(quote! { schema = schema - .default(::decodal::IntoHostValue::into_host_value(#default_expr)) + .default(::decodal::IntoValue::into_value(#default_expr)) .expect("Decodal derive generated a valid default"); }); } @@ -210,3 +272,42 @@ fn decode_expr(ty: &Type, path: &str, attrs: &FieldAttrs) -> TokenStream2 { } } } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_multiple_rest_fields() { + let input: DeriveInput = syn::parse_quote! { + struct Invalid { + #[decodal(rest)] + first: std::collections::BTreeMap, + #[decodal(rest)] + second: std::collections::BTreeMap, + } + }; + assert!( + expand_decodal(input) + .unwrap_err() + .to_string() + .contains("only one `rest` field") + ); + } + + #[test] + fn rejects_rest_field_modifiers() { + let input: DeriveInput = syn::parse_quote! { + struct Invalid { + #[decodal(rest, default)] + extra: std::collections::BTreeMap, + } + }; + assert!( + expand_decodal(input) + .unwrap_err() + .to_string() + .contains("cannot be combined") + ); + } +} diff --git a/crates/decodal-derive/tests/derive.rs b/crates/decodal-derive/tests/derive.rs index 5a04611..02ae90c 100644 --- a/crates/decodal-derive/tests/derive.rs +++ b/crates/decodal-derive/tests/derive.rs @@ -1,4 +1,6 @@ -use decodal::{Data, DecodalDecode, DecodalSchema, EmptyLoader, Engine}; +use std::collections::BTreeMap; + +use decodal::{Constraint, Data, DecodalDecode, DecodalSchema, EmptyLoader, Engine, Value}; use decodal_derive::Decodal; #[derive(Debug, PartialEq, Decodal)] @@ -24,6 +26,28 @@ struct Fleet { workers: Vec, } +#[derive(Debug, PartialEq, Decodal)] +struct OpenConfig { + name: String, + #[decodal(default = true, rename = "feature.enabled")] + enabled: bool, + #[decodal(rest)] + extra: BTreeMap, +} + +#[derive(Debug, PartialEq, Decodal)] +struct StringLabels { + name: String, + #[decodal(rest)] + labels: BTreeMap, +} + +#[derive(Debug, PartialEq, Decodal)] +struct OpenBag { + #[decodal(rest)] + values: BTreeMap, +} + #[test] fn derives_schema_and_decode() { let mut engine = Engine::new(EmptyLoader); @@ -148,3 +172,97 @@ fn vec_schema_applies_nested_struct_defaults() { } ); } + +#[test] +fn rest_map_opens_the_derived_object_and_collects_additional_fields() { + let schema = OpenConfig::decodal_schema(); + let Value::Object { + fields, + rest: Some(rest), + } = schema + else { + panic!("derived schema should have an object rest range") + }; + assert_eq!(fields.len(), 2); + assert!(matches!( + *rest, + Value::Range { ref constraints, .. } + if constraints == &[Constraint::Unknown] + )); + + let mut engine = Engine::new(EmptyLoader); + engine + .bind_global("OpenConfig", OpenConfig::decodal_schema()) + .unwrap(); + let module = engine + .add_root_source( + "test", + "test", + r#" + { + name = "api"; + plugin = { name = "cache"; }; + retries = 3; + } as OpenConfig + "#, + ) + .unwrap(); + let value = engine.eval_module(module).unwrap(); + let data = engine.materialize(&value).unwrap(); + let config = OpenConfig::decodal_decode(&data).unwrap(); + + assert_eq!(config.name, "api"); + assert!(config.enabled); + assert_eq!(config.extra.get("retries"), Some(&Data::Int(3))); + assert!(matches!(config.extra.get("plugin"), Some(Data::Object(_)))); + assert!(!config.extra.contains_key("name")); + assert!(!config.extra.contains_key("feature")); +} + +#[test] +fn typed_rest_map_constrains_each_additional_field() { + let mut engine = Engine::new(EmptyLoader); + engine + .bind_global("StringLabels", StringLabels::decodal_schema()) + .unwrap(); + let module = engine + .add_root_source( + "test", + "test", + r#"{ name = "service"; region = "ap-northeast-1"; tier = "edge"; } as StringLabels"#, + ) + .unwrap(); + let value = engine.eval_module(module).unwrap(); + let data = engine.materialize(&value).unwrap(); + let labels = StringLabels::decodal_decode(&data).unwrap(); + assert_eq!(labels.labels.get("region"), Some(&"ap-northeast-1".into())); + assert_eq!(labels.labels.get("tier"), Some(&"edge".into())); + + let module = engine + .add_root_source( + "invalid", + "invalid", + r#"{ name = "service"; priority = 1; } as StringLabels"#, + ) + .unwrap(); + assert!(engine.eval_module(module).is_err()); +} + +#[test] +fn rest_only_struct_collects_every_field() { + let schema = OpenBag::decodal_schema(); + assert!(matches!( + schema, + Value::Object { + ref fields, + rest: Some(_), + } if fields.is_empty() + )); + + let data = Data::Object(vec![decodal::runtime::DataField { + name: "answer".into(), + value: Data::Int(42), + }]); + let bag = OpenBag::decodal_decode(&data).unwrap(); + assert_eq!(bag.values.get("answer"), Some(&Data::Int(42))); +} diff --git a/crates/decodal-language-service/src/completion.rs b/crates/decodal-language-service/src/completion.rs index 9c27e8c..4c8f40c 100644 --- a/crates/decodal-language-service/src/completion.rs +++ b/crates/decodal-language-service/src/completion.rs @@ -1,7 +1,7 @@ use std::collections::{BTreeMap, HashMap}; use decodal::{ - Engine, HostEnvironment, HostValue, ImportLoader, LoadedImport, Result, RuntimeValue, + Engine, HostEnvironment, ImportLoader, LoadedImport, Result, Value, runtime::RuntimeValue, }; #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -116,12 +116,12 @@ pub(crate) fn complete( let mut loader = environment.create_loader(); let loaded = loader.load(Some(key), specifier)?; detail = match &loaded { - LoadedImport::Source(source) => source.name.clone(), - LoadedImport::Value(value) => value.key.clone(), + LoadedImport::Source { name, .. } => name.clone(), + LoadedImport::Value { key, .. } => key.clone(), }; fields = match loaded { - LoadedImport::Source(source) => collect_fields(&tokenize(&source.source)), - LoadedImport::Value(value) => fields_from_host_value(&value.value), + LoadedImport::Source { source, .. } => collect_fields(&tokenize(&source)), + LoadedImport::Value { value, .. } => fields_from_value(&value), }; } else if let Some(local) = local_fields.get(root) { fields = local.clone(); @@ -229,6 +229,7 @@ fn builtin_items() -> Vec { ("Int", CompletionKind::Type, "integer constraint", 5), ("Float", CompletionKind::Type, "float constraint", 5), ("Bool", CompletionKind::Type, "boolean constraint", 5), + ("Unknown", CompletionKind::Type, "unknown top range", 5), ] .into_iter() .map(|(label, kind, detail, priority)| CompletionItem { @@ -267,24 +268,24 @@ fn fields_from_runtime( Ok(tree) } -fn fields_from_host_value(value: &HostValue) -> FieldTree { +fn fields_from_value(value: &Value) -> FieldTree { match value { - HostValue::Object(fields) => fields + Value::Object { fields, .. } => fields .iter() - .map(|field| (field.name.clone(), fields_from_host_value(&field.value))) + .map(|field| (field.name.clone(), fields_from_value(&field.value))) .collect(), - HostValue::ArrayConstraint { + Value::ArrayRange { default: Some(value), .. } - | HostValue::MapConstraint { + | Value::MapRange { default: Some(value), .. } - | HostValue::Abstract { + | Value::Range { default: Some(value), .. - } => fields_from_host_value(value), + } => fields_from_value(value), _ => FieldTree::new(), } } @@ -688,7 +689,7 @@ mod tests { use std::collections::BTreeMap; use decodal::{ - Diagnostic, DiagnosticKind, EmptyLoader, HostValue, ImportCandidate, LoadedImport, Span, + Diagnostic, DiagnosticKind, EmptyLoader, ImportCandidate, LoadedImport, Span, Value, }; use super::*; @@ -708,15 +709,15 @@ mod tests { if specifier == "./post.md" { return Ok(LoadedImport::value( "post.md", - HostValue::object([ + Value::object([ ( "frontmatter", - HostValue::object([ - ("title", HostValue::string("Hello")), - ("draft", HostValue::bool(false)), + Value::object([ + ("title", Value::string("Hello")), + ("draft", Value::bool(false)), ]), ), - ("body", HostValue::string("# Hello")), + ("body", Value::string("# Hello")), ]), )); } @@ -758,12 +759,9 @@ mod tests { fn configure_engine(&self, engine: &mut Engine) -> Result<()> { engine.bind_global( "App", - HostValue::object([( + Value::object([( "config", - HostValue::object([ - ("enabled", HostValue::bool_type()), - ("port", HostValue::int_type()), - ]), + Value::object([("enabled", Value::bool_type()), ("port", Value::int_type())]), )]), )?; Ok(()) @@ -854,6 +852,7 @@ mod tests { .unwrap(); let labels = labels(result); assert!(labels.contains(&"String".into())); + assert!(labels.contains(&"Unknown".into())); assert!(labels.contains(&"service".into())); assert!(labels.contains(&"value".into())); assert!(labels.contains(&"App".into())); @@ -881,6 +880,10 @@ mod tests { .unwrap() .unwrap(); assert!(labels(result).contains(&"String".into())); + let result = complete(&EmptyEnvironment, "main.dcdl", "Unk", 3, false) + .unwrap() + .unwrap(); + assert!(labels(result).contains(&"Unknown".into())); } struct EmptyEnvironment; diff --git a/crates/decodal-language-service/src/lib.rs b/crates/decodal-language-service/src/lib.rs index 7f21daf..b451321 100644 --- a/crates/decodal-language-service/src/lib.rs +++ b/crates/decodal-language-service/src/lib.rs @@ -92,7 +92,7 @@ impl SemanticAnalysis { #[cfg(test)] mod tests { use decodal::{ - Data, Diagnostic, DiagnosticKind, Engine, HostValue, ImportLoader, LoadedImport, Span, + Data, Diagnostic, DiagnosticKind, Engine, ImportLoader, LoadedImport, Span, Value, }; use super::*; @@ -100,11 +100,11 @@ mod tests { const ROOT: &str = r#"Post & import "./post.md""#; struct ContentEnvironment { - draft: HostValue, + draft: Value, } struct ContentLoader { - draft: HostValue, + draft: Value, } impl ImportLoader for ContentLoader { @@ -122,15 +122,15 @@ mod tests { } Ok(LoadedImport::value( "content/post.md", - HostValue::object([ + Value::object([ ( "frontmatter", - HostValue::object([ - ("title", HostValue::string("Hello")), + Value::object([ + ("title", Value::string("Hello")), ("draft", self.draft.clone()), ]), ), - ("body", HostValue::string("# Hello")), + ("body", Value::string("# Hello")), ]), )) } @@ -148,15 +148,15 @@ mod tests { fn configure_engine(&self, engine: &mut Engine) -> decodal::Result<()> { engine.bind_global( "Post", - HostValue::object([ + Value::object([ ( "frontmatter", - HostValue::object([ - ("title", HostValue::string_type()), - ("draft", HostValue::bool_type()), + Value::object([ + ("title", Value::string_type()), + ("draft", Value::bool_type()), ]), ), - ("body", HostValue::string_type()), + ("body", Value::string_type()), ]), )?; Ok(()) @@ -173,7 +173,7 @@ mod tests { #[test] fn injected_environment_matches_direct_evaluation() { let environment = ContentEnvironment { - draft: HostValue::bool(false), + draft: Value::bool(false), }; let direct = evaluate_direct(&environment).unwrap(); let service = LanguageService::new(&environment); @@ -186,7 +186,7 @@ mod tests { #[test] fn injected_environment_preserves_import_diagnostics() { let service = LanguageService::new(ContentEnvironment { - draft: HostValue::string("maybe"), + draft: Value::string("maybe"), }); let analysis = service.analyze("main.dcdl", "main.dcdl", ROOT); diff --git a/crates/decodal-language-tools/src/lib.rs b/crates/decodal-language-tools/src/lib.rs index 59dc44e..74a12c1 100644 --- a/crates/decodal-language-tools/src/lib.rs +++ b/crates/decodal-language-tools/src/lib.rs @@ -1,8 +1,8 @@ use std::{error::Error, fmt}; use decodal::{ - Ast, BinaryOp, CompareOp, Expr, ExprId, Field, Param, SourceForm, Span, SyntaxToken, - SyntaxTokenKind, + Ast, BinaryOp, CompareOp, Expr, ExprId, Field, ObjectRest, Param, SourceForm, Span, + SyntaxToken, SyntaxTokenKind, ast::{MatchArm, UnaryOp}, parse_source, tokenize_source, }; @@ -81,7 +81,7 @@ impl<'a> Formatter<'a> { fn format(&self, root: ExprId, source_form: SourceForm) -> String { let mut out = String::new(); if source_form == SourceForm::Fields { - let Expr::Object(fields) = &self.ast.get(root).expr else { + let Expr::Object { fields, .. } = &self.ast.get(root).expr else { unreachable!("field-form sources parse to an object") }; self.write_field_list(&mut out, fields, 0, self.source.len(), 0); @@ -145,7 +145,7 @@ impl<'a> Formatter<'a> { if self.has_comment(node.span) && !matches!( node.expr, - Expr::Object(_) | Expr::Array(_) | Expr::Let { .. } | Expr::Match { .. } + Expr::Object { .. } | Expr::Array(_) | Expr::Let { .. } | Expr::Match { .. } ) { out.push_str(self.raw(node.span)); @@ -162,7 +162,9 @@ impl<'a> Formatter<'a> { Expr::Literal(_) | Expr::Ident(_) | Expr::RegexConstraint(_) | Expr::Wildcard => { out.push_str(self.raw(node.span)); } - Expr::Object(fields) => self.write_object(out, node.span, fields, indent), + Expr::Object { fields, rest } => { + self.write_object(out, node.span, fields, rest.as_ref(), indent) + } Expr::Array(items) => self.write_array(out, node.span, items, indent), Expr::ArrayConstraint { item } => { out.push_str("[..."); @@ -241,15 +243,50 @@ impl<'a> Formatter<'a> { } } - fn write_object(&self, out: &mut String, span: Span, fields: &[Field], indent: usize) { + fn write_object( + &self, + out: &mut String, + span: Span, + fields: &[Field], + rest: Option<&ObjectRest>, + indent: usize, + ) { let (start, end) = self.delimited_range(span, SyntaxTokenKind::LBrace, SyntaxTokenKind::RBrace); - if fields.is_empty() && !self.has_comment_between(start, end) { + if fields.is_empty() && rest.is_none() && !self.has_comment_between(start, end) { out.push_str("{}"); return; } out.push_str("{\n"); - self.write_field_list(out, fields, start, end, indent + INDENT); + let field_end = rest.map_or(end, |rest| rest.span.start as usize); + self.write_field_list(out, fields, start, field_end, indent + INDENT); + if let Some(rest) = rest { + write_indent(out, indent + INDENT); + out.push_str("..."); + let value_start = self.ast.span(rest.value).start as usize; + let ellipsis = self + .tokens_between(rest.span.start as usize, value_start) + .find(|token| token.kind == SyntaxTokenKind::Ellipsis) + .expect("parsed object rest constraints contain `...`"); + if self.has_comment_between(ellipsis.span.end as usize, value_start) { + self.write_between( + out, + ellipsis.span.end as usize, + value_start, + Some(ellipsis.span.end as usize), + indent + INDENT, + ); + write_indent(out, indent + INDENT); + } + self.write_expr(out, rest.value, indent + INDENT, 0); + self.write_between( + out, + rest.span.end as usize, + end, + Some(rest.span.end as usize), + indent + INDENT, + ); + } write_indent(out, indent); out.push('}'); } @@ -524,7 +561,7 @@ impl<'a> Formatter<'a> { Expr::As { narrower, wider } => { self.is_inline_expr(*narrower) && self.is_inline_expr(*wider) } - Expr::Object(_) | Expr::Let { .. } | Expr::Function { .. } | Expr::Match { .. } => { + Expr::Object { .. } | Expr::Let { .. } | Expr::Function { .. } | Expr::Match { .. } => { false } } @@ -707,6 +744,17 @@ mod tests { ); } + #[test] + fn formats_unknown_and_object_rest_constraints() { + let source = + "value={hoge=Int;fuga=String;# remaining fields\n...# unconstrained\nUnknown};"; + let formatted = format_source(source).unwrap(); + assert_eq!( + formatted, + "value = {\n hoge = Int;\n fuga = String; # remaining fields\n ... # unconstrained\n Unknown\n};\n" + ); + } + #[test] fn preserves_regex_and_escaped_strings() { let source = r#"value={pattern=/^api\/.+$/;text="a\n\"b";};"#; diff --git a/crates/decodal-lsp/src/lib.rs b/crates/decodal-lsp/src/lib.rs index c7405a8..6424bbe 100644 --- a/crates/decodal-lsp/src/lib.rs +++ b/crates/decodal-lsp/src/lib.rs @@ -7,7 +7,7 @@ use std::{ use decodal::{ Diagnostic as DecodalDiagnostic, DiagnosticKind, HostEnvironment, ImportCandidate, - ImportLoader, LoadedImport, LoadedSource, SourceId, Span, + ImportLoader, LoadedImport, SourceId, Span, }; use decodal_language_service::{ CompletionKind as ServiceCompletionKind, CompletionResult, LanguageService, SemanticAnalysis, @@ -667,11 +667,11 @@ impl ImportLoader for FileSystemLoader { ) })? }; - Ok(LoadedImport::Source(LoadedSource { + Ok(LoadedImport::Source { key: key.clone(), name: key, source, - })) + }) } fn complete_import( @@ -743,7 +743,7 @@ mod tests { time::Duration, }; - use decodal::{Engine, HostValue}; + use decodal::{Engine, Value}; use lsp_server::RequestId; use serde_json::json; @@ -772,12 +772,12 @@ mod tests { .is_some_and(|source| source == "draft: false"); Ok(LoadedImport::value( "content/post.md", - HostValue::object([( + Value::object([( "draft", if draft { - HostValue::bool(false) + Value::bool(false) } else { - HostValue::string("maybe") + Value::string("maybe") }, )]), )) @@ -794,10 +794,7 @@ mod tests { } fn configure_engine(&self, engine: &mut Engine) -> decodal::Result<()> { - engine.bind_global( - "Post", - HostValue::object([("draft", HostValue::bool_type())]), - )?; + engine.bind_global("Post", Value::object([("draft", Value::bool_type())]))?; Ok(()) } } diff --git a/crates/decodal-wasm/src/lib.rs b/crates/decodal-wasm/src/lib.rs index 494f805..45881f0 100644 --- a/crates/decodal-wasm/src/lib.rs +++ b/crates/decodal-wasm/src/lib.rs @@ -6,7 +6,7 @@ use decodal_language_service::{CompletionKind, LanguageService}; use wasm_bindgen::prelude::*; #[cfg(any(target_arch = "wasm32", test))] -mod host_value; +mod value; #[cfg(target_arch = "wasm32")] mod web_environment; diff --git a/crates/decodal-wasm/src/host_value.rs b/crates/decodal-wasm/src/value.rs similarity index 55% rename from crates/decodal-wasm/src/host_value.rs rename to crates/decodal-wasm/src/value.rs index f9b90a2..68873c3 100644 --- a/crates/decodal-wasm/src/host_value.rs +++ b/crates/decodal-wasm/src/value.rs @@ -1,41 +1,41 @@ -use decodal::{CompareOp, Constraint, HostValue, LiteralValue, PrimitiveType}; -use serde_json::{Map, Value}; +use decodal::{CompareOp, Constraint, LiteralValue, PrimitiveType, Value}; +use serde_json::{Map, Value as JsonValue}; -pub(crate) fn from_json(value: &Value) -> Result { +pub(crate) fn from_json(value: &JsonValue) -> Result { match value { - Value::Null => Err(String::from("null is not a Decodal host value")), - Value::Bool(value) => Ok(HostValue::bool(*value)), - Value::Number(value) => number(value), - Value::String(value) => Ok(HostValue::string(value)), - Value::Array(items) => items + JsonValue::Null => Err(String::from("null is not a Decodal value")), + JsonValue::Bool(value) => Ok(Value::bool(*value)), + JsonValue::Number(value) => number(value), + JsonValue::String(value) => Ok(Value::string(value)), + JsonValue::Array(items) => items .iter() .enumerate() .map(|(index, value)| { from_json(value).map_err(|error| format!("array item {index}: {error}")) }) .collect::, _>>() - .map(HostValue::array), - Value::Object(fields) => object(fields), + .map(Value::array), + JsonValue::Object(fields) => object(fields), } } -fn number(value: &serde_json::Number) -> Result { +fn number(value: &serde_json::Number) -> Result { if let Some(value) = value.as_i64() { - return Ok(HostValue::int(value)); + return Ok(Value::int(value)); } if let Some(value) = value.as_u64() { return i64::try_from(value) - .map(HostValue::int) - .map_err(|_| String::from("integer host value is outside the signed 64-bit range")); + .map(Value::int) + .map_err(|_| String::from("integer value is outside the signed 64-bit range")); } value .as_f64() .filter(|value| value.is_finite()) - .map(HostValue::float) - .ok_or_else(|| String::from("invalid numeric host value")) + .map(Value::float) + .ok_or_else(|| String::from("invalid numeric value")) } -fn object(fields: &Map) -> Result { +fn object(fields: &Map) -> Result { let Some(descriptor) = fields.get("$decodal") else { return fields .iter() @@ -45,7 +45,7 @@ fn object(fields: &Map) -> Result { .map_err(|error| format!("field `{name}`: {error}")) }) .collect::, _>>() - .map(HostValue::object); + .map(Value::object); }; let descriptor = descriptor @@ -59,6 +59,14 @@ fn object(fields: &Map) -> Result { .map(Box::new); match descriptor { + "Unknown" => { + let mut all_constraints = vec![Constraint::Unknown]; + all_constraints.extend(constraints); + Ok(Value::Range { + constraints: all_constraints, + default, + }) + } "String" | "Int" | "Float" | "Bool" => { let primitive = match descriptor { "String" => PrimitiveType::String, @@ -69,7 +77,7 @@ fn object(fields: &Map) -> Result { }; let mut all_constraints = vec![Constraint::Type(primitive)]; all_constraints.extend(constraints); - Ok(HostValue::Abstract { + Ok(Value::Range { constraints: all_constraints, default, }) @@ -78,7 +86,7 @@ fn object(fields: &Map) -> Result { let item = fields .get("item") .ok_or_else(|| String::from("Array descriptor requires `item`"))?; - Ok(HostValue::ArrayConstraint { + Ok(Value::ArrayRange { item: Box::new(from_json(item)?), constraints, default, @@ -88,21 +96,49 @@ fn object(fields: &Map) -> Result { let value = fields .get("value") .ok_or_else(|| String::from("Map descriptor requires `value`"))?; - Ok(HostValue::MapConstraint { + Ok(Value::MapRange { value: Box::new(from_json(value)?), constraints, default, }) } - "Abstract" => Ok(HostValue::Abstract { + "Object" => { + if !constraints.is_empty() { + return Err(String::from( + "Object descriptor does not accept `constraints`; constrain its fields or rest range", + )); + } + if default.is_some() { + return Err(String::from( + "Object descriptor does not accept `default`; place defaults on its fields", + )); + } + let object_fields = fields + .get("fields") + .and_then(JsonValue::as_object) + .ok_or_else(|| String::from("Object descriptor requires object `fields`"))?; + let value_fields = object_fields + .iter() + .map(|(name, value)| { + from_json(value) + .map(|value| (name.clone(), value)) + .map_err(|error| format!("field `{name}`: {error}")) + }) + .collect::, _>>()?; + let rest = fields + .get("rest") + .ok_or_else(|| String::from("Object descriptor requires `rest`"))?; + Ok(Value::object_with_rest(value_fields, from_json(rest)?)) + } + "Range" => Ok(Value::Range { constraints, default, }), - name => Err(format!("unknown Decodal host descriptor `{name}`")), + name => Err(format!("unknown Decodal value descriptor `{name}`")), } } -fn parse_constraints(value: Option<&Value>) -> Result, String> { +fn parse_constraints(value: Option<&JsonValue>) -> Result, String> { let Some(value) = value else { return Ok(Vec::new()); }; @@ -118,12 +154,13 @@ fn parse_constraints(value: Option<&Value>) -> Result, String> { .collect() } -fn parse_constraint(value: &Value) -> Result { +fn parse_constraint(value: &JsonValue) -> Result { let fields = value .as_object() .ok_or_else(|| String::from("constraint must be an object"))?; let kind = required_string(fields, "kind")?; match kind { + "unknown" => Ok(Constraint::Unknown), "type" => match required_string(fields, "value")? { "String" => Ok(Constraint::Type(PrimitiveType::String)), "Int" => Ok(Constraint::Type(PrimitiveType::Int)), @@ -154,29 +191,29 @@ fn parse_constraint(value: &Value) -> Result { } } -fn literal(value: &Value) -> Result { +fn literal(value: &JsonValue) -> Result { match value { - Value::String(value) => Ok(LiteralValue::String(value.clone())), - Value::Bool(value) => Ok(LiteralValue::Bool(*value)), - Value::Number(value) => match number(value)? { - HostValue::Int(value) => Ok(LiteralValue::Int(value)), - HostValue::Float(value) => Ok(LiteralValue::Float(value)), + JsonValue::String(value) => Ok(LiteralValue::String(value.clone())), + JsonValue::Bool(value) => Ok(LiteralValue::Bool(*value)), + JsonValue::Number(value) => match number(value)? { + Value::Int(value) => Ok(LiteralValue::Int(value)), + Value::Float(value) => Ok(LiteralValue::Float(value)), _ => unreachable!(), }, _ => Err(String::from("comparison value must be a primitive literal")), } } -fn required_string<'a>(fields: &'a Map, name: &str) -> Result<&'a str, String> { +fn required_string<'a>(fields: &'a Map, name: &str) -> Result<&'a str, String> { fields .get(name) - .and_then(Value::as_str) + .and_then(JsonValue::as_str) .ok_or_else(|| format!("constraint requires string `{name}`")) } #[cfg(test)] mod tests { - use decodal::{Constraint, HostValue, LiteralValue, PrimitiveType}; + use decodal::{Constraint, LiteralValue, PrimitiveType, Value}; use super::from_json; @@ -188,11 +225,11 @@ mod tests { }); assert_eq!( from_json(&value).unwrap(), - HostValue::object([ - ("body", HostValue::string("# Hello")), + Value::object([ + ("body", Value::string("# Hello")), ( "frontmatter", - HostValue::object([("draft", HostValue::bool(false))]), + Value::object([("draft", Value::bool(false))]), ), ]) ); @@ -210,8 +247,8 @@ mod tests { }); assert_eq!( from_json(&value).unwrap(), - HostValue::ArrayConstraint { - item: Box::new(HostValue::Abstract { + Value::ArrayRange { + item: Box::new(Value::Range { constraints: vec![ Constraint::Type(PrimitiveType::Int), Constraint::Compare(decodal::CompareOp::Gt, LiteralValue::Int(0)), @@ -219,10 +256,7 @@ mod tests { default: None, }), constraints: Vec::new(), - default: Some(Box::new(HostValue::array([ - HostValue::int(1), - HostValue::int(2), - ]))), + default: Some(Box::new(Value::array([Value::int(1), Value::int(2),]))), } ); } @@ -236,10 +270,41 @@ mod tests { }); assert_eq!( from_json(&value).unwrap(), - HostValue::MapConstraint { - value: Box::new(HostValue::bool_type()), + Value::MapRange { + value: Box::new(Value::bool_type()), constraints: Vec::new(), - default: Some(Box::new(HostValue::object([] as [(&str, HostValue); 0]))), + default: Some(Box::new(Value::object([] as [(&str, Value); 0]))), + } + ); + } + + #[test] + fn converts_unknown_and_open_object_descriptors() { + let value = serde_json::json!({ + "$decodal": "Object", + "fields": { + "name": { "$decodal": "String" }, + }, + "rest": { "$decodal": "Unknown" }, + }); + assert_eq!( + from_json(&value).unwrap(), + Value::object_with_rest([("name", Value::string_type())], Value::unknown(),) + ); + } + + #[test] + fn converts_general_range_descriptors() { + let value = serde_json::json!({ + "$decodal": "Range", + "constraints": [{ "kind": "predicate", "value": "available" }], + "default": true, + }); + assert_eq!( + from_json(&value).unwrap(), + Value::Range { + constraints: vec![Constraint::BuiltinPredicate("available".into())], + default: Some(Box::new(Value::bool(true))), } ); } diff --git a/crates/decodal-wasm/src/web_environment.rs b/crates/decodal-wasm/src/web_environment.rs index 25799c3..11889eb 100644 --- a/crates/decodal-wasm/src/web_environment.rs +++ b/crates/decodal-wasm/src/web_environment.rs @@ -1,17 +1,17 @@ use std::collections::BTreeMap; use decodal::{ - Diagnostic, DiagnosticKind, Engine, HostEnvironment, HostValue, ImportCandidate, ImportLoader, - LoadedImport, Span, + Diagnostic, DiagnosticKind, Engine, HostEnvironment, ImportCandidate, ImportLoader, + LoadedImport, Span, Value as DecodalValue, }; use js_sys::{Function, Reflect}; use serde_json::Value; use wasm_bindgen::{JsCast, JsValue}; -use crate::host_value; +use crate::value; pub(crate) struct JsEnvironment { - globals: BTreeMap, + globals: BTreeMap, load_import: Option, complete_import: Option, } @@ -37,7 +37,7 @@ impl JsEnvironment { globals .iter() .map(|(name, value)| { - host_value::from_json(value) + value::from_json(value) .map(|value| (name.clone(), value)) .map_err(|error| { JsValue::from_str(&format!("invalid global `{name}`: {error}")) @@ -133,7 +133,7 @@ fn loaded_import(value: &Value) -> Result { let value = fields .get("value") .ok_or_else(|| String::from("value import requires `value`"))?; - let value = host_value::from_json(value) + let value = value::from_json(value) .map_err(|error| format!("invalid imported value: {error}"))?; Ok(LoadedImport::value(key, value)) } diff --git a/doc/manual/souce/design/diagnostics-and-fallback.md b/doc/manual/souce/design/diagnostics-and-fallback.md index 5cb0f45..fcd8357 100644 --- a/doc/manual/souce/design/diagnostics-and-fallback.md +++ b/doc/manual/souce/design/diagnostics-and-fallback.md @@ -75,5 +75,5 @@ fallback は有限で明示的な仕組みに限定する。 - `default`: 未指定値の fallback。 - `match`: 有限 pattern に基づく分岐。 -Decodal は `unknown` / `any` を持たないため、field 不在や未解決 identifier を fallback 可能な通常値として扱わない。 -それらは diagnostic として報告する。 +`Unknown` は明示的に書く最上位のabstract rangeであり、評価エラーを包む値ではない。 +field 不在や未解決 identifier は `Unknown` へ変換せず、diagnostic として報告する。 diff --git a/doc/manual/souce/design/embedding-api.md b/doc/manual/souce/design/embedding-api.md index f5abcc4..47a4f6f 100644 --- a/doc/manual/souce/design/embedding-api.md +++ b/doc/manual/souce/design/embedding-api.md @@ -17,23 +17,23 @@ let / function env ``` Module top-level bindings shadow prelude bindings. -Primitive type names such as `String`, `Int`, `Float`, and `Bool` are handled before environment lookup, so they are reserved and cannot be shadowed by host bindings. +Primitive type names such as `String`, `Int`, `Float`, and `Bool`, plus the top range `Unknown`, are handled before environment lookup, so they are reserved and cannot be shadowed by host bindings. ## Global bindings The host can bind values before adding or evaluating user sources. ```rust -use decodal::{EmptyLoader, Engine, HostValue}; +use decodal::{EmptyLoader, Engine, Value}; let mut engine = Engine::new(EmptyLoader); engine.bind_global( "Service", - HostValue::object([ - ("name", HostValue::string_type()), - ("port", HostValue::int_type().gt(443).default_int(8443)?), - ("enabled", HostValue::bool_type().default_bool(true)?), + Value::object([ + ("name", Value::string_type()), + ("port", Value::int_type().gt(443).default_int(8443)?), + ("enabled", Value::bool_type().default_bool(true)?), ]), )?; ``` @@ -47,40 +47,49 @@ A user source can then refer to `Service` without importing it. } as Service ``` -## HostValue +## Value -`HostValue` is the public builder-facing value representation for embedding. +`Value` is the public builder-facing value representation for embedding. It keeps host code from constructing internal `ThunkId` or `ObjectValue` values directly. ```text -HostValue = +Value = String Int Float Bool - Array(Vec) - ArrayConstraint { item, constraints, default } - MapConstraint { value, constraints, default } - Object(Vec) - Abstract { constraints, default } + Array(Vec) + ArrayRange { item, constraints, default } + MapRange { value, constraints, default } + Object { fields, rest: Option } + Range { constraints, default } ``` -When a host value is bound, the engine internalizes it into `RuntimeValue` and allocates value thunks for object fields, array items, and defaults. +When a value is bound by the host, the engine internalizes it into `RuntimeValue` and allocates value thunks for object fields, array items, and defaults. -`HostValue::array_of(item)` builds an array constraint with a required element schema. -There is no host API for an unconstrained abstract array. +`Value::array_of(item)` builds an array constraint with a required element schema. +There is no `Value` constructor for an unconstrained abstract array. -`HostValue::map_of(value)` builds a map constraint whose arbitrary object field values must satisfy `value`. -`BTreeMap` and, with `std`, `HashMap` implement `DecodalSchema`, `DecodalDecode`, and `IntoHostValue` using this representation. +`Value::map_of(value)` builds a map constraint whose arbitrary object field values must satisfy `value`. +`BTreeMap` and, with `std`, `HashMap` implement `DecodalSchema`, `DecodalDecode`, and `IntoValue` using this representation. -## Abstract host objects - -A host-provided schema object is represented as a concrete object structure whose fields may contain abstract values. +`Value::unknown()` builds the top abstract range. `Value::object_with_rest(fields, rest)` builds an object with named fields and a range for all remaining fields. ```rust -HostValue::object([ - ("name", HostValue::string_type()), - ("port", HostValue::int_type().gt(443).default_int(8443)?), +Value::object_with_rest( + [("enabled", Value::bool_type().default_bool(true)?)], + Value::unknown(), +) +``` + +## Objects containing ranges + +A host-provided schema object is represented as a concrete object structure whose fields may contain ranges. + +```rust +Value::object([ + ("name", Value::string_type()), + ("port", Value::int_type().gt(443).default_int(8443)?), ]) ``` @@ -100,9 +109,28 @@ This matches the runtime model used for Decodal source-defined schema objects. Hosts can enable the `derive` feature on `decodal` to keep a Rust struct, the Decodal schema, and the decoded result in sync. The derive implements two traits from the `decodal` crate: -- `DecodalSchema`: builds a `HostValue` schema that can be passed to `Engine::bind_global`. +- `DecodalSchema`: builds a `Value` schema that can be passed to `Engine::bind_global`. - `DecodalDecode`: decodes materialized `Data` back into the Rust type. +An explicitly marked map field can receive the open portion of an object. + +```rust +use std::collections::BTreeMap; +use decodal::{Data, Decodal}; + +#[derive(Decodal)] +struct OpenConfig { + enabled: bool, + + #[decodal(rest)] + extra: BTreeMap, +} +``` + +The schema generated for `extra` is `...Unknown`. A typed receiver such as `BTreeMap` generates `...String` instead. During decode, named top-level fields are excluded and all remaining fields are collected into the map. + +Only one `#[decodal(rest)]` field is allowed. It must implement `DecodalRest`; the core provides implementations for `BTreeMap` and, with `std`, `HashMap`. `rename`, `default`, and field constraints cannot be combined with `rest`. Without a rest receiver, a derived struct remains a closed object range. + ```rust use decodal::{Decodal, DecodalDecode, DecodalSchema, EmptyLoader, Engine}; @@ -202,20 +230,21 @@ run_stdio(|initialize| { `LspEnvironment` adds document lifecycle hooks on top of `HostEnvironment`. A `run_stdio` environment factory always receives the client's `InitializeParams`; the host decides whether to use its workspace folders, initialization options, and capabilities or ignore them. A host that keeps unsaved buffers in shared state can update them from `open_document`, `change_document`, and `close_document`; every subsequent diagnostic pass creates the normal import loader from that updated environment. -Synchronized non-Decodal documents are passed through these hooks but are not evaluated as Decodal roots, so a loader can parse an unsaved Markdown file into `HostValue` and immediately revalidate the open Decodal documents that import it. +Synchronized non-Decodal documents are passed through these hooks but are not evaluated as Decodal roots, so a loader can parse an unsaved Markdown file into `Value` and immediately revalidate the open Decodal documents that import it. ## Structured imports `ImportLoader::load` returns either `LoadedImport::Source` or `LoadedImport::Value`. -The value variant carries a `HostValue`, allowing a host to parse non-Decodal resources such as Markdown into an application-specific structure. +The value variant carries a `Value`, allowing a host to parse non-Decodal resources such as Markdown into an application-specific structure. ```text import "./post.md" -> host parses content - -> LoadedImport::Value( - { frontmatter: {...}, body: "..." } - ) - -> Engine internalizes HostValue + -> LoadedImport::Value { + key: "content/post.md", + value: { frontmatter: {...}, body: "..." } + } + -> Engine internalizes Value -> normal composition and materialization ``` @@ -223,7 +252,7 @@ The core does not select content types or bundle Markdown/frontmatter parsers. The loader owns path resolution, media or extension dispatch, parsing rules, and parse diagnostics. The stable loader key is also used to cache structured imports. -When a structured value fails a Decodal constraint, the diagnostic keeps the Decodal constraint span and identifies the host value by its stable import key and logical value path, such as `content/post.md` and `frontmatter.draft`. -`HostValue` does not need source spans: syntax diagnostics for the external format remain the loader's responsibility, while cross-value validation reports semantic provenance. +When a structured value fails a Decodal constraint, the diagnostic keeps the Decodal constraint span and identifies the imported value by its stable key and logical value path, such as `content/post.md` and `frontmatter.draft`. +`Value` does not need source spans: syntax diagnostics for the external format remain the loader's responsibility, while cross-value validation reports semantic provenance. `load` is the single import hook: loaders dispatch by extension, media type, or another host-defined rule and return the appropriate variant directly. diff --git a/doc/manual/souce/design/execution-pipeline.md b/doc/manual/souce/design/execution-pipeline.md index 8d3d1e3..7fa7b36 100644 --- a/doc/manual/souce/design/execution-pipeline.md +++ b/doc/manual/souce/design/execution-pipeline.md @@ -71,10 +71,10 @@ ModuleRegistry: import 先 module は、この段階で全て読み込む必要はない。 import expression が評価されたとき、処理系は `ImportLoader::load` に現在の module key と import specifier を渡す。 -loader は module key、表示名、および DCDL source text または構造化済み `HostValue` を返す。 +loader は module key、表示名、および DCDL source text または構造化済み `Value` を返す。 DCDL source の場合、module registry は key が未登録なら対象 module を parse / desugar して登録する。 登録された source module は module root thunk を持つ。 -構造化値の場合、host value を runtime value に internalize した root thunk を key でキャッシュする。 +構造化値の場合、host が返した `Value` を runtime value に internalize した root thunk を key でキャッシュする。 同じ key が複数回 import された場合は、同じ source module または structured root thunk を使う。 つまり source import は module を即時評価しない。 diff --git a/doc/manual/souce/design/features.md b/doc/manual/souce/design/features.md index 28dbcf9..3070fd5 100644 --- a/doc/manual/souce/design/features.md +++ b/doc/manual/souce/design/features.md @@ -10,7 +10,7 @@ Core に入れる機能は、基本的に deterministic な value transformation - arithmetic / logical / comparison operators - array concat - object / constraint composition -- asymmetric range refinement and homogeneous map constraints +- asymmetric range refinement, `Unknown`, map constraints, and object rest constraints - default materialization - pure function evaluation - host supplied import evaluation @@ -24,7 +24,7 @@ Core に入れないものは以下である。 - arbitrary host function calls - symbolic constraint solving beyond simple normalization -未解決 identifier や missing field は `unknown` として流れず、diagnostic になる。 +未解決 identifier や missing field は明示的な `Unknown` range とは異なり、diagnostic になる。 この方針により、存在チェックや optional chaining のような dynamic object inspection は core language の対象外とする。 ## Constraint reasoning diff --git a/doc/manual/souce/design/runtime-model.md b/doc/manual/souce/design/runtime-model.md index fa04888..d2f6cc1 100644 --- a/doc/manual/souce/design/runtime-model.md +++ b/doc/manual/souce/design/runtime-model.md @@ -14,9 +14,9 @@ RuntimeValue = `Concrete` は明示的な値である。 `Abstract` は、まだ具体値に確定していない制約付きの値である。 -Decodal は `unknown`、`any`、`null` のような「存在するが意味が未確定な値」を runtime value として持たない。 -識別子や field が解決できない場合は、その場で diagnostic になる。 -未解決値を後続の演算へ流して推論することはしない。 +Decodal は `Unknown` を、すべてのDecodal値を包含する最上位の abstract range として持つ。 +これは存在する具体値の型情報を消す `Any` ではない。具体値を `Unknown` に対して検証した場合は具体値を保持し、`Unknown` のままmaterializeしようとした場合は diagnostic になる。 +識別子や field が解決できない状態とは区別し、それらは従来どおりその場で diagnostic になる。 ## ConcreteValue @@ -37,10 +37,15 @@ object は concrete structure として扱う。 ```text ObjectValue: fields: Map + rest: Option ObjectField: value: ThunkId span: Span + +ObjectRest: + value: ThunkId + span: Span ``` 例えば以下の schema object は、object 自体は concrete だが、field の値は abstract value になる。 @@ -122,6 +127,7 @@ constraint は concrete value とは別の型として扱う。 ```text Constraint = + Unknown Type(PrimitiveType) ArrayItems(ThunkId) MapValues(ThunkId) @@ -137,6 +143,8 @@ Constraint = `MapValues` は object の key 集合を制限せず、すべての field value へ適用する schema thunk を表す。 連想配列は materialize 後も `Data::Object` になり、別の data variant は持たない。 +`ObjectValue.rest` は名前付きfieldを持つobjectの残余field rangeを表す。rest自体はfieldを生成せず、materializeは実在するfieldだけを出力する。 + 初期実装では、object の形は主に `Concrete(Object)` の field に `Abstract` を置くことで表現する。 object 全体にかかる constraint は必要になった時点で追加する。 diff --git a/doc/manual/souce/language/constraints-and-defaults.md b/doc/manual/souce/language/constraints-and-defaults.md index 15471ab..92d3c9c 100644 --- a/doc/manual/souce/language/constraints-and-defaults.md +++ b/doc/manual/souce/language/constraints-and-defaults.md @@ -82,12 +82,27 @@ Int & >= 10 & <= 10 # OK 最小の組み込み制約は以下である。 ```dcdl +Unknown String Int Float Bool ``` +`Unknown` はすべてのDecodal値を含む最上位rangeである。検査を無効化する `Any` ではなく、具体的な値またはより狭いrangeがまだ決まっていないことを表す。 + +```dcdl +Int & Unknown # Int +42 as Unknown # 42 +Unknown as Int # エラー +``` + +`Unknown` 自体は具体値を持たないためmaterializeできない。defaultを与えるか、具体値で絞り込む必要がある。 + +```dcdl +Unknown default {} # {} +``` + 追加の述語制約はライブラリまたは組み込みとして提供できる。 ```dcdl @@ -150,7 +165,16 @@ Services = {...{ ``` key は schema で列挙せず、空 object も許容する。 -固定 object field と任意 key の value constraint を混在させる構文は現在サポートしない。 +固定 object field と任意 key の value constraint は、末尾の `...T` で混在できる。 + +```dcdl +{ + enabled = Bool default true; + ...Unknown +} +``` + +このrest constraintは明示されていないfieldだけに適用され、field自体は生成しない。 ## default diff --git a/doc/manual/souce/language/expression/object.md b/doc/manual/souce/language/expression/object.md index 073c1f3..e5edeb5 100644 --- a/doc/manual/souce/language/expression/object.md +++ b/doc/manual/souce/language/expression/object.md @@ -63,4 +63,26 @@ services = { 右辺にしかない field は default の有無にかかわらず abstract のまま残る。 host から渡した object は識別子構文に収まらない文字列 key も保持できるが、DCDL source の object field name は通常の識別子に限られる。 -固定 field と任意 key を一つの object schema に混在させる rest-field 構文は、現在サポートしない。 +## Object rest constraint + +固定 field と任意 key の value range は、一つの object に混在できる。 + +```dcdl +OpenConfig = { + enabled = Bool default true; + ...Unknown +}; +``` + +`...T` は明示されていない残余 field にだけ適用する。明示 field にはそれぞれの field range を適用し、rest range を重ねて適用しない。 +rest constraint は field を生成せず、materialize 時には実際に存在する追加 field だけを出力する。 + +```dcdl +{ + enabled = false; + plugin = { name = "cache"; }; +} as OpenConfig +``` + +`...T` は object の末尾に一つだけ書ける。省略した object は閉じており、`as` の左辺に未宣言 field があればエラーになる。 +名前付き field を持たない `{...T}` は従来どおり抽象的な map constraint であり、単独でmaterializeするにはdefaultまたは具体値が必要になる。 diff --git a/doc/manual/souce/language/expression/path-reference.md b/doc/manual/souce/language/expression/path-reference.md index b9030ab..0ab0d73 100644 --- a/doc/manual/souce/language/expression/path-reference.md +++ b/doc/manual/souce/language/expression/path-reference.md @@ -13,4 +13,4 @@ config.feature_hoge.enable 参照先 field は必要になるまで評価されない。 存在しない field への参照は diagnostic になる。 -Decodal は unknown / Any のような値を伝播せず、field の有無を曖昧にしない。 +明示的な `Unknown` range は存在しないfieldを表さないため、fieldの有無を曖昧にはしない。 diff --git a/doc/manual/souce/language/grammar.md b/doc/manual/souce/language/grammar.md index 8610f5a..fdd5bba 100644 --- a/doc/manual/souce/language/grammar.md +++ b/doc/manual/souce/language/grammar.md @@ -71,7 +71,9 @@ literal = string | integer | float | "true" | "false" | regex ; comparison_operator = "==" | "!=" | "<" | "<=" | ">" | ">=" ; comparison_constraint = ( "<" | "<=" | ">" | ">=" ) , expression ; -object = "{" , [ field_definition , { ";" , field_definition } , [ ";" ] ] , "}" ; +object = "{" , [ field_definition , { ";" , field_definition } + , [ ";" , object_rest ] , [ ";" ] ] , "}" ; +object_rest = "..." , expression ; map_constraint = "{" , "..." , expression , "}" ; field_definition = field_path , "=" , expression ; field_path = identifier , { "." , identifier } ; diff --git a/doc/manual/souce/language/modules-and-imports.md b/doc/manual/souce/language/modules-and-imports.md index 78a4509..686f822 100644 --- a/doc/manual/souce/language/modules-and-imports.md +++ b/doc/manual/souce/language/modules-and-imports.md @@ -43,11 +43,11 @@ CLI では canonical path を key とする。 ### 構造化 import -`ImportLoader::load` は DCDL source または host が構築した `HostValue` を import 結果として返す。 +`ImportLoader::load` は DCDL source または host が構築した `Value` を import 結果として返す。 Markdown、JSON、TOML などの解釈規則は core に固定せず、loader がファイル種別を判定して構造化する。 ```rust -use decodal::{HostValue, ImportLoader, LoadedImport}; +use decodal::{Value, ImportLoader, LoadedImport}; struct ContentLoader; @@ -62,9 +62,9 @@ impl ImportLoader for ContentLoader { let parsed = parse_frontmatter(&markdown)?; return Ok(LoadedImport::value( parsed.key, - HostValue::object([ + Value::object([ ("frontmatter", parsed.frontmatter), - ("body", HostValue::string(parsed.body)), + ("body", Value::string(parsed.body)), ]), )); } diff --git a/doc/manual/souce/language/value/index.md b/doc/manual/souce/language/value/index.md index beb3da3..f6e0ba4 100644 --- a/doc/manual/souce/language/value/index.md +++ b/doc/manual/souce/language/value/index.md @@ -13,6 +13,7 @@ tags = [...String]; ``` 現在の primitive type は `String`、`Int`、`Float`、`Bool` である。 +`Unknown` はprimitive typeではなく、すべてのDecodal値を含む最上位の抽象rangeである。具体値またはdefaultがない `Unknown` はmaterializeできない。 配列は primitive type ではなく、必須の要素制約を持つ `[...T]` で表現する。 各型の個別仕様へのリンクは [Manual Index](../../index.md) に集約する。 diff --git a/editors/lezer-decodal/decodal.grammar b/editors/lezer-decodal/decodal.grammar index 44ebb4e..b59b89c 100644 --- a/editors/lezer-decodal/decodal.grammar +++ b/editors/lezer-decodal/decodal.grammar @@ -90,7 +90,12 @@ Literal { String | Integer | Float | True | False | Regex } CompareOperator { EqualEqual | BangEqual | Lt | Lte | Gt | Gte } ComparisonConstraint { (Lt | Lte | Gt | Gte) Expression } -Object { LBrace (FieldDefinition (Semicolon FieldDefinition)* Semicolon?)? RBrace } +Object { + LBrace + (FieldDefinition (Semicolon FieldDefinition)* (Semicolon ObjectRest)? Semicolon?)? + RBrace +} +ObjectRest { Ellipsis Expression } MapConstraint { LBrace Ellipsis Expression RBrace } FieldDefinition { FieldPath Equal Expression } FieldPath { Identifier !fieldPath (Dot Identifier)* } diff --git a/editors/tree-sitter-decodal/corpus/basic.txt b/editors/tree-sitter-decodal/corpus/basic.txt index 0b3fea9..937f2cd 100644 --- a/editors/tree-sitter-decodal/corpus/basic.txt +++ b/editors/tree-sitter-decodal/corpus/basic.txt @@ -210,3 +210,29 @@ Map constraint and ascription (field_definition path: (field_path (identifier)) value: (identifier)))))))) + +================== +Unknown object rest constraint +================== +{ + value = { + hoge = Int; + fuga = String; + ...Unknown + }; +} +--- + +(source_file + (object + (field_definition + path: (field_path (identifier)) + value: (object + (field_definition + path: (field_path (identifier)) + value: (identifier)) + (field_definition + path: (field_path (identifier)) + value: (identifier)) + (object_rest + value: (identifier)))))) diff --git a/editors/tree-sitter-decodal/grammar.js b/editors/tree-sitter-decodal/grammar.js index cf4d2f8..54d27aa 100644 --- a/editors/tree-sitter-decodal/grammar.js +++ b/editors/tree-sitter-decodal/grammar.js @@ -99,10 +99,20 @@ module.exports = grammar({ object: $ => seq( '{', - semiSep($.field_definition), + optional(seq( + $.field_definition, + repeat(seq(';', $.field_definition)), + optional(seq(';', $.object_rest)), + optional(';'), + )), '}', ), + object_rest: $ => seq( + '...', + field('value', $._expression), + ), + map_constraint: $ => seq( '{', '...', diff --git a/editors/tree-sitter-decodal/queries/highlights.scm b/editors/tree-sitter-decodal/queries/highlights.scm index f796013..dbe1ccf 100644 --- a/editors/tree-sitter-decodal/queries/highlights.scm +++ b/editors/tree-sitter-decodal/queries/highlights.scm @@ -54,7 +54,7 @@ ] @punctuation.delimiter ((identifier) @type.builtin - (#match? @type.builtin "^(String|Int|Float|Bool)$")) + (#match? @type.builtin "^(String|Int|Float|Bool|Unknown)$")) (field_definition path: (field_path (identifier) @property)) diff --git a/editors/tree-sitter-decodal/src/grammar.json b/editors/tree-sitter-decodal/src/grammar.json index f64eff8..fff99f3 100644 --- a/editors/tree-sitter-decodal/src/grammar.json +++ b/editors/tree-sitter-decodal/src/grammar.json @@ -302,6 +302,27 @@ ] } }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ";" + }, + { + "type": "SYMBOL", + "name": "object_rest" + } + ] + }, + { + "type": "BLANK" + } + ] + }, { "type": "CHOICE", "members": [ @@ -327,6 +348,23 @@ } ] }, + "object_rest": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "..." + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + } + ] + }, "map_constraint": { "type": "SEQ", "members": [ diff --git a/editors/tree-sitter-decodal/src/node-types.json b/editors/tree-sitter-decodal/src/node-types.json index 9cac035..13a8794 100644 --- a/editors/tree-sitter-decodal/src/node-types.json +++ b/editors/tree-sitter-decodal/src/node-types.json @@ -1758,10 +1758,102 @@ { "type": "field_definition", "named": true + }, + { + "type": "object_rest", + "named": true } ] } }, + { + "type": "object_rest", + "named": true, + "fields": { + "value": { + "multiple": false, + "required": true, + "types": [ + { + "type": "array", + "named": true + }, + { + "type": "array_constraint", + "named": true + }, + { + "type": "as_expression", + "named": true + }, + { + "type": "binary_expression", + "named": true + }, + { + "type": "call_expression", + "named": true + }, + { + "type": "comparison_constraint", + "named": true + }, + { + "type": "default_expression", + "named": true + }, + { + "type": "function_expression", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "import_expression", + "named": true + }, + { + "type": "let_expression", + "named": true + }, + { + "type": "literal", + "named": true + }, + { + "type": "map_constraint", + "named": true + }, + { + "type": "match_expression", + "named": true + }, + { + "type": "object", + "named": true + }, + { + "type": "parenthesized_expression", + "named": true + }, + { + "type": "path_expression", + "named": true + }, + { + "type": "regex_literal", + "named": true + }, + { + "type": "unary_expression", + "named": true + } + ] + } + } + }, { "type": "parameter", "named": true, diff --git a/editors/tree-sitter-decodal/src/parser.c b/editors/tree-sitter-decodal/src/parser.c index 9a790ff..04c08fc 100644 --- a/editors/tree-sitter-decodal/src/parser.c +++ b/editors/tree-sitter-decodal/src/parser.c @@ -5,15 +5,15 @@ #endif #define LANGUAGE_VERSION 14 -#define STATE_COUNT 245 -#define LARGE_STATE_COUNT 72 -#define SYMBOL_COUNT 77 +#define STATE_COUNT 259 +#define LARGE_STATE_COUNT 25 +#define SYMBOL_COUNT 78 #define ALIAS_COUNT 0 #define TOKEN_COUNT 45 #define EXTERNAL_TOKEN_COUNT 0 #define FIELD_COUNT 20 #define MAX_ALIAS_SEQUENCE_LENGTH 7 -#define PRODUCTION_ID_COUNT 21 +#define PRODUCTION_ID_COUNT 22 enum ts_symbol_identifiers { sym_identifier = 1, @@ -66,32 +66,33 @@ enum ts_symbol_identifiers { sym_literal = 48, sym_boolean = 49, sym_object = 50, - sym_map_constraint = 51, - sym_field_definition = 52, - sym_field_path = 53, - sym_array = 54, - sym_array_constraint = 55, - sym_let_expression = 56, - sym_function_expression = 57, - sym_parameter = 58, - sym_match_expression = 59, - sym_match_arm = 60, - sym_import_expression = 61, - sym_parenthesized_expression = 62, - sym_call_expression = 63, - sym_path_expression = 64, - sym_comparison_constraint = 65, - sym_unary_expression = 66, - sym_binary_expression = 67, - sym_default_expression = 68, - sym_as_expression = 69, - aux_sym_source_file_repeat1 = 70, - aux_sym_object_repeat1 = 71, - aux_sym_field_path_repeat1 = 72, - aux_sym_array_repeat1 = 73, - aux_sym_let_expression_repeat1 = 74, - aux_sym_function_expression_repeat1 = 75, - aux_sym_match_expression_repeat1 = 76, + sym_object_rest = 51, + sym_map_constraint = 52, + sym_field_definition = 53, + sym_field_path = 54, + sym_array = 55, + sym_array_constraint = 56, + sym_let_expression = 57, + sym_function_expression = 58, + sym_parameter = 59, + sym_match_expression = 60, + sym_match_arm = 61, + sym_import_expression = 62, + sym_parenthesized_expression = 63, + sym_call_expression = 64, + sym_path_expression = 65, + sym_comparison_constraint = 66, + sym_unary_expression = 67, + sym_binary_expression = 68, + sym_default_expression = 69, + sym_as_expression = 70, + aux_sym_source_file_repeat1 = 71, + aux_sym_object_repeat1 = 72, + aux_sym_field_path_repeat1 = 73, + aux_sym_array_repeat1 = 74, + aux_sym_let_expression_repeat1 = 75, + aux_sym_function_expression_repeat1 = 76, + aux_sym_match_expression_repeat1 = 77, }; static const char * const ts_symbol_names[] = { @@ -146,6 +147,7 @@ static const char * const ts_symbol_names[] = { [sym_literal] = "literal", [sym_boolean] = "boolean", [sym_object] = "object", + [sym_object_rest] = "object_rest", [sym_map_constraint] = "map_constraint", [sym_field_definition] = "field_definition", [sym_field_path] = "field_path", @@ -226,6 +228,7 @@ static const TSSymbol ts_symbol_map[] = { [sym_literal] = sym_literal, [sym_boolean] = sym_boolean, [sym_object] = sym_object, + [sym_object_rest] = sym_object_rest, [sym_map_constraint] = sym_map_constraint, [sym_field_definition] = sym_field_definition, [sym_field_path] = sym_field_path, @@ -459,6 +462,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_object_rest] = { + .visible = true, + .named = true, + }, [sym_map_constraint] = { .visible = true, .named = true, @@ -631,8 +638,9 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [16] = {.index = 24, .length = 1}, [17] = {.index = 25, .length = 1}, [18] = {.index = 26, .length = 1}, - [19] = {.index = 27, .length = 2}, - [20] = {.index = 29, .length = 1}, + [19] = {.index = 27, .length = 1}, + [20] = {.index = 28, .length = 2}, + [21] = {.index = 30, .length = 1}, }; static const TSFieldMapEntry ts_field_map_entries[] = { @@ -678,13 +686,15 @@ static const TSFieldMapEntry ts_field_map_entries[] = { [24] = {field_scrutinee, 1}, [25] = - {field_body, 4}, + {field_value, 1}, [26] = - {field_body, 5}, + {field_body, 4}, [27] = + {field_body, 5}, + [28] = {field_body, 2}, {field_pattern, 0}, - [29] = + [30] = {field_body, 6}, }; @@ -729,9 +739,9 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [29] = 29, [30] = 30, [31] = 31, - [32] = 26, + [32] = 32, [33] = 33, - [34] = 28, + [34] = 27, [35] = 35, [36] = 36, [37] = 35, @@ -760,16 +770,16 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [60] = 29, [61] = 61, [62] = 45, - [63] = 61, + [63] = 63, [64] = 44, [65] = 40, [66] = 43, [67] = 67, [68] = 36, - [69] = 69, + [69] = 63, [70] = 42, - [71] = 69, - [72] = 72, + [71] = 32, + [72] = 26, [73] = 73, [74] = 74, [75] = 75, @@ -814,86 +824,86 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [114] = 114, [115] = 115, [116] = 116, - [117] = 73, - [118] = 88, - [119] = 91, - [120] = 92, - [121] = 94, - [122] = 98, - [123] = 102, - [124] = 104, - [125] = 106, - [126] = 114, - [127] = 109, - [128] = 96, - [129] = 115, - [130] = 113, - [131] = 108, - [132] = 101, - [133] = 99, - [134] = 93, - [135] = 89, - [136] = 86, - [137] = 85, - [138] = 84, - [139] = 83, - [140] = 82, - [141] = 90, - [142] = 112, - [143] = 81, - [144] = 80, - [145] = 111, - [146] = 110, - [147] = 79, - [148] = 105, - [149] = 103, - [150] = 100, + [117] = 117, + [118] = 118, + [119] = 119, + [120] = 89, + [121] = 75, + [122] = 92, + [123] = 93, + [124] = 94, + [125] = 74, + [126] = 100, + [127] = 104, + [128] = 105, + [129] = 108, + [130] = 112, + [131] = 117, + [132] = 98, + [133] = 111, + [134] = 119, + [135] = 115, + [136] = 110, + [137] = 103, + [138] = 101, + [139] = 97, + [140] = 88, + [141] = 86, + [142] = 85, + [143] = 84, + [144] = 83, + [145] = 82, + [146] = 81, + [147] = 80, + [148] = 79, + [149] = 91, + [150] = 118, [151] = 78, [152] = 77, - [153] = 75, - [154] = 74, - [155] = 95, + [153] = 113, + [154] = 109, + [155] = 96, [156] = 107, - [157] = 76, - [158] = 97, - [159] = 159, - [160] = 160, - [161] = 161, - [162] = 159, - [163] = 161, + [157] = 106, + [158] = 102, + [159] = 114, + [160] = 95, + [161] = 76, + [162] = 90, + [163] = 99, [164] = 164, [165] = 165, - [166] = 166, + [166] = 164, [167] = 167, [168] = 168, - [169] = 87, - [170] = 168, + [169] = 167, + [170] = 170, [171] = 171, [172] = 172, - [173] = 173, - [174] = 172, + [173] = 87, + [174] = 174, [175] = 175, - [176] = 173, - [177] = 171, + [176] = 175, + [177] = 177, [178] = 178, [179] = 179, - [180] = 179, + [180] = 180, [181] = 181, - [182] = 182, + [182] = 178, [183] = 181, - [184] = 184, - [185] = 184, + [184] = 177, + [185] = 185, [186] = 186, - [187] = 187, - [188] = 188, - [189] = 187, - [190] = 186, + [187] = 185, + [188] = 186, + [189] = 189, + [190] = 189, [191] = 191, - [192] = 192, + [192] = 191, [193] = 193, [194] = 194, - [195] = 195, - [196] = 193, + [195] = 194, + [196] = 196, [197] = 197, [198] = 198, [199] = 199, @@ -902,46 +912,60 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [202] = 202, [203] = 203, [204] = 204, - [205] = 205, - [206] = 205, - [207] = 194, + [205] = 202, + [206] = 206, + [207] = 207, [208] = 208, - [209] = 200, + [209] = 209, [210] = 210, [211] = 201, - [212] = 208, - [213] = 213, + [212] = 209, + [213] = 197, [214] = 214, - [215] = 198, - [216] = 197, - [217] = 203, - [218] = 213, + [215] = 215, + [216] = 199, + [217] = 215, + [218] = 204, [219] = 219, - [220] = 220, + [220] = 203, [221] = 221, [222] = 222, - [223] = 223, - [224] = 224, + [223] = 208, + [224] = 198, [225] = 225, - [226] = 226, - [227] = 226, + [226] = 225, + [227] = 227, [228] = 228, [229] = 229, [230] = 230, - [231] = 231, + [231] = 228, [232] = 232, [233] = 233, [234] = 234, - [235] = 233, + [235] = 235, [236] = 236, [237] = 237, [238] = 238, - [239] = 238, - [240] = 228, - [241] = 229, - [242] = 225, - [243] = 236, - [244] = 232, + [239] = 237, + [240] = 240, + [241] = 241, + [242] = 242, + [243] = 238, + [244] = 244, + [245] = 235, + [246] = 246, + [247] = 247, + [248] = 241, + [249] = 249, + [250] = 236, + [251] = 251, + [252] = 252, + [253] = 249, + [254] = 252, + [255] = 255, + [256] = 246, + [257] = 242, + [258] = 244, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -1460,7 +1484,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [69] = {.lex_state = 0}, [70] = {.lex_state = 0}, [71] = {.lex_state = 0}, - [72] = {.lex_state = 15}, + [72] = {.lex_state = 0}, [73] = {.lex_state = 15}, [74] = {.lex_state = 15}, [75] = {.lex_state = 15}, @@ -1505,9 +1529,9 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [114] = {.lex_state = 15}, [115] = {.lex_state = 15}, [116] = {.lex_state = 15}, - [117] = {.lex_state = 2}, - [118] = {.lex_state = 2}, - [119] = {.lex_state = 2}, + [117] = {.lex_state = 15}, + [118] = {.lex_state = 15}, + [119] = {.lex_state = 15}, [120] = {.lex_state = 2}, [121] = {.lex_state = 2}, [122] = {.lex_state = 2}, @@ -1555,50 +1579,50 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [164] = {.lex_state = 2}, [165] = {.lex_state = 2}, [166] = {.lex_state = 2}, - [167] = {.lex_state = 0}, + [167] = {.lex_state = 2}, [168] = {.lex_state = 2}, [169] = {.lex_state = 2}, [170] = {.lex_state = 2}, [171] = {.lex_state = 2}, [172] = {.lex_state = 2}, [173] = {.lex_state = 2}, - [174] = {.lex_state = 2}, - [175] = {.lex_state = 0}, + [174] = {.lex_state = 0}, + [175] = {.lex_state = 2}, [176] = {.lex_state = 2}, [177] = {.lex_state = 2}, [178] = {.lex_state = 2}, - [179] = {.lex_state = 0}, + [179] = {.lex_state = 2}, [180] = {.lex_state = 0}, - [181] = {.lex_state = 0}, - [182] = {.lex_state = 0}, - [183] = {.lex_state = 0}, - [184] = {.lex_state = 1}, + [181] = {.lex_state = 2}, + [182] = {.lex_state = 2}, + [183] = {.lex_state = 2}, + [184] = {.lex_state = 2}, [185] = {.lex_state = 1}, - [186] = {.lex_state = 0}, - [187] = {.lex_state = 0}, - [188] = {.lex_state = 0}, + [186] = {.lex_state = 1}, + [187] = {.lex_state = 1}, + [188] = {.lex_state = 1}, [189] = {.lex_state = 0}, [190] = {.lex_state = 0}, [191] = {.lex_state = 0}, - [192] = {.lex_state = 15}, + [192] = {.lex_state = 0}, [193] = {.lex_state = 0}, - [194] = {.lex_state = 0}, - [195] = {.lex_state = 0}, + [194] = {.lex_state = 1}, + [195] = {.lex_state = 1}, [196] = {.lex_state = 0}, [197] = {.lex_state = 0}, [198] = {.lex_state = 0}, [199] = {.lex_state = 0}, - [200] = {.lex_state = 0}, + [200] = {.lex_state = 15}, [201] = {.lex_state = 0}, - [202] = {.lex_state = 15}, + [202] = {.lex_state = 0}, [203] = {.lex_state = 0}, [204] = {.lex_state = 0}, [205] = {.lex_state = 0}, [206] = {.lex_state = 0}, - [207] = {.lex_state = 0}, + [207] = {.lex_state = 15}, [208] = {.lex_state = 0}, [209] = {.lex_state = 0}, - [210] = {.lex_state = 15}, + [210] = {.lex_state = 0}, [211] = {.lex_state = 0}, [212] = {.lex_state = 0}, [213] = {.lex_state = 0}, @@ -1608,31 +1632,45 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [217] = {.lex_state = 0}, [218] = {.lex_state = 0}, [219] = {.lex_state = 0}, - [220] = {.lex_state = 15}, - [221] = {.lex_state = 0}, + [220] = {.lex_state = 0}, + [221] = {.lex_state = 15}, [222] = {.lex_state = 0}, [223] = {.lex_state = 0}, [224] = {.lex_state = 0}, - [225] = {.lex_state = 1}, + [225] = {.lex_state = 0}, [226] = {.lex_state = 0}, [227] = {.lex_state = 0}, - [228] = {.lex_state = 1}, - [229] = {.lex_state = 1}, + [228] = {.lex_state = 0}, + [229] = {.lex_state = 0}, [230] = {.lex_state = 0}, [231] = {.lex_state = 0}, - [232] = {.lex_state = 1}, - [233] = {.lex_state = 0}, + [232] = {.lex_state = 0}, + [233] = {.lex_state = 15}, [234] = {.lex_state = 0}, [235] = {.lex_state = 0}, [236] = {.lex_state = 0}, - [237] = {.lex_state = 0}, - [238] = {.lex_state = 0}, - [239] = {.lex_state = 0}, - [240] = {.lex_state = 1}, - [241] = {.lex_state = 1}, - [242] = {.lex_state = 1}, - [243] = {.lex_state = 0}, + [237] = {.lex_state = 1}, + [238] = {.lex_state = 1}, + [239] = {.lex_state = 1}, + [240] = {.lex_state = 0}, + [241] = {.lex_state = 0}, + [242] = {.lex_state = 0}, + [243] = {.lex_state = 1}, [244] = {.lex_state = 1}, + [245] = {.lex_state = 0}, + [246] = {.lex_state = 1}, + [247] = {.lex_state = 0}, + [248] = {.lex_state = 0}, + [249] = {.lex_state = 0}, + [250] = {.lex_state = 0}, + [251] = {.lex_state = 0}, + [252] = {.lex_state = 0}, + [253] = {.lex_state = 0}, + [254] = {.lex_state = 0}, + [255] = {.lex_state = 0}, + [256] = {.lex_state = 1}, + [257] = {.lex_state = 0}, + [258] = {.lex_state = 1}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -1683,15 +1721,15 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_as] = ACTIONS(1), }, [1] = { - [sym_source_file] = STATE(237), + [sym_source_file] = STATE(240), [sym__statement] = STATE(2), [sym__expression] = STATE(116), [sym_literal] = STATE(116), - [sym_boolean] = STATE(112), + [sym_boolean] = STATE(118), [sym_object] = STATE(116), [sym_map_constraint] = STATE(116), - [sym_field_definition] = STATE(167), - [sym_field_path] = STATE(235), + [sym_field_definition] = STATE(174), + [sym_field_path] = STATE(249), [sym_array] = STATE(116), [sym_array_constraint] = STATE(116), [sym_let_expression] = STATE(116), @@ -1733,11 +1771,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__statement] = STATE(3), [sym__expression] = STATE(116), [sym_literal] = STATE(116), - [sym_boolean] = STATE(112), + [sym_boolean] = STATE(118), [sym_object] = STATE(116), [sym_map_constraint] = STATE(116), - [sym_field_definition] = STATE(167), - [sym_field_path] = STATE(235), + [sym_field_definition] = STATE(174), + [sym_field_path] = STATE(249), [sym_array] = STATE(116), [sym_array_constraint] = STATE(116), [sym_let_expression] = STATE(116), @@ -1779,11 +1817,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__statement] = STATE(3), [sym__expression] = STATE(116), [sym_literal] = STATE(116), - [sym_boolean] = STATE(112), + [sym_boolean] = STATE(118), [sym_object] = STATE(116), [sym_map_constraint] = STATE(116), - [sym_field_definition] = STATE(167), - [sym_field_path] = STATE(235), + [sym_field_definition] = STATE(174), + [sym_field_path] = STATE(249), [sym_array] = STATE(116), [sym_array_constraint] = STATE(116), [sym_let_expression] = STATE(116), @@ -1822,26 +1860,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(78), }, [4] = { - [sym__expression] = STATE(178), - [sym_literal] = STATE(178), - [sym_boolean] = STATE(142), - [sym_object] = STATE(178), - [sym_map_constraint] = STATE(178), - [sym_array] = STATE(178), - [sym_array_constraint] = STATE(178), - [sym_let_expression] = STATE(178), - [sym_function_expression] = STATE(178), - [sym_match_expression] = STATE(178), - [sym_match_arm] = STATE(201), - [sym_import_expression] = STATE(178), - [sym_parenthesized_expression] = STATE(178), - [sym_call_expression] = STATE(178), - [sym_path_expression] = STATE(178), - [sym_comparison_constraint] = STATE(178), - [sym_unary_expression] = STATE(178), - [sym_binary_expression] = STATE(178), - [sym_default_expression] = STATE(178), - [sym_as_expression] = STATE(178), + [sym__expression] = STATE(179), + [sym_literal] = STATE(179), + [sym_boolean] = STATE(150), + [sym_object] = STATE(179), + [sym_map_constraint] = STATE(179), + [sym_array] = STATE(179), + [sym_array_constraint] = STATE(179), + [sym_let_expression] = STATE(179), + [sym_function_expression] = STATE(179), + [sym_match_expression] = STATE(179), + [sym_match_arm] = STATE(211), + [sym_import_expression] = STATE(179), + [sym_parenthesized_expression] = STATE(179), + [sym_call_expression] = STATE(179), + [sym_path_expression] = STATE(179), + [sym_comparison_constraint] = STATE(179), + [sym_unary_expression] = STATE(179), + [sym_binary_expression] = STATE(179), + [sym_default_expression] = STATE(179), + [sym_as_expression] = STATE(179), [sym_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1866,26 +1904,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [5] = { - [sym__expression] = STATE(178), - [sym_literal] = STATE(178), - [sym_boolean] = STATE(142), - [sym_object] = STATE(178), - [sym_map_constraint] = STATE(178), - [sym_array] = STATE(178), - [sym_array_constraint] = STATE(178), - [sym_let_expression] = STATE(178), - [sym_function_expression] = STATE(178), - [sym_match_expression] = STATE(178), - [sym_match_arm] = STATE(219), - [sym_import_expression] = STATE(178), - [sym_parenthesized_expression] = STATE(178), - [sym_call_expression] = STATE(178), - [sym_path_expression] = STATE(178), - [sym_comparison_constraint] = STATE(178), - [sym_unary_expression] = STATE(178), - [sym_binary_expression] = STATE(178), - [sym_default_expression] = STATE(178), - [sym_as_expression] = STATE(178), + [sym__expression] = STATE(179), + [sym_literal] = STATE(179), + [sym_boolean] = STATE(150), + [sym_object] = STATE(179), + [sym_map_constraint] = STATE(179), + [sym_array] = STATE(179), + [sym_array_constraint] = STATE(179), + [sym_let_expression] = STATE(179), + [sym_function_expression] = STATE(179), + [sym_match_expression] = STATE(179), + [sym_match_arm] = STATE(230), + [sym_import_expression] = STATE(179), + [sym_parenthesized_expression] = STATE(179), + [sym_call_expression] = STATE(179), + [sym_path_expression] = STATE(179), + [sym_comparison_constraint] = STATE(179), + [sym_unary_expression] = STATE(179), + [sym_binary_expression] = STATE(179), + [sym_default_expression] = STATE(179), + [sym_as_expression] = STATE(179), [sym_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1910,26 +1948,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [6] = { - [sym__expression] = STATE(178), - [sym_literal] = STATE(178), - [sym_boolean] = STATE(142), - [sym_object] = STATE(178), - [sym_map_constraint] = STATE(178), - [sym_array] = STATE(178), - [sym_array_constraint] = STATE(178), - [sym_let_expression] = STATE(178), - [sym_function_expression] = STATE(178), - [sym_match_expression] = STATE(178), - [sym_match_arm] = STATE(211), - [sym_import_expression] = STATE(178), - [sym_parenthesized_expression] = STATE(178), - [sym_call_expression] = STATE(178), - [sym_path_expression] = STATE(178), - [sym_comparison_constraint] = STATE(178), - [sym_unary_expression] = STATE(178), - [sym_binary_expression] = STATE(178), - [sym_default_expression] = STATE(178), - [sym_as_expression] = STATE(178), + [sym__expression] = STATE(179), + [sym_literal] = STATE(179), + [sym_boolean] = STATE(150), + [sym_object] = STATE(179), + [sym_map_constraint] = STATE(179), + [sym_array] = STATE(179), + [sym_array_constraint] = STATE(179), + [sym_let_expression] = STATE(179), + [sym_function_expression] = STATE(179), + [sym_match_expression] = STATE(179), + [sym_match_arm] = STATE(201), + [sym_import_expression] = STATE(179), + [sym_parenthesized_expression] = STATE(179), + [sym_call_expression] = STATE(179), + [sym_path_expression] = STATE(179), + [sym_comparison_constraint] = STATE(179), + [sym_unary_expression] = STATE(179), + [sym_binary_expression] = STATE(179), + [sym_default_expression] = STATE(179), + [sym_as_expression] = STATE(179), [sym_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1954,26 +1992,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [7] = { - [sym__expression] = STATE(178), - [sym_literal] = STATE(178), - [sym_boolean] = STATE(142), - [sym_object] = STATE(178), - [sym_map_constraint] = STATE(178), - [sym_array] = STATE(178), - [sym_array_constraint] = STATE(178), - [sym_let_expression] = STATE(178), - [sym_function_expression] = STATE(178), - [sym_match_expression] = STATE(178), - [sym_match_arm] = STATE(219), - [sym_import_expression] = STATE(178), - [sym_parenthesized_expression] = STATE(178), - [sym_call_expression] = STATE(178), - [sym_path_expression] = STATE(178), - [sym_comparison_constraint] = STATE(178), - [sym_unary_expression] = STATE(178), - [sym_binary_expression] = STATE(178), - [sym_default_expression] = STATE(178), - [sym_as_expression] = STATE(178), + [sym__expression] = STATE(179), + [sym_literal] = STATE(179), + [sym_boolean] = STATE(150), + [sym_object] = STATE(179), + [sym_map_constraint] = STATE(179), + [sym_array] = STATE(179), + [sym_array_constraint] = STATE(179), + [sym_let_expression] = STATE(179), + [sym_function_expression] = STATE(179), + [sym_match_expression] = STATE(179), + [sym_match_arm] = STATE(230), + [sym_import_expression] = STATE(179), + [sym_parenthesized_expression] = STATE(179), + [sym_call_expression] = STATE(179), + [sym_path_expression] = STATE(179), + [sym_comparison_constraint] = STATE(179), + [sym_unary_expression] = STATE(179), + [sym_binary_expression] = STATE(179), + [sym_default_expression] = STATE(179), + [sym_as_expression] = STATE(179), [sym_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1998,26 +2036,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [8] = { - [sym__expression] = STATE(178), - [sym_literal] = STATE(178), - [sym_boolean] = STATE(142), - [sym_object] = STATE(178), - [sym_map_constraint] = STATE(178), - [sym_array] = STATE(178), - [sym_array_constraint] = STATE(178), - [sym_let_expression] = STATE(178), - [sym_function_expression] = STATE(178), - [sym_match_expression] = STATE(178), - [sym_match_arm] = STATE(219), - [sym_import_expression] = STATE(178), - [sym_parenthesized_expression] = STATE(178), - [sym_call_expression] = STATE(178), - [sym_path_expression] = STATE(178), - [sym_comparison_constraint] = STATE(178), - [sym_unary_expression] = STATE(178), - [sym_binary_expression] = STATE(178), - [sym_default_expression] = STATE(178), - [sym_as_expression] = STATE(178), + [sym__expression] = STATE(179), + [sym_literal] = STATE(179), + [sym_boolean] = STATE(150), + [sym_object] = STATE(179), + [sym_map_constraint] = STATE(179), + [sym_array] = STATE(179), + [sym_array_constraint] = STATE(179), + [sym_let_expression] = STATE(179), + [sym_function_expression] = STATE(179), + [sym_match_expression] = STATE(179), + [sym_match_arm] = STATE(230), + [sym_import_expression] = STATE(179), + [sym_parenthesized_expression] = STATE(179), + [sym_call_expression] = STATE(179), + [sym_path_expression] = STATE(179), + [sym_comparison_constraint] = STATE(179), + [sym_unary_expression] = STATE(179), + [sym_binary_expression] = STATE(179), + [sym_default_expression] = STATE(179), + [sym_as_expression] = STATE(179), [sym_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2042,26 +2080,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [9] = { - [sym__expression] = STATE(178), - [sym_literal] = STATE(178), - [sym_boolean] = STATE(142), - [sym_object] = STATE(178), - [sym_map_constraint] = STATE(178), - [sym_array] = STATE(178), - [sym_array_constraint] = STATE(178), - [sym_let_expression] = STATE(178), - [sym_function_expression] = STATE(178), - [sym_match_expression] = STATE(178), - [sym_match_arm] = STATE(219), - [sym_import_expression] = STATE(178), - [sym_parenthesized_expression] = STATE(178), - [sym_call_expression] = STATE(178), - [sym_path_expression] = STATE(178), - [sym_comparison_constraint] = STATE(178), - [sym_unary_expression] = STATE(178), - [sym_binary_expression] = STATE(178), - [sym_default_expression] = STATE(178), - [sym_as_expression] = STATE(178), + [sym__expression] = STATE(179), + [sym_literal] = STATE(179), + [sym_boolean] = STATE(150), + [sym_object] = STATE(179), + [sym_map_constraint] = STATE(179), + [sym_array] = STATE(179), + [sym_array_constraint] = STATE(179), + [sym_let_expression] = STATE(179), + [sym_function_expression] = STATE(179), + [sym_match_expression] = STATE(179), + [sym_match_arm] = STATE(230), + [sym_import_expression] = STATE(179), + [sym_parenthesized_expression] = STATE(179), + [sym_call_expression] = STATE(179), + [sym_path_expression] = STATE(179), + [sym_comparison_constraint] = STATE(179), + [sym_unary_expression] = STATE(179), + [sym_binary_expression] = STATE(179), + [sym_default_expression] = STATE(179), + [sym_as_expression] = STATE(179), [sym_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2086,25 +2124,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [10] = { - [sym__expression] = STATE(163), - [sym_literal] = STATE(163), - [sym_boolean] = STATE(142), - [sym_object] = STATE(163), - [sym_map_constraint] = STATE(163), - [sym_array] = STATE(163), - [sym_array_constraint] = STATE(163), - [sym_let_expression] = STATE(163), - [sym_function_expression] = STATE(163), - [sym_match_expression] = STATE(163), - [sym_import_expression] = STATE(163), - [sym_parenthesized_expression] = STATE(163), - [sym_call_expression] = STATE(163), - [sym_path_expression] = STATE(163), - [sym_comparison_constraint] = STATE(163), - [sym_unary_expression] = STATE(163), - [sym_binary_expression] = STATE(163), - [sym_default_expression] = STATE(163), - [sym_as_expression] = STATE(163), + [sym__expression] = STATE(167), + [sym_literal] = STATE(167), + [sym_boolean] = STATE(150), + [sym_object] = STATE(167), + [sym_map_constraint] = STATE(167), + [sym_array] = STATE(167), + [sym_array_constraint] = STATE(167), + [sym_let_expression] = STATE(167), + [sym_function_expression] = STATE(167), + [sym_match_expression] = STATE(167), + [sym_import_expression] = STATE(167), + [sym_parenthesized_expression] = STATE(167), + [sym_call_expression] = STATE(167), + [sym_path_expression] = STATE(167), + [sym_comparison_constraint] = STATE(167), + [sym_unary_expression] = STATE(167), + [sym_binary_expression] = STATE(167), + [sym_default_expression] = STATE(167), + [sym_as_expression] = STATE(167), [sym_identifier] = ACTIONS(123), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2129,26 +2167,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [11] = { - [sym__expression] = STATE(173), - [sym_literal] = STATE(173), - [sym_boolean] = STATE(142), - [sym_object] = STATE(173), - [sym_map_constraint] = STATE(173), - [sym_array] = STATE(173), - [sym_array_constraint] = STATE(173), - [sym_let_expression] = STATE(173), - [sym_function_expression] = STATE(173), - [sym_parameter] = STATE(206), - [sym_match_expression] = STATE(173), - [sym_import_expression] = STATE(173), - [sym_parenthesized_expression] = STATE(173), - [sym_call_expression] = STATE(173), - [sym_path_expression] = STATE(173), - [sym_comparison_constraint] = STATE(173), - [sym_unary_expression] = STATE(173), - [sym_binary_expression] = STATE(173), - [sym_default_expression] = STATE(173), - [sym_as_expression] = STATE(173), + [sym__expression] = STATE(177), + [sym_literal] = STATE(177), + [sym_boolean] = STATE(150), + [sym_object] = STATE(177), + [sym_map_constraint] = STATE(177), + [sym_array] = STATE(177), + [sym_array_constraint] = STATE(177), + [sym_let_expression] = STATE(177), + [sym_function_expression] = STATE(177), + [sym_parameter] = STATE(216), + [sym_match_expression] = STATE(177), + [sym_import_expression] = STATE(177), + [sym_parenthesized_expression] = STATE(177), + [sym_call_expression] = STATE(177), + [sym_path_expression] = STATE(177), + [sym_comparison_constraint] = STATE(177), + [sym_unary_expression] = STATE(177), + [sym_binary_expression] = STATE(177), + [sym_default_expression] = STATE(177), + [sym_as_expression] = STATE(177), [sym_identifier] = ACTIONS(131), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2172,26 +2210,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [12] = { - [sym__expression] = STATE(178), - [sym_literal] = STATE(178), - [sym_boolean] = STATE(142), - [sym_object] = STATE(178), - [sym_map_constraint] = STATE(178), - [sym_array] = STATE(178), - [sym_array_constraint] = STATE(178), - [sym_let_expression] = STATE(178), - [sym_function_expression] = STATE(178), - [sym_match_expression] = STATE(178), - [sym_match_arm] = STATE(219), - [sym_import_expression] = STATE(178), - [sym_parenthesized_expression] = STATE(178), - [sym_call_expression] = STATE(178), - [sym_path_expression] = STATE(178), - [sym_comparison_constraint] = STATE(178), - [sym_unary_expression] = STATE(178), - [sym_binary_expression] = STATE(178), - [sym_default_expression] = STATE(178), - [sym_as_expression] = STATE(178), + [sym__expression] = STATE(179), + [sym_literal] = STATE(179), + [sym_boolean] = STATE(150), + [sym_object] = STATE(179), + [sym_map_constraint] = STATE(179), + [sym_array] = STATE(179), + [sym_array_constraint] = STATE(179), + [sym_let_expression] = STATE(179), + [sym_function_expression] = STATE(179), + [sym_match_expression] = STATE(179), + [sym_match_arm] = STATE(230), + [sym_import_expression] = STATE(179), + [sym_parenthesized_expression] = STATE(179), + [sym_call_expression] = STATE(179), + [sym_path_expression] = STATE(179), + [sym_comparison_constraint] = STATE(179), + [sym_unary_expression] = STATE(179), + [sym_binary_expression] = STATE(179), + [sym_default_expression] = STATE(179), + [sym_as_expression] = STATE(179), [sym_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2215,26 +2253,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [13] = { - [sym__expression] = STATE(176), - [sym_literal] = STATE(176), - [sym_boolean] = STATE(142), - [sym_object] = STATE(176), - [sym_map_constraint] = STATE(176), - [sym_array] = STATE(176), - [sym_array_constraint] = STATE(176), - [sym_let_expression] = STATE(176), - [sym_function_expression] = STATE(176), - [sym_parameter] = STATE(205), - [sym_match_expression] = STATE(176), - [sym_import_expression] = STATE(176), - [sym_parenthesized_expression] = STATE(176), - [sym_call_expression] = STATE(176), - [sym_path_expression] = STATE(176), - [sym_comparison_constraint] = STATE(176), - [sym_unary_expression] = STATE(176), - [sym_binary_expression] = STATE(176), - [sym_default_expression] = STATE(176), - [sym_as_expression] = STATE(176), + [sym__expression] = STATE(184), + [sym_literal] = STATE(184), + [sym_boolean] = STATE(150), + [sym_object] = STATE(184), + [sym_map_constraint] = STATE(184), + [sym_array] = STATE(184), + [sym_array_constraint] = STATE(184), + [sym_let_expression] = STATE(184), + [sym_function_expression] = STATE(184), + [sym_parameter] = STATE(199), + [sym_match_expression] = STATE(184), + [sym_import_expression] = STATE(184), + [sym_parenthesized_expression] = STATE(184), + [sym_call_expression] = STATE(184), + [sym_path_expression] = STATE(184), + [sym_comparison_constraint] = STATE(184), + [sym_unary_expression] = STATE(184), + [sym_binary_expression] = STATE(184), + [sym_default_expression] = STATE(184), + [sym_as_expression] = STATE(184), [sym_identifier] = ACTIONS(131), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2258,25 +2296,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [14] = { - [sym__expression] = STATE(161), - [sym_literal] = STATE(161), - [sym_boolean] = STATE(142), - [sym_object] = STATE(161), - [sym_map_constraint] = STATE(161), - [sym_array] = STATE(161), - [sym_array_constraint] = STATE(161), - [sym_let_expression] = STATE(161), - [sym_function_expression] = STATE(161), - [sym_match_expression] = STATE(161), - [sym_import_expression] = STATE(161), - [sym_parenthesized_expression] = STATE(161), - [sym_call_expression] = STATE(161), - [sym_path_expression] = STATE(161), - [sym_comparison_constraint] = STATE(161), - [sym_unary_expression] = STATE(161), - [sym_binary_expression] = STATE(161), - [sym_default_expression] = STATE(161), - [sym_as_expression] = STATE(161), + [sym__expression] = STATE(169), + [sym_literal] = STATE(169), + [sym_boolean] = STATE(150), + [sym_object] = STATE(169), + [sym_map_constraint] = STATE(169), + [sym_array] = STATE(169), + [sym_array_constraint] = STATE(169), + [sym_let_expression] = STATE(169), + [sym_function_expression] = STATE(169), + [sym_match_expression] = STATE(169), + [sym_import_expression] = STATE(169), + [sym_parenthesized_expression] = STATE(169), + [sym_call_expression] = STATE(169), + [sym_path_expression] = STATE(169), + [sym_comparison_constraint] = STATE(169), + [sym_unary_expression] = STATE(169), + [sym_binary_expression] = STATE(169), + [sym_default_expression] = STATE(169), + [sym_as_expression] = STATE(169), [sym_identifier] = ACTIONS(141), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2301,25 +2339,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [15] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), + [sym__expression] = STATE(168), + [sym_literal] = STATE(168), + [sym_boolean] = STATE(150), + [sym_object] = STATE(168), + [sym_map_constraint] = STATE(168), + [sym_array] = STATE(168), + [sym_array_constraint] = STATE(168), + [sym_let_expression] = STATE(168), + [sym_function_expression] = STATE(168), + [sym_match_expression] = STATE(168), + [sym_import_expression] = STATE(168), + [sym_parenthesized_expression] = STATE(168), + [sym_call_expression] = STATE(168), + [sym_path_expression] = STATE(168), + [sym_comparison_constraint] = STATE(168), + [sym_unary_expression] = STATE(168), + [sym_binary_expression] = STATE(168), + [sym_default_expression] = STATE(168), + [sym_as_expression] = STATE(168), [sym_identifier] = ACTIONS(149), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2343,25 +2381,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [16] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), + [sym__expression] = STATE(168), + [sym_literal] = STATE(168), + [sym_boolean] = STATE(150), + [sym_object] = STATE(168), + [sym_map_constraint] = STATE(168), + [sym_array] = STATE(168), + [sym_array_constraint] = STATE(168), + [sym_let_expression] = STATE(168), + [sym_function_expression] = STATE(168), + [sym_match_expression] = STATE(168), + [sym_import_expression] = STATE(168), + [sym_parenthesized_expression] = STATE(168), + [sym_call_expression] = STATE(168), + [sym_path_expression] = STATE(168), + [sym_comparison_constraint] = STATE(168), + [sym_unary_expression] = STATE(168), + [sym_binary_expression] = STATE(168), + [sym_default_expression] = STATE(168), + [sym_as_expression] = STATE(168), [sym_identifier] = ACTIONS(149), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2385,25 +2423,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [17] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), + [sym__expression] = STATE(168), + [sym_literal] = STATE(168), + [sym_boolean] = STATE(150), + [sym_object] = STATE(168), + [sym_map_constraint] = STATE(168), + [sym_array] = STATE(168), + [sym_array_constraint] = STATE(168), + [sym_let_expression] = STATE(168), + [sym_function_expression] = STATE(168), + [sym_match_expression] = STATE(168), + [sym_import_expression] = STATE(168), + [sym_parenthesized_expression] = STATE(168), + [sym_call_expression] = STATE(168), + [sym_path_expression] = STATE(168), + [sym_comparison_constraint] = STATE(168), + [sym_unary_expression] = STATE(168), + [sym_binary_expression] = STATE(168), + [sym_default_expression] = STATE(168), + [sym_as_expression] = STATE(168), [sym_identifier] = ACTIONS(149), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2427,25 +2465,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [18] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), + [sym__expression] = STATE(168), + [sym_literal] = STATE(168), + [sym_boolean] = STATE(150), + [sym_object] = STATE(168), + [sym_map_constraint] = STATE(168), + [sym_array] = STATE(168), + [sym_array_constraint] = STATE(168), + [sym_let_expression] = STATE(168), + [sym_function_expression] = STATE(168), + [sym_match_expression] = STATE(168), + [sym_import_expression] = STATE(168), + [sym_parenthesized_expression] = STATE(168), + [sym_call_expression] = STATE(168), + [sym_path_expression] = STATE(168), + [sym_comparison_constraint] = STATE(168), + [sym_unary_expression] = STATE(168), + [sym_binary_expression] = STATE(168), + [sym_default_expression] = STATE(168), + [sym_as_expression] = STATE(168), [sym_identifier] = ACTIONS(149), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2469,25 +2507,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [19] = { - [sym__expression] = STATE(159), - [sym_literal] = STATE(159), - [sym_boolean] = STATE(142), - [sym_object] = STATE(159), - [sym_map_constraint] = STATE(159), - [sym_array] = STATE(159), - [sym_array_constraint] = STATE(159), - [sym_let_expression] = STATE(159), - [sym_function_expression] = STATE(159), - [sym_match_expression] = STATE(159), - [sym_import_expression] = STATE(159), - [sym_parenthesized_expression] = STATE(159), - [sym_call_expression] = STATE(159), - [sym_path_expression] = STATE(159), - [sym_comparison_constraint] = STATE(159), - [sym_unary_expression] = STATE(159), - [sym_binary_expression] = STATE(159), - [sym_default_expression] = STATE(159), - [sym_as_expression] = STATE(159), + [sym__expression] = STATE(164), + [sym_literal] = STATE(164), + [sym_boolean] = STATE(150), + [sym_object] = STATE(164), + [sym_map_constraint] = STATE(164), + [sym_array] = STATE(164), + [sym_array_constraint] = STATE(164), + [sym_let_expression] = STATE(164), + [sym_function_expression] = STATE(164), + [sym_match_expression] = STATE(164), + [sym_import_expression] = STATE(164), + [sym_parenthesized_expression] = STATE(164), + [sym_call_expression] = STATE(164), + [sym_path_expression] = STATE(164), + [sym_comparison_constraint] = STATE(164), + [sym_unary_expression] = STATE(164), + [sym_binary_expression] = STATE(164), + [sym_default_expression] = STATE(164), + [sym_as_expression] = STATE(164), [sym_identifier] = ACTIONS(161), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2511,25 +2549,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [20] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), + [sym__expression] = STATE(168), + [sym_literal] = STATE(168), + [sym_boolean] = STATE(150), + [sym_object] = STATE(168), + [sym_map_constraint] = STATE(168), + [sym_array] = STATE(168), + [sym_array_constraint] = STATE(168), + [sym_let_expression] = STATE(168), + [sym_function_expression] = STATE(168), + [sym_match_expression] = STATE(168), + [sym_import_expression] = STATE(168), + [sym_parenthesized_expression] = STATE(168), + [sym_call_expression] = STATE(168), + [sym_path_expression] = STATE(168), + [sym_comparison_constraint] = STATE(168), + [sym_unary_expression] = STATE(168), + [sym_binary_expression] = STATE(168), + [sym_default_expression] = STATE(168), + [sym_as_expression] = STATE(168), [sym_identifier] = ACTIONS(149), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2553,25 +2591,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [21] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), + [sym__expression] = STATE(168), + [sym_literal] = STATE(168), + [sym_boolean] = STATE(150), + [sym_object] = STATE(168), + [sym_map_constraint] = STATE(168), + [sym_array] = STATE(168), + [sym_array_constraint] = STATE(168), + [sym_let_expression] = STATE(168), + [sym_function_expression] = STATE(168), + [sym_match_expression] = STATE(168), + [sym_import_expression] = STATE(168), + [sym_parenthesized_expression] = STATE(168), + [sym_call_expression] = STATE(168), + [sym_path_expression] = STATE(168), + [sym_comparison_constraint] = STATE(168), + [sym_unary_expression] = STATE(168), + [sym_binary_expression] = STATE(168), + [sym_default_expression] = STATE(168), + [sym_as_expression] = STATE(168), [sym_identifier] = ACTIONS(149), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2595,25 +2633,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [22] = { - [sym__expression] = STATE(162), - [sym_literal] = STATE(162), - [sym_boolean] = STATE(142), - [sym_object] = STATE(162), - [sym_map_constraint] = STATE(162), - [sym_array] = STATE(162), - [sym_array_constraint] = STATE(162), - [sym_let_expression] = STATE(162), - [sym_function_expression] = STATE(162), - [sym_match_expression] = STATE(162), - [sym_import_expression] = STATE(162), - [sym_parenthesized_expression] = STATE(162), - [sym_call_expression] = STATE(162), - [sym_path_expression] = STATE(162), - [sym_comparison_constraint] = STATE(162), - [sym_unary_expression] = STATE(162), - [sym_binary_expression] = STATE(162), - [sym_default_expression] = STATE(162), - [sym_as_expression] = STATE(162), + [sym__expression] = STATE(166), + [sym_literal] = STATE(166), + [sym_boolean] = STATE(150), + [sym_object] = STATE(166), + [sym_map_constraint] = STATE(166), + [sym_array] = STATE(166), + [sym_array_constraint] = STATE(166), + [sym_let_expression] = STATE(166), + [sym_function_expression] = STATE(166), + [sym_match_expression] = STATE(166), + [sym_import_expression] = STATE(166), + [sym_parenthesized_expression] = STATE(166), + [sym_call_expression] = STATE(166), + [sym_path_expression] = STATE(166), + [sym_comparison_constraint] = STATE(166), + [sym_unary_expression] = STATE(166), + [sym_binary_expression] = STATE(166), + [sym_default_expression] = STATE(166), + [sym_as_expression] = STATE(166), [sym_identifier] = ACTIONS(171), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2637,25 +2675,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [23] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), + [sym__expression] = STATE(168), + [sym_literal] = STATE(168), + [sym_boolean] = STATE(150), + [sym_object] = STATE(168), + [sym_map_constraint] = STATE(168), + [sym_array] = STATE(168), + [sym_array_constraint] = STATE(168), + [sym_let_expression] = STATE(168), + [sym_function_expression] = STATE(168), + [sym_match_expression] = STATE(168), + [sym_import_expression] = STATE(168), + [sym_parenthesized_expression] = STATE(168), + [sym_call_expression] = STATE(168), + [sym_path_expression] = STATE(168), + [sym_comparison_constraint] = STATE(168), + [sym_unary_expression] = STATE(168), + [sym_binary_expression] = STATE(168), + [sym_default_expression] = STATE(168), + [sym_as_expression] = STATE(168), [sym_identifier] = ACTIONS(149), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2679,25 +2717,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [24] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), + [sym__expression] = STATE(168), + [sym_literal] = STATE(168), + [sym_boolean] = STATE(150), + [sym_object] = STATE(168), + [sym_map_constraint] = STATE(168), + [sym_array] = STATE(168), + [sym_array_constraint] = STATE(168), + [sym_let_expression] = STATE(168), + [sym_function_expression] = STATE(168), + [sym_match_expression] = STATE(168), + [sym_import_expression] = STATE(168), + [sym_parenthesized_expression] = STATE(168), + [sym_call_expression] = STATE(168), + [sym_path_expression] = STATE(168), + [sym_comparison_constraint] = STATE(168), + [sym_unary_expression] = STATE(168), + [sym_binary_expression] = STATE(168), + [sym_default_expression] = STATE(168), + [sym_as_expression] = STATE(168), [sym_identifier] = ACTIONS(149), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2720,1946 +2758,2755 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(111), [anon_sym_BANG] = ACTIONS(111), }, - [25] = { - [sym__expression] = STATE(143), - [sym_literal] = STATE(143), - [sym_boolean] = STATE(142), - [sym_object] = STATE(143), - [sym_map_constraint] = STATE(143), - [sym_array] = STATE(143), - [sym_array_constraint] = STATE(143), - [sym_let_expression] = STATE(143), - [sym_function_expression] = STATE(143), - [sym_match_expression] = STATE(143), - [sym_import_expression] = STATE(143), - [sym_parenthesized_expression] = STATE(143), - [sym_call_expression] = STATE(143), - [sym_path_expression] = STATE(143), - [sym_comparison_constraint] = STATE(143), - [sym_unary_expression] = STATE(143), - [sym_binary_expression] = STATE(143), - [sym_default_expression] = STATE(143), - [sym_as_expression] = STATE(143), - [sym_identifier] = ACTIONS(181), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(183), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [26] = { - [sym__expression] = STATE(156), - [sym_literal] = STATE(156), - [sym_boolean] = STATE(142), - [sym_object] = STATE(156), - [sym_map_constraint] = STATE(156), - [sym_array] = STATE(156), - [sym_array_constraint] = STATE(156), - [sym_let_expression] = STATE(156), - [sym_function_expression] = STATE(156), - [sym_match_expression] = STATE(156), - [sym_import_expression] = STATE(156), - [sym_parenthesized_expression] = STATE(156), - [sym_call_expression] = STATE(156), - [sym_path_expression] = STATE(156), - [sym_comparison_constraint] = STATE(156), - [sym_unary_expression] = STATE(156), - [sym_binary_expression] = STATE(156), - [sym_default_expression] = STATE(156), - [sym_as_expression] = STATE(156), - [sym_identifier] = ACTIONS(185), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(187), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [27] = { - [sym__expression] = STATE(165), - [sym_literal] = STATE(165), - [sym_boolean] = STATE(142), - [sym_object] = STATE(165), - [sym_map_constraint] = STATE(165), - [sym_array] = STATE(165), - [sym_array_constraint] = STATE(165), - [sym_let_expression] = STATE(165), - [sym_function_expression] = STATE(165), - [sym_match_expression] = STATE(165), - [sym_import_expression] = STATE(165), - [sym_parenthesized_expression] = STATE(165), - [sym_call_expression] = STATE(165), - [sym_path_expression] = STATE(165), - [sym_comparison_constraint] = STATE(165), - [sym_unary_expression] = STATE(165), - [sym_binary_expression] = STATE(165), - [sym_default_expression] = STATE(165), - [sym_as_expression] = STATE(165), - [sym_identifier] = ACTIONS(189), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(191), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [28] = { - [sym__expression] = STATE(102), - [sym_literal] = STATE(102), - [sym_boolean] = STATE(112), - [sym_object] = STATE(102), - [sym_map_constraint] = STATE(102), - [sym_array] = STATE(102), - [sym_array_constraint] = STATE(102), - [sym_let_expression] = STATE(102), - [sym_function_expression] = STATE(102), - [sym_match_expression] = STATE(102), - [sym_import_expression] = STATE(102), - [sym_parenthesized_expression] = STATE(102), - [sym_call_expression] = STATE(102), - [sym_path_expression] = STATE(102), - [sym_comparison_constraint] = STATE(102), - [sym_unary_expression] = STATE(102), - [sym_binary_expression] = STATE(102), - [sym_default_expression] = STATE(102), - [sym_as_expression] = STATE(102), - [sym_identifier] = ACTIONS(193), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(195), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [29] = { - [sym__expression] = STATE(174), - [sym_literal] = STATE(174), - [sym_boolean] = STATE(142), - [sym_object] = STATE(174), - [sym_map_constraint] = STATE(174), - [sym_array] = STATE(174), - [sym_array_constraint] = STATE(174), - [sym_let_expression] = STATE(174), - [sym_function_expression] = STATE(174), - [sym_match_expression] = STATE(174), - [sym_import_expression] = STATE(174), - [sym_parenthesized_expression] = STATE(174), - [sym_call_expression] = STATE(174), - [sym_path_expression] = STATE(174), - [sym_comparison_constraint] = STATE(174), - [sym_unary_expression] = STATE(174), - [sym_binary_expression] = STATE(174), - [sym_default_expression] = STATE(174), - [sym_as_expression] = STATE(174), - [sym_identifier] = ACTIONS(197), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(199), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [30] = { - [sym__expression] = STATE(168), - [sym_literal] = STATE(168), - [sym_boolean] = STATE(142), - [sym_object] = STATE(168), - [sym_map_constraint] = STATE(168), - [sym_array] = STATE(168), - [sym_array_constraint] = STATE(168), - [sym_let_expression] = STATE(168), - [sym_function_expression] = STATE(168), - [sym_match_expression] = STATE(168), - [sym_import_expression] = STATE(168), - [sym_parenthesized_expression] = STATE(168), - [sym_call_expression] = STATE(168), - [sym_path_expression] = STATE(168), - [sym_comparison_constraint] = STATE(168), - [sym_unary_expression] = STATE(168), - [sym_binary_expression] = STATE(168), - [sym_default_expression] = STATE(168), - [sym_as_expression] = STATE(168), - [sym_identifier] = ACTIONS(201), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(203), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [31] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(142), - [sym_object] = STATE(164), - [sym_map_constraint] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), - [sym_match_expression] = STATE(164), - [sym_import_expression] = STATE(164), - [sym_parenthesized_expression] = STATE(164), - [sym_call_expression] = STATE(164), - [sym_path_expression] = STATE(164), - [sym_comparison_constraint] = STATE(164), - [sym_unary_expression] = STATE(164), - [sym_binary_expression] = STATE(164), - [sym_default_expression] = STATE(164), - [sym_as_expression] = STATE(164), - [sym_identifier] = ACTIONS(149), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(151), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [32] = { - [sym__expression] = STATE(107), - [sym_literal] = STATE(107), - [sym_boolean] = STATE(112), - [sym_object] = STATE(107), - [sym_map_constraint] = STATE(107), - [sym_array] = STATE(107), - [sym_array_constraint] = STATE(107), - [sym_let_expression] = STATE(107), - [sym_function_expression] = STATE(107), - [sym_match_expression] = STATE(107), - [sym_import_expression] = STATE(107), - [sym_parenthesized_expression] = STATE(107), - [sym_call_expression] = STATE(107), - [sym_path_expression] = STATE(107), - [sym_comparison_constraint] = STATE(107), - [sym_unary_expression] = STATE(107), - [sym_binary_expression] = STATE(107), - [sym_default_expression] = STATE(107), - [sym_as_expression] = STATE(107), - [sym_identifier] = ACTIONS(205), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(207), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [33] = { - [sym__expression] = STATE(120), - [sym_literal] = STATE(120), - [sym_boolean] = STATE(142), - [sym_object] = STATE(120), - [sym_map_constraint] = STATE(120), - [sym_array] = STATE(120), - [sym_array_constraint] = STATE(120), - [sym_let_expression] = STATE(120), - [sym_function_expression] = STATE(120), - [sym_match_expression] = STATE(120), - [sym_import_expression] = STATE(120), - [sym_parenthesized_expression] = STATE(120), - [sym_call_expression] = STATE(120), - [sym_path_expression] = STATE(120), - [sym_comparison_constraint] = STATE(120), - [sym_unary_expression] = STATE(120), - [sym_binary_expression] = STATE(120), - [sym_default_expression] = STATE(120), - [sym_as_expression] = STATE(120), - [sym_identifier] = ACTIONS(209), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(211), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [34] = { - [sym__expression] = STATE(123), - [sym_literal] = STATE(123), - [sym_boolean] = STATE(142), - [sym_object] = STATE(123), - [sym_map_constraint] = STATE(123), - [sym_array] = STATE(123), - [sym_array_constraint] = STATE(123), - [sym_let_expression] = STATE(123), - [sym_function_expression] = STATE(123), - [sym_match_expression] = STATE(123), - [sym_import_expression] = STATE(123), - [sym_parenthesized_expression] = STATE(123), - [sym_call_expression] = STATE(123), - [sym_path_expression] = STATE(123), - [sym_comparison_constraint] = STATE(123), - [sym_unary_expression] = STATE(123), - [sym_binary_expression] = STATE(123), - [sym_default_expression] = STATE(123), - [sym_as_expression] = STATE(123), - [sym_identifier] = ACTIONS(213), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(215), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [35] = { - [sym__expression] = STATE(126), - [sym_literal] = STATE(126), - [sym_boolean] = STATE(142), - [sym_object] = STATE(126), - [sym_map_constraint] = STATE(126), - [sym_array] = STATE(126), - [sym_array_constraint] = STATE(126), - [sym_let_expression] = STATE(126), - [sym_function_expression] = STATE(126), - [sym_match_expression] = STATE(126), - [sym_import_expression] = STATE(126), - [sym_parenthesized_expression] = STATE(126), - [sym_call_expression] = STATE(126), - [sym_path_expression] = STATE(126), - [sym_comparison_constraint] = STATE(126), - [sym_unary_expression] = STATE(126), - [sym_binary_expression] = STATE(126), - [sym_default_expression] = STATE(126), - [sym_as_expression] = STATE(126), - [sym_identifier] = ACTIONS(217), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(219), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [36] = { - [sym__expression] = STATE(132), - [sym_literal] = STATE(132), - [sym_boolean] = STATE(142), - [sym_object] = STATE(132), - [sym_map_constraint] = STATE(132), - [sym_array] = STATE(132), - [sym_array_constraint] = STATE(132), - [sym_let_expression] = STATE(132), - [sym_function_expression] = STATE(132), - [sym_match_expression] = STATE(132), - [sym_import_expression] = STATE(132), - [sym_parenthesized_expression] = STATE(132), - [sym_call_expression] = STATE(132), - [sym_path_expression] = STATE(132), - [sym_comparison_constraint] = STATE(132), - [sym_unary_expression] = STATE(132), - [sym_binary_expression] = STATE(132), - [sym_default_expression] = STATE(132), - [sym_as_expression] = STATE(132), - [sym_identifier] = ACTIONS(221), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(223), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [37] = { - [sym__expression] = STATE(114), - [sym_literal] = STATE(114), - [sym_boolean] = STATE(112), - [sym_object] = STATE(114), - [sym_map_constraint] = STATE(114), - [sym_array] = STATE(114), - [sym_array_constraint] = STATE(114), - [sym_let_expression] = STATE(114), - [sym_function_expression] = STATE(114), - [sym_match_expression] = STATE(114), - [sym_import_expression] = STATE(114), - [sym_parenthesized_expression] = STATE(114), - [sym_call_expression] = STATE(114), - [sym_path_expression] = STATE(114), - [sym_comparison_constraint] = STATE(114), - [sym_unary_expression] = STATE(114), - [sym_binary_expression] = STATE(114), - [sym_default_expression] = STATE(114), - [sym_as_expression] = STATE(114), - [sym_identifier] = ACTIONS(225), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(227), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [38] = { - [sym__expression] = STATE(177), - [sym_literal] = STATE(177), - [sym_boolean] = STATE(142), - [sym_object] = STATE(177), - [sym_map_constraint] = STATE(177), - [sym_array] = STATE(177), - [sym_array_constraint] = STATE(177), - [sym_let_expression] = STATE(177), - [sym_function_expression] = STATE(177), - [sym_match_expression] = STATE(177), - [sym_import_expression] = STATE(177), - [sym_parenthesized_expression] = STATE(177), - [sym_call_expression] = STATE(177), - [sym_path_expression] = STATE(177), - [sym_comparison_constraint] = STATE(177), - [sym_unary_expression] = STATE(177), - [sym_binary_expression] = STATE(177), - [sym_default_expression] = STATE(177), - [sym_as_expression] = STATE(177), - [sym_identifier] = ACTIONS(229), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(231), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [39] = { - [sym__expression] = STATE(92), - [sym_literal] = STATE(92), - [sym_boolean] = STATE(112), - [sym_object] = STATE(92), - [sym_map_constraint] = STATE(92), - [sym_array] = STATE(92), - [sym_array_constraint] = STATE(92), - [sym_let_expression] = STATE(92), - [sym_function_expression] = STATE(92), - [sym_match_expression] = STATE(92), - [sym_import_expression] = STATE(92), - [sym_parenthesized_expression] = STATE(92), - [sym_call_expression] = STATE(92), - [sym_path_expression] = STATE(92), - [sym_comparison_constraint] = STATE(92), - [sym_unary_expression] = STATE(92), - [sym_binary_expression] = STATE(92), - [sym_default_expression] = STATE(92), - [sym_as_expression] = STATE(92), - [sym_identifier] = ACTIONS(233), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(235), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [40] = { - [sym__expression] = STATE(133), - [sym_literal] = STATE(133), - [sym_boolean] = STATE(142), - [sym_object] = STATE(133), - [sym_map_constraint] = STATE(133), - [sym_array] = STATE(133), - [sym_array_constraint] = STATE(133), - [sym_let_expression] = STATE(133), - [sym_function_expression] = STATE(133), - [sym_match_expression] = STATE(133), - [sym_import_expression] = STATE(133), - [sym_parenthesized_expression] = STATE(133), - [sym_call_expression] = STATE(133), - [sym_path_expression] = STATE(133), - [sym_comparison_constraint] = STATE(133), - [sym_unary_expression] = STATE(133), - [sym_binary_expression] = STATE(133), - [sym_default_expression] = STATE(133), - [sym_as_expression] = STATE(133), - [sym_identifier] = ACTIONS(237), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(239), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [41] = { - [sym__expression] = STATE(169), - [sym_literal] = STATE(169), - [sym_boolean] = STATE(142), - [sym_object] = STATE(169), - [sym_map_constraint] = STATE(169), - [sym_array] = STATE(169), - [sym_array_constraint] = STATE(169), - [sym_let_expression] = STATE(169), - [sym_function_expression] = STATE(169), - [sym_match_expression] = STATE(169), - [sym_import_expression] = STATE(169), - [sym_parenthesized_expression] = STATE(169), - [sym_call_expression] = STATE(169), - [sym_path_expression] = STATE(169), - [sym_comparison_constraint] = STATE(169), - [sym_unary_expression] = STATE(169), - [sym_binary_expression] = STATE(169), - [sym_default_expression] = STATE(169), - [sym_as_expression] = STATE(169), - [sym_identifier] = ACTIONS(241), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(243), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [42] = { - [sym__expression] = STATE(77), - [sym_literal] = STATE(77), - [sym_boolean] = STATE(112), - [sym_object] = STATE(77), - [sym_map_constraint] = STATE(77), - [sym_array] = STATE(77), - [sym_array_constraint] = STATE(77), - [sym_let_expression] = STATE(77), - [sym_function_expression] = STATE(77), - [sym_match_expression] = STATE(77), - [sym_import_expression] = STATE(77), - [sym_parenthesized_expression] = STATE(77), - [sym_call_expression] = STATE(77), - [sym_path_expression] = STATE(77), - [sym_comparison_constraint] = STATE(77), - [sym_unary_expression] = STATE(77), - [sym_binary_expression] = STATE(77), - [sym_default_expression] = STATE(77), - [sym_as_expression] = STATE(77), - [sym_identifier] = ACTIONS(245), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(247), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [43] = { - [sym__expression] = STATE(78), - [sym_literal] = STATE(78), - [sym_boolean] = STATE(112), - [sym_object] = STATE(78), - [sym_map_constraint] = STATE(78), - [sym_array] = STATE(78), - [sym_array_constraint] = STATE(78), - [sym_let_expression] = STATE(78), - [sym_function_expression] = STATE(78), - [sym_match_expression] = STATE(78), - [sym_import_expression] = STATE(78), - [sym_parenthesized_expression] = STATE(78), - [sym_call_expression] = STATE(78), - [sym_path_expression] = STATE(78), - [sym_comparison_constraint] = STATE(78), - [sym_unary_expression] = STATE(78), - [sym_binary_expression] = STATE(78), - [sym_default_expression] = STATE(78), - [sym_as_expression] = STATE(78), - [sym_identifier] = ACTIONS(249), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(251), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [44] = { - [sym__expression] = STATE(79), - [sym_literal] = STATE(79), - [sym_boolean] = STATE(112), - [sym_object] = STATE(79), - [sym_map_constraint] = STATE(79), - [sym_array] = STATE(79), - [sym_array_constraint] = STATE(79), - [sym_let_expression] = STATE(79), - [sym_function_expression] = STATE(79), - [sym_match_expression] = STATE(79), - [sym_import_expression] = STATE(79), - [sym_parenthesized_expression] = STATE(79), - [sym_call_expression] = STATE(79), - [sym_path_expression] = STATE(79), - [sym_comparison_constraint] = STATE(79), - [sym_unary_expression] = STATE(79), - [sym_binary_expression] = STATE(79), - [sym_default_expression] = STATE(79), - [sym_as_expression] = STATE(79), - [sym_identifier] = ACTIONS(253), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(255), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [45] = { - [sym__expression] = STATE(80), - [sym_literal] = STATE(80), - [sym_boolean] = STATE(112), - [sym_object] = STATE(80), - [sym_map_constraint] = STATE(80), - [sym_array] = STATE(80), - [sym_array_constraint] = STATE(80), - [sym_let_expression] = STATE(80), - [sym_function_expression] = STATE(80), - [sym_match_expression] = STATE(80), - [sym_import_expression] = STATE(80), - [sym_parenthesized_expression] = STATE(80), - [sym_call_expression] = STATE(80), - [sym_path_expression] = STATE(80), - [sym_comparison_constraint] = STATE(80), - [sym_unary_expression] = STATE(80), - [sym_binary_expression] = STATE(80), - [sym_default_expression] = STATE(80), - [sym_as_expression] = STATE(80), - [sym_identifier] = ACTIONS(257), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(259), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [46] = { - [sym__expression] = STATE(81), - [sym_literal] = STATE(81), - [sym_boolean] = STATE(112), - [sym_object] = STATE(81), - [sym_map_constraint] = STATE(81), - [sym_array] = STATE(81), - [sym_array_constraint] = STATE(81), - [sym_let_expression] = STATE(81), - [sym_function_expression] = STATE(81), - [sym_match_expression] = STATE(81), - [sym_import_expression] = STATE(81), - [sym_parenthesized_expression] = STATE(81), - [sym_call_expression] = STATE(81), - [sym_path_expression] = STATE(81), - [sym_comparison_constraint] = STATE(81), - [sym_unary_expression] = STATE(81), - [sym_binary_expression] = STATE(81), - [sym_default_expression] = STATE(81), - [sym_as_expression] = STATE(81), - [sym_identifier] = ACTIONS(261), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(263), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [47] = { - [sym__expression] = STATE(82), - [sym_literal] = STATE(82), - [sym_boolean] = STATE(112), - [sym_object] = STATE(82), - [sym_map_constraint] = STATE(82), - [sym_array] = STATE(82), - [sym_array_constraint] = STATE(82), - [sym_let_expression] = STATE(82), - [sym_function_expression] = STATE(82), - [sym_match_expression] = STATE(82), - [sym_import_expression] = STATE(82), - [sym_parenthesized_expression] = STATE(82), - [sym_call_expression] = STATE(82), - [sym_path_expression] = STATE(82), - [sym_comparison_constraint] = STATE(82), - [sym_unary_expression] = STATE(82), - [sym_binary_expression] = STATE(82), - [sym_default_expression] = STATE(82), - [sym_as_expression] = STATE(82), - [sym_identifier] = ACTIONS(265), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(267), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [48] = { - [sym__expression] = STATE(83), - [sym_literal] = STATE(83), - [sym_boolean] = STATE(112), - [sym_object] = STATE(83), - [sym_map_constraint] = STATE(83), - [sym_array] = STATE(83), - [sym_array_constraint] = STATE(83), - [sym_let_expression] = STATE(83), - [sym_function_expression] = STATE(83), - [sym_match_expression] = STATE(83), - [sym_import_expression] = STATE(83), - [sym_parenthesized_expression] = STATE(83), - [sym_call_expression] = STATE(83), - [sym_path_expression] = STATE(83), - [sym_comparison_constraint] = STATE(83), - [sym_unary_expression] = STATE(83), - [sym_binary_expression] = STATE(83), - [sym_default_expression] = STATE(83), - [sym_as_expression] = STATE(83), - [sym_identifier] = ACTIONS(269), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(271), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [49] = { - [sym__expression] = STATE(84), - [sym_literal] = STATE(84), - [sym_boolean] = STATE(112), - [sym_object] = STATE(84), - [sym_map_constraint] = STATE(84), - [sym_array] = STATE(84), - [sym_array_constraint] = STATE(84), - [sym_let_expression] = STATE(84), - [sym_function_expression] = STATE(84), - [sym_match_expression] = STATE(84), - [sym_import_expression] = STATE(84), - [sym_parenthesized_expression] = STATE(84), - [sym_call_expression] = STATE(84), - [sym_path_expression] = STATE(84), - [sym_comparison_constraint] = STATE(84), - [sym_unary_expression] = STATE(84), - [sym_binary_expression] = STATE(84), - [sym_default_expression] = STATE(84), - [sym_as_expression] = STATE(84), - [sym_identifier] = ACTIONS(273), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(275), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [50] = { - [sym__expression] = STATE(85), - [sym_literal] = STATE(85), - [sym_boolean] = STATE(112), - [sym_object] = STATE(85), - [sym_map_constraint] = STATE(85), - [sym_array] = STATE(85), - [sym_array_constraint] = STATE(85), - [sym_let_expression] = STATE(85), - [sym_function_expression] = STATE(85), - [sym_match_expression] = STATE(85), - [sym_import_expression] = STATE(85), - [sym_parenthesized_expression] = STATE(85), - [sym_call_expression] = STATE(85), - [sym_path_expression] = STATE(85), - [sym_comparison_constraint] = STATE(85), - [sym_unary_expression] = STATE(85), - [sym_binary_expression] = STATE(85), - [sym_default_expression] = STATE(85), - [sym_as_expression] = STATE(85), - [sym_identifier] = ACTIONS(277), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(279), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [51] = { - [sym__expression] = STATE(86), - [sym_literal] = STATE(86), - [sym_boolean] = STATE(112), - [sym_object] = STATE(86), - [sym_map_constraint] = STATE(86), - [sym_array] = STATE(86), - [sym_array_constraint] = STATE(86), - [sym_let_expression] = STATE(86), - [sym_function_expression] = STATE(86), - [sym_match_expression] = STATE(86), - [sym_import_expression] = STATE(86), - [sym_parenthesized_expression] = STATE(86), - [sym_call_expression] = STATE(86), - [sym_path_expression] = STATE(86), - [sym_comparison_constraint] = STATE(86), - [sym_unary_expression] = STATE(86), - [sym_binary_expression] = STATE(86), - [sym_default_expression] = STATE(86), - [sym_as_expression] = STATE(86), - [sym_identifier] = ACTIONS(281), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(283), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [52] = { - [sym__expression] = STATE(87), - [sym_literal] = STATE(87), - [sym_boolean] = STATE(112), - [sym_object] = STATE(87), - [sym_map_constraint] = STATE(87), - [sym_array] = STATE(87), - [sym_array_constraint] = STATE(87), - [sym_let_expression] = STATE(87), - [sym_function_expression] = STATE(87), - [sym_match_expression] = STATE(87), - [sym_import_expression] = STATE(87), - [sym_parenthesized_expression] = STATE(87), - [sym_call_expression] = STATE(87), - [sym_path_expression] = STATE(87), - [sym_comparison_constraint] = STATE(87), - [sym_unary_expression] = STATE(87), - [sym_binary_expression] = STATE(87), - [sym_default_expression] = STATE(87), - [sym_as_expression] = STATE(87), - [sym_identifier] = ACTIONS(285), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(287), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [53] = { - [sym__expression] = STATE(136), - [sym_literal] = STATE(136), - [sym_boolean] = STATE(142), - [sym_object] = STATE(136), - [sym_map_constraint] = STATE(136), - [sym_array] = STATE(136), - [sym_array_constraint] = STATE(136), - [sym_let_expression] = STATE(136), - [sym_function_expression] = STATE(136), - [sym_match_expression] = STATE(136), - [sym_import_expression] = STATE(136), - [sym_parenthesized_expression] = STATE(136), - [sym_call_expression] = STATE(136), - [sym_path_expression] = STATE(136), - [sym_comparison_constraint] = STATE(136), - [sym_unary_expression] = STATE(136), - [sym_binary_expression] = STATE(136), - [sym_default_expression] = STATE(136), - [sym_as_expression] = STATE(136), - [sym_identifier] = ACTIONS(289), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(291), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [54] = { - [sym__expression] = STATE(137), - [sym_literal] = STATE(137), - [sym_boolean] = STATE(142), - [sym_object] = STATE(137), - [sym_map_constraint] = STATE(137), - [sym_array] = STATE(137), - [sym_array_constraint] = STATE(137), - [sym_let_expression] = STATE(137), - [sym_function_expression] = STATE(137), - [sym_match_expression] = STATE(137), - [sym_import_expression] = STATE(137), - [sym_parenthesized_expression] = STATE(137), - [sym_call_expression] = STATE(137), - [sym_path_expression] = STATE(137), - [sym_comparison_constraint] = STATE(137), - [sym_unary_expression] = STATE(137), - [sym_binary_expression] = STATE(137), - [sym_default_expression] = STATE(137), - [sym_as_expression] = STATE(137), - [sym_identifier] = ACTIONS(293), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(295), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [55] = { - [sym__expression] = STATE(138), - [sym_literal] = STATE(138), - [sym_boolean] = STATE(142), - [sym_object] = STATE(138), - [sym_map_constraint] = STATE(138), - [sym_array] = STATE(138), - [sym_array_constraint] = STATE(138), - [sym_let_expression] = STATE(138), - [sym_function_expression] = STATE(138), - [sym_match_expression] = STATE(138), - [sym_import_expression] = STATE(138), - [sym_parenthesized_expression] = STATE(138), - [sym_call_expression] = STATE(138), - [sym_path_expression] = STATE(138), - [sym_comparison_constraint] = STATE(138), - [sym_unary_expression] = STATE(138), - [sym_binary_expression] = STATE(138), - [sym_default_expression] = STATE(138), - [sym_as_expression] = STATE(138), - [sym_identifier] = ACTIONS(297), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(299), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [56] = { - [sym__expression] = STATE(139), - [sym_literal] = STATE(139), - [sym_boolean] = STATE(142), - [sym_object] = STATE(139), - [sym_map_constraint] = STATE(139), - [sym_array] = STATE(139), - [sym_array_constraint] = STATE(139), - [sym_let_expression] = STATE(139), - [sym_function_expression] = STATE(139), - [sym_match_expression] = STATE(139), - [sym_import_expression] = STATE(139), - [sym_parenthesized_expression] = STATE(139), - [sym_call_expression] = STATE(139), - [sym_path_expression] = STATE(139), - [sym_comparison_constraint] = STATE(139), - [sym_unary_expression] = STATE(139), - [sym_binary_expression] = STATE(139), - [sym_default_expression] = STATE(139), - [sym_as_expression] = STATE(139), - [sym_identifier] = ACTIONS(301), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(303), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [57] = { - [sym__expression] = STATE(170), - [sym_literal] = STATE(170), - [sym_boolean] = STATE(142), - [sym_object] = STATE(170), - [sym_map_constraint] = STATE(170), - [sym_array] = STATE(170), - [sym_array_constraint] = STATE(170), - [sym_let_expression] = STATE(170), - [sym_function_expression] = STATE(170), - [sym_match_expression] = STATE(170), - [sym_import_expression] = STATE(170), - [sym_parenthesized_expression] = STATE(170), - [sym_call_expression] = STATE(170), - [sym_path_expression] = STATE(170), - [sym_comparison_constraint] = STATE(170), - [sym_unary_expression] = STATE(170), - [sym_binary_expression] = STATE(170), - [sym_default_expression] = STATE(170), - [sym_as_expression] = STATE(170), - [sym_identifier] = ACTIONS(305), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(307), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [58] = { - [sym__expression] = STATE(140), - [sym_literal] = STATE(140), - [sym_boolean] = STATE(142), - [sym_object] = STATE(140), - [sym_map_constraint] = STATE(140), - [sym_array] = STATE(140), - [sym_array_constraint] = STATE(140), - [sym_let_expression] = STATE(140), - [sym_function_expression] = STATE(140), - [sym_match_expression] = STATE(140), - [sym_import_expression] = STATE(140), - [sym_parenthesized_expression] = STATE(140), - [sym_call_expression] = STATE(140), - [sym_path_expression] = STATE(140), - [sym_comparison_constraint] = STATE(140), - [sym_unary_expression] = STATE(140), - [sym_binary_expression] = STATE(140), - [sym_default_expression] = STATE(140), - [sym_as_expression] = STATE(140), - [sym_identifier] = ACTIONS(309), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(311), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [59] = { - [sym__expression] = STATE(171), - [sym_literal] = STATE(171), - [sym_boolean] = STATE(142), - [sym_object] = STATE(171), - [sym_map_constraint] = STATE(171), - [sym_array] = STATE(171), - [sym_array_constraint] = STATE(171), - [sym_let_expression] = STATE(171), - [sym_function_expression] = STATE(171), - [sym_match_expression] = STATE(171), - [sym_import_expression] = STATE(171), - [sym_parenthesized_expression] = STATE(171), - [sym_call_expression] = STATE(171), - [sym_path_expression] = STATE(171), - [sym_comparison_constraint] = STATE(171), - [sym_unary_expression] = STATE(171), - [sym_binary_expression] = STATE(171), - [sym_default_expression] = STATE(171), - [sym_as_expression] = STATE(171), - [sym_identifier] = ACTIONS(313), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(315), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [60] = { - [sym__expression] = STATE(172), - [sym_literal] = STATE(172), - [sym_boolean] = STATE(142), - [sym_object] = STATE(172), - [sym_map_constraint] = STATE(172), - [sym_array] = STATE(172), - [sym_array_constraint] = STATE(172), - [sym_let_expression] = STATE(172), - [sym_function_expression] = STATE(172), - [sym_match_expression] = STATE(172), - [sym_import_expression] = STATE(172), - [sym_parenthesized_expression] = STATE(172), - [sym_call_expression] = STATE(172), - [sym_path_expression] = STATE(172), - [sym_comparison_constraint] = STATE(172), - [sym_unary_expression] = STATE(172), - [sym_binary_expression] = STATE(172), - [sym_default_expression] = STATE(172), - [sym_as_expression] = STATE(172), - [sym_identifier] = ACTIONS(317), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(319), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [61] = { - [sym__expression] = STATE(149), - [sym_literal] = STATE(149), - [sym_boolean] = STATE(142), - [sym_object] = STATE(149), - [sym_map_constraint] = STATE(149), - [sym_array] = STATE(149), - [sym_array_constraint] = STATE(149), - [sym_let_expression] = STATE(149), - [sym_function_expression] = STATE(149), - [sym_match_expression] = STATE(149), - [sym_import_expression] = STATE(149), - [sym_parenthesized_expression] = STATE(149), - [sym_call_expression] = STATE(149), - [sym_path_expression] = STATE(149), - [sym_comparison_constraint] = STATE(149), - [sym_unary_expression] = STATE(149), - [sym_binary_expression] = STATE(149), - [sym_default_expression] = STATE(149), - [sym_as_expression] = STATE(149), - [sym_identifier] = ACTIONS(321), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(323), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [62] = { - [sym__expression] = STATE(144), - [sym_literal] = STATE(144), - [sym_boolean] = STATE(142), - [sym_object] = STATE(144), - [sym_map_constraint] = STATE(144), - [sym_array] = STATE(144), - [sym_array_constraint] = STATE(144), - [sym_let_expression] = STATE(144), - [sym_function_expression] = STATE(144), - [sym_match_expression] = STATE(144), - [sym_import_expression] = STATE(144), - [sym_parenthesized_expression] = STATE(144), - [sym_call_expression] = STATE(144), - [sym_path_expression] = STATE(144), - [sym_comparison_constraint] = STATE(144), - [sym_unary_expression] = STATE(144), - [sym_binary_expression] = STATE(144), - [sym_default_expression] = STATE(144), - [sym_as_expression] = STATE(144), - [sym_identifier] = ACTIONS(325), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(327), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [63] = { - [sym__expression] = STATE(103), - [sym_literal] = STATE(103), - [sym_boolean] = STATE(112), - [sym_object] = STATE(103), - [sym_map_constraint] = STATE(103), - [sym_array] = STATE(103), - [sym_array_constraint] = STATE(103), - [sym_let_expression] = STATE(103), - [sym_function_expression] = STATE(103), - [sym_match_expression] = STATE(103), - [sym_import_expression] = STATE(103), - [sym_parenthesized_expression] = STATE(103), - [sym_call_expression] = STATE(103), - [sym_path_expression] = STATE(103), - [sym_comparison_constraint] = STATE(103), - [sym_unary_expression] = STATE(103), - [sym_binary_expression] = STATE(103), - [sym_default_expression] = STATE(103), - [sym_as_expression] = STATE(103), - [sym_identifier] = ACTIONS(329), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(331), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [64] = { - [sym__expression] = STATE(147), - [sym_literal] = STATE(147), - [sym_boolean] = STATE(142), - [sym_object] = STATE(147), - [sym_map_constraint] = STATE(147), - [sym_array] = STATE(147), - [sym_array_constraint] = STATE(147), - [sym_let_expression] = STATE(147), - [sym_function_expression] = STATE(147), - [sym_match_expression] = STATE(147), - [sym_import_expression] = STATE(147), - [sym_parenthesized_expression] = STATE(147), - [sym_call_expression] = STATE(147), - [sym_path_expression] = STATE(147), - [sym_comparison_constraint] = STATE(147), - [sym_unary_expression] = STATE(147), - [sym_binary_expression] = STATE(147), - [sym_default_expression] = STATE(147), - [sym_as_expression] = STATE(147), - [sym_identifier] = ACTIONS(333), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(335), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [65] = { - [sym__expression] = STATE(99), - [sym_literal] = STATE(99), - [sym_boolean] = STATE(112), - [sym_object] = STATE(99), - [sym_map_constraint] = STATE(99), - [sym_array] = STATE(99), - [sym_array_constraint] = STATE(99), - [sym_let_expression] = STATE(99), - [sym_function_expression] = STATE(99), - [sym_match_expression] = STATE(99), - [sym_import_expression] = STATE(99), - [sym_parenthesized_expression] = STATE(99), - [sym_call_expression] = STATE(99), - [sym_path_expression] = STATE(99), - [sym_comparison_constraint] = STATE(99), - [sym_unary_expression] = STATE(99), - [sym_binary_expression] = STATE(99), - [sym_default_expression] = STATE(99), - [sym_as_expression] = STATE(99), - [sym_identifier] = ACTIONS(337), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(339), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [66] = { - [sym__expression] = STATE(151), - [sym_literal] = STATE(151), - [sym_boolean] = STATE(142), - [sym_object] = STATE(151), - [sym_map_constraint] = STATE(151), - [sym_array] = STATE(151), - [sym_array_constraint] = STATE(151), - [sym_let_expression] = STATE(151), - [sym_function_expression] = STATE(151), - [sym_match_expression] = STATE(151), - [sym_import_expression] = STATE(151), - [sym_parenthesized_expression] = STATE(151), - [sym_call_expression] = STATE(151), - [sym_path_expression] = STATE(151), - [sym_comparison_constraint] = STATE(151), - [sym_unary_expression] = STATE(151), - [sym_binary_expression] = STATE(151), - [sym_default_expression] = STATE(151), - [sym_as_expression] = STATE(151), - [sym_identifier] = ACTIONS(341), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(343), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [67] = { - [sym__expression] = STATE(166), - [sym_literal] = STATE(166), - [sym_boolean] = STATE(142), - [sym_object] = STATE(166), - [sym_map_constraint] = STATE(166), - [sym_array] = STATE(166), - [sym_array_constraint] = STATE(166), - [sym_let_expression] = STATE(166), - [sym_function_expression] = STATE(166), - [sym_match_expression] = STATE(166), - [sym_import_expression] = STATE(166), - [sym_parenthesized_expression] = STATE(166), - [sym_call_expression] = STATE(166), - [sym_path_expression] = STATE(166), - [sym_comparison_constraint] = STATE(166), - [sym_unary_expression] = STATE(166), - [sym_binary_expression] = STATE(166), - [sym_default_expression] = STATE(166), - [sym_as_expression] = STATE(166), - [sym_identifier] = ACTIONS(345), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(347), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [68] = { - [sym__expression] = STATE(101), - [sym_literal] = STATE(101), - [sym_boolean] = STATE(112), - [sym_object] = STATE(101), - [sym_map_constraint] = STATE(101), - [sym_array] = STATE(101), - [sym_array_constraint] = STATE(101), - [sym_let_expression] = STATE(101), - [sym_function_expression] = STATE(101), - [sym_match_expression] = STATE(101), - [sym_import_expression] = STATE(101), - [sym_parenthesized_expression] = STATE(101), - [sym_call_expression] = STATE(101), - [sym_path_expression] = STATE(101), - [sym_comparison_constraint] = STATE(101), - [sym_unary_expression] = STATE(101), - [sym_binary_expression] = STATE(101), - [sym_default_expression] = STATE(101), - [sym_as_expression] = STATE(101), - [sym_identifier] = ACTIONS(349), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(351), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, - [69] = { - [sym__expression] = STATE(150), - [sym_literal] = STATE(150), - [sym_boolean] = STATE(142), - [sym_object] = STATE(150), - [sym_map_constraint] = STATE(150), - [sym_array] = STATE(150), - [sym_array_constraint] = STATE(150), - [sym_let_expression] = STATE(150), - [sym_function_expression] = STATE(150), - [sym_match_expression] = STATE(150), - [sym_import_expression] = STATE(150), - [sym_parenthesized_expression] = STATE(150), - [sym_call_expression] = STATE(150), - [sym_path_expression] = STATE(150), - [sym_comparison_constraint] = STATE(150), - [sym_unary_expression] = STATE(150), - [sym_binary_expression] = STATE(150), - [sym_default_expression] = STATE(150), - [sym_as_expression] = STATE(150), - [sym_identifier] = ACTIONS(353), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(355), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [70] = { - [sym__expression] = STATE(152), - [sym_literal] = STATE(152), - [sym_boolean] = STATE(142), - [sym_object] = STATE(152), - [sym_map_constraint] = STATE(152), - [sym_array] = STATE(152), - [sym_array_constraint] = STATE(152), - [sym_let_expression] = STATE(152), - [sym_function_expression] = STATE(152), - [sym_match_expression] = STATE(152), - [sym_import_expression] = STATE(152), - [sym_parenthesized_expression] = STATE(152), - [sym_call_expression] = STATE(152), - [sym_path_expression] = STATE(152), - [sym_comparison_constraint] = STATE(152), - [sym_unary_expression] = STATE(152), - [sym_binary_expression] = STATE(152), - [sym_default_expression] = STATE(152), - [sym_as_expression] = STATE(152), - [sym_identifier] = ACTIONS(357), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(83), - [anon_sym_false] = ACTIONS(83), - [sym_string] = ACTIONS(85), - [sym_integer] = ACTIONS(87), - [sym_float] = ACTIONS(85), - [sym_regex_literal] = ACTIONS(359), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_match] = ACTIONS(101), - [anon_sym_import] = ACTIONS(105), - [anon_sym_GT] = ACTIONS(107), - [anon_sym_GT_EQ] = ACTIONS(109), - [anon_sym_LT] = ACTIONS(107), - [anon_sym_LT_EQ] = ACTIONS(109), - [anon_sym_DASH] = ACTIONS(111), - [anon_sym_BANG] = ACTIONS(111), - }, - [71] = { - [sym__expression] = STATE(100), - [sym_literal] = STATE(100), - [sym_boolean] = STATE(112), - [sym_object] = STATE(100), - [sym_map_constraint] = STATE(100), - [sym_array] = STATE(100), - [sym_array_constraint] = STATE(100), - [sym_let_expression] = STATE(100), - [sym_function_expression] = STATE(100), - [sym_match_expression] = STATE(100), - [sym_import_expression] = STATE(100), - [sym_parenthesized_expression] = STATE(100), - [sym_call_expression] = STATE(100), - [sym_path_expression] = STATE(100), - [sym_comparison_constraint] = STATE(100), - [sym_unary_expression] = STATE(100), - [sym_binary_expression] = STATE(100), - [sym_default_expression] = STATE(100), - [sym_as_expression] = STATE(100), - [sym_identifier] = ACTIONS(361), - [sym_comment] = ACTIONS(3), - [anon_sym_true] = ACTIONS(9), - [anon_sym_false] = ACTIONS(9), - [sym_string] = ACTIONS(11), - [sym_integer] = ACTIONS(13), - [sym_float] = ACTIONS(11), - [sym_regex_literal] = ACTIONS(363), - [anon_sym_LBRACE] = ACTIONS(17), - [anon_sym_LBRACK] = ACTIONS(19), - [anon_sym_let] = ACTIONS(21), - [anon_sym_LPAREN] = ACTIONS(23), - [anon_sym_match] = ACTIONS(25), - [anon_sym_import] = ACTIONS(27), - [anon_sym_GT] = ACTIONS(29), - [anon_sym_GT_EQ] = ACTIONS(31), - [anon_sym_LT] = ACTIONS(29), - [anon_sym_LT_EQ] = ACTIONS(31), - [anon_sym_DASH] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(33), - }, }; static const uint16_t ts_small_parse_table[] = { - [0] = 6, + [0] = 17, ACTIONS(3), 1, sym_comment, - ACTIONS(369), 1, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(181), 1, + sym_identifier, + ACTIONS(183), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(146), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [74] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(185), 1, + sym_identifier, + ACTIONS(187), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(158), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [148] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(189), 1, + sym_identifier, + ACTIONS(191), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(104), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [222] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(149), 1, + sym_identifier, + ACTIONS(151), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(168), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [296] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(193), 1, + sym_identifier, + ACTIONS(195), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(182), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [370] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(197), 1, + sym_identifier, + ACTIONS(199), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(175), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [444] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(201), 1, + sym_identifier, + ACTIONS(203), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(171), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [518] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(205), 1, + sym_identifier, + ACTIONS(207), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(76), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [592] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(209), 1, + sym_identifier, + ACTIONS(211), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(123), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [666] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(213), 1, + sym_identifier, + ACTIONS(215), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(127), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [740] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(217), 1, + sym_identifier, + ACTIONS(219), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(131), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [814] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(221), 1, + sym_identifier, + ACTIONS(223), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(137), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [888] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(225), 1, + sym_identifier, + ACTIONS(227), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(117), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [962] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(229), 1, + sym_identifier, + ACTIONS(231), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(181), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1036] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(233), 1, + sym_identifier, + ACTIONS(235), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(93), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1110] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(237), 1, + sym_identifier, + ACTIONS(239), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(138), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1184] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(241), 1, + sym_identifier, + ACTIONS(243), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(173), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1258] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(245), 1, + sym_identifier, + ACTIONS(247), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(77), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1332] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(249), 1, + sym_identifier, + ACTIONS(251), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(78), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1406] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(253), 1, + sym_identifier, + ACTIONS(255), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(79), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1480] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(257), 1, + sym_identifier, + ACTIONS(259), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(80), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1554] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(261), 1, + sym_identifier, + ACTIONS(263), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(81), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1628] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(265), 1, + sym_identifier, + ACTIONS(267), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(82), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1702] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(269), 1, + sym_identifier, + ACTIONS(271), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(83), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1776] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(273), 1, + sym_identifier, + ACTIONS(275), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(84), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1850] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(277), 1, + sym_identifier, + ACTIONS(279), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(85), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1924] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(281), 1, + sym_identifier, + ACTIONS(283), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(86), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [1998] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(285), 1, + sym_identifier, + ACTIONS(287), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(87), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2072] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(289), 1, + sym_identifier, + ACTIONS(291), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(141), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2146] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(293), 1, + sym_identifier, + ACTIONS(295), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(142), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2220] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(297), 1, + sym_identifier, + ACTIONS(299), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(143), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2294] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(301), 1, + sym_identifier, + ACTIONS(303), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(144), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2368] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(305), 1, + sym_identifier, + ACTIONS(307), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(176), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2442] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(309), 1, + sym_identifier, + ACTIONS(311), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(145), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2516] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(313), 1, + sym_identifier, + ACTIONS(315), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(183), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2590] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(317), 1, + sym_identifier, + ACTIONS(319), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(178), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2664] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(321), 1, + sym_identifier, + ACTIONS(323), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(170), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2738] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(325), 1, + sym_identifier, + ACTIONS(327), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(147), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2812] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(329), 1, + sym_identifier, + ACTIONS(331), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(157), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2886] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(333), 1, + sym_identifier, + ACTIONS(335), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(148), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [2960] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(337), 1, + sym_identifier, + ACTIONS(339), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(101), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [3034] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(341), 1, + sym_identifier, + ACTIONS(343), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(151), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [3108] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(345), 1, + sym_identifier, + ACTIONS(347), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(172), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [3182] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(349), 1, + sym_identifier, + ACTIONS(351), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(103), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [3256] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(353), 1, + sym_identifier, + ACTIONS(355), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(106), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [3330] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(357), 1, + sym_identifier, + ACTIONS(359), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(152), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [3404] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(87), 1, + sym_integer, + ACTIONS(91), 1, + anon_sym_LBRACE, + ACTIONS(95), 1, + anon_sym_LBRACK, + ACTIONS(97), 1, + anon_sym_let, + ACTIONS(99), 1, + anon_sym_LPAREN, + ACTIONS(101), 1, + anon_sym_match, + ACTIONS(105), 1, + anon_sym_import, + ACTIONS(361), 1, + sym_identifier, + ACTIONS(363), 1, + sym_regex_literal, + STATE(150), 1, + sym_boolean, + ACTIONS(83), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(85), 2, + sym_string, + sym_float, + ACTIONS(107), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(109), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(111), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(161), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [3478] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + sym_integer, + ACTIONS(17), 1, + anon_sym_LBRACE, + ACTIONS(19), 1, + anon_sym_LBRACK, + ACTIONS(21), 1, + anon_sym_let, + ACTIONS(23), 1, + anon_sym_LPAREN, + ACTIONS(25), 1, + anon_sym_match, + ACTIONS(27), 1, + anon_sym_import, + ACTIONS(365), 1, + sym_identifier, + ACTIONS(367), 1, + sym_regex_literal, + STATE(118), 1, + sym_boolean, + ACTIONS(9), 2, + anon_sym_true, + anon_sym_false, + ACTIONS(11), 2, + sym_string, + sym_float, + ACTIONS(29), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(31), 2, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + ACTIONS(33), 2, + anon_sym_DASH, + anon_sym_BANG, + STATE(102), 18, + sym__expression, + sym_literal, + sym_object, + sym_map_constraint, + sym_array, + sym_array_constraint, + sym_let_expression, + sym_function_expression, + sym_match_expression, + sym_import_expression, + sym_parenthesized_expression, + sym_call_expression, + sym_path_expression, + sym_comparison_constraint, + sym_unary_expression, + sym_binary_expression, + sym_default_expression, + sym_as_expression, + [3552] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(373), 1, anon_sym_EQ, - ACTIONS(371), 1, + ACTIONS(375), 1, anon_sym_DOT, - STATE(192), 1, + STATE(221), 1, aux_sym_field_path_repeat1, - ACTIONS(367), 15, + ACTIONS(371), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -4675,7 +5522,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP, anon_sym_default, anon_sym_as, - ACTIONS(365), 18, + ACTIONS(369), 18, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -4694,46 +5541,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [50] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(375), 15, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_GT, - anon_sym_LT, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(373), 19, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_DOT, - anon_sym_LBRACK, - anon_sym_LPAREN, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - [92] = 3, + [3602] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(379), 15, @@ -4772,7 +5580,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [134] = 3, + [3644] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(383), 15, @@ -4811,399 +5619,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [176] = 3, + [3686] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(387), 15, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_GT, - anon_sym_LT, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(385), 19, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, + ACTIONS(389), 1, anon_sym_DOT, - anon_sym_LBRACK, - anon_sym_LPAREN, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - [218] = 10, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, + ACTIONS(391), 1, anon_sym_LPAREN, ACTIONS(397), 1, anon_sym_DASH, ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(391), 13, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_GT, - anon_sym_LT, - anon_sym_BANG, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(389), 14, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - anon_sym_GT_EQ, - anon_sym_LT_EQ, anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_SLASH_SLASH, - [274] = 7, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(391), 14, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_GT, - anon_sym_LT, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(389), 16, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_SLASH_SLASH, - [324] = 13, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, ACTIONS(401), 1, - anon_sym_PLUS, + anon_sym_AMP_AMP, ACTIONS(403), 1, - anon_sym_STAR, + anon_sym_PLUS_PLUS, ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, anon_sym_SLASH, ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(407), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(409), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(389), 9, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - anon_sym_PIPE_PIPE, - anon_sym_SLASH_SLASH, - ACTIONS(391), 11, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_BANG, anon_sym_AMP, - anon_sym_default, - anon_sym_as, - [386] = 12, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(407), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(409), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(389), 10, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_SLASH_SLASH, - ACTIONS(391), 11, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_BANG, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - [446] = 9, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(391), 13, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_GT, - anon_sym_LT, - anon_sym_BANG, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(389), 15, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_SLASH_SLASH, - [500] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(391), 15, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_GT, - anon_sym_LT, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(389), 17, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - [546] = 14, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(411), 1, - anon_sym_AMP_AMP, ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(407), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(409), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(389), 8, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, anon_sym_SLASH_SLASH, - ACTIONS(391), 11, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_BANG, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - [610] = 15, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(407), 2, + anon_sym_default, + ACTIONS(417), 1, + anon_sym_as, + ACTIONS(393), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(409), 4, + ACTIONS(395), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(389), 8, + ACTIONS(385), 7, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5211,8 +5664,7 @@ static const uint16_t ts_small_parse_table[] = { sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, - anon_sym_SLASH_SLASH, - ACTIONS(391), 10, + ACTIONS(387), 8, anon_sym_true, anon_sym_false, sym_integer, @@ -5221,44 +5673,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - anon_sym_default, - anon_sym_as, - [676] = 17, + [3758] = 10, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, + ACTIONS(389), 1, anon_sym_DOT, - ACTIONS(395), 1, + ACTIONS(391), 1, anon_sym_LPAREN, ACTIONS(397), 1, anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, ACTIONS(403), 1, - anon_sym_STAR, + anon_sym_PLUS_PLUS, ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, anon_sym_SLASH, - ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(421), 1, - anon_sym_SLASH_SLASH, - ACTIONS(423), 1, - anon_sym_default, - ACTIONS(407), 2, + ACTIONS(421), 13, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, anon_sym_GT, anon_sym_LT, - ACTIONS(409), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(417), 7, + anon_sym_BANG, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(419), 14, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5266,52 +5712,84 @@ static const uint16_t ts_small_parse_table[] = { sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_SLASH_SLASH, + [3814] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(421), 14, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_GT, + anon_sym_LT, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(419), 16, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_SLASH_SLASH, + [3864] = 13, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(401), 1, + anon_sym_AMP_AMP, + ACTIONS(403), 1, + anon_sym_PLUS_PLUS, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(393), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(395), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, ACTIONS(419), 9, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_BANG, - anon_sym_as, - [746] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(421), 1, - anon_sym_SLASH_SLASH, - ACTIONS(423), 1, - anon_sym_default, - ACTIONS(407), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(409), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(425), 7, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5319,7 +5797,9 @@ static const uint16_t ts_small_parse_table[] = { sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, - ACTIONS(427), 9, + anon_sym_PIPE_PIPE, + anon_sym_SLASH_SLASH, + ACTIONS(421), 11, anon_sym_true, anon_sym_false, sym_integer, @@ -5328,45 +5808,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, + anon_sym_AMP, + anon_sym_default, anon_sym_as, - [816] = 18, + [3926] = 12, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, + ACTIONS(389), 1, anon_sym_DOT, - ACTIONS(395), 1, + ACTIONS(391), 1, anon_sym_LPAREN, ACTIONS(397), 1, anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, ACTIONS(403), 1, - anon_sym_STAR, + anon_sym_PLUS_PLUS, ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, anon_sym_SLASH, - ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(421), 1, - anon_sym_SLASH_SLASH, - ACTIONS(423), 1, - anon_sym_default, - ACTIONS(433), 1, - anon_sym_as, - ACTIONS(407), 2, + ACTIONS(393), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(409), 4, + ACTIONS(395), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(429), 7, + ACTIONS(419), 10, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5374,7 +5844,10 @@ static const uint16_t ts_small_parse_table[] = { sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, - ACTIONS(431), 8, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_SLASH_SLASH, + ACTIONS(421), 11, anon_sym_true, anon_sym_false, sym_integer, @@ -5383,7 +5856,357 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - [888] = 3, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + [3986] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(421), 13, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_GT, + anon_sym_LT, + anon_sym_BANG, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(419), 15, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_SLASH_SLASH, + [4040] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(421), 15, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_GT, + anon_sym_LT, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(419), 17, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + [4086] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(399), 1, + anon_sym_PIPE_PIPE, + ACTIONS(401), 1, + anon_sym_AMP_AMP, + ACTIONS(403), 1, + anon_sym_PLUS_PLUS, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(393), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(395), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(419), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_SLASH_SLASH, + ACTIONS(421), 11, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + [4150] = 15, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(399), 1, + anon_sym_PIPE_PIPE, + ACTIONS(401), 1, + anon_sym_AMP_AMP, + ACTIONS(403), 1, + anon_sym_PLUS_PLUS, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(411), 1, + anon_sym_AMP, + ACTIONS(393), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(395), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(419), 8, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_SLASH_SLASH, + ACTIONS(421), 10, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + anon_sym_default, + anon_sym_as, + [4216] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(399), 1, + anon_sym_PIPE_PIPE, + ACTIONS(401), 1, + anon_sym_AMP_AMP, + ACTIONS(403), 1, + anon_sym_PLUS_PLUS, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(411), 1, + anon_sym_AMP, + ACTIONS(413), 1, + anon_sym_SLASH_SLASH, + ACTIONS(415), 1, + anon_sym_default, + ACTIONS(393), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(395), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(423), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + ACTIONS(425), 9, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + anon_sym_as, + [4286] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(399), 1, + anon_sym_PIPE_PIPE, + ACTIONS(401), 1, + anon_sym_AMP_AMP, + ACTIONS(403), 1, + anon_sym_PLUS_PLUS, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(411), 1, + anon_sym_AMP, + ACTIONS(413), 1, + anon_sym_SLASH_SLASH, + ACTIONS(415), 1, + anon_sym_default, + ACTIONS(393), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(395), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(427), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + ACTIONS(429), 9, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + anon_sym_as, + [4356] = 18, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(399), 1, + anon_sym_PIPE_PIPE, + ACTIONS(401), 1, + anon_sym_AMP_AMP, + ACTIONS(403), 1, + anon_sym_PLUS_PLUS, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(411), 1, + anon_sym_AMP, + ACTIONS(413), 1, + anon_sym_SLASH_SLASH, + ACTIONS(415), 1, + anon_sym_default, + ACTIONS(417), 1, + anon_sym_as, + ACTIONS(393), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(395), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(431), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + ACTIONS(433), 8, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + [4428] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(437), 15, @@ -5422,7 +6245,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [930] = 3, + [4470] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(441), 15, @@ -5461,7 +6284,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [972] = 3, + [4512] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(445), 15, @@ -5500,7 +6323,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1014] = 3, + [4554] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(449), 15, @@ -5539,44 +6362,83 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1056] = 18, + [4596] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, + ACTIONS(453), 15, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_GT, + anon_sym_LT, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(451), 19, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, anon_sym_DOT, - ACTIONS(395), 1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + [4638] = 18, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, anon_sym_LPAREN, ACTIONS(397), 1, anon_sym_DASH, ACTIONS(399), 1, - anon_sym_PLUS_PLUS, + anon_sym_PIPE_PIPE, ACTIONS(401), 1, - anon_sym_PLUS, + anon_sym_AMP_AMP, ACTIONS(403), 1, - anon_sym_STAR, + anon_sym_PLUS_PLUS, ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, anon_sym_SLASH, ACTIONS(411), 1, - anon_sym_AMP_AMP, + anon_sym_AMP, ACTIONS(413), 1, - anon_sym_PIPE_PIPE, + anon_sym_SLASH_SLASH, ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(421), 1, - anon_sym_SLASH_SLASH, - ACTIONS(423), 1, anon_sym_default, - ACTIONS(433), 1, + ACTIONS(417), 1, anon_sym_as, - ACTIONS(407), 2, + ACTIONS(393), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(409), 4, + ACTIONS(395), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(451), 7, + ACTIONS(455), 7, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5584,7 +6446,7 @@ static const uint16_t ts_small_parse_table[] = { sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, - ACTIONS(453), 8, + ACTIONS(457), 8, anon_sym_true, anon_sym_false, sym_integer, @@ -5593,46 +6455,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - [1128] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(457), 15, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_GT, - anon_sym_LT, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(455), 19, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_DOT, - anon_sym_LBRACK, - anon_sym_LPAREN, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - [1170] = 3, + [4710] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(461), 15, @@ -5671,7 +6494,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1212] = 3, + [4752] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(465), 15, @@ -5710,7 +6533,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1254] = 3, + [4794] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(469), 15, @@ -5749,7 +6572,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1296] = 3, + [4836] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(473), 15, @@ -5788,7 +6611,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1338] = 3, + [4878] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(477), 15, @@ -5827,52 +6650,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1380] = 18, + [4920] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(421), 1, - anon_sym_SLASH_SLASH, - ACTIONS(423), 1, - anon_sym_default, - ACTIONS(433), 1, - anon_sym_as, - ACTIONS(407), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(409), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(479), 7, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - ACTIONS(481), 8, + ACTIONS(481), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -5880,14 +6661,37 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_let, anon_sym_match, anon_sym_import, + anon_sym_GT, + anon_sym_LT, anon_sym_BANG, - [1452] = 5, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(479), 19, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_DOT, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + [4962] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, ACTIONS(485), 15, anon_sym_true, anon_sym_false, @@ -5904,14 +6708,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP, anon_sym_default, anon_sym_as, - ACTIONS(483), 17, + ACTIONS(483), 19, ts_builtin_sym_end, anon_sym_SEMI, sym_string, sym_float, sym_regex_literal, anon_sym_LBRACE, + anon_sym_DOT, anon_sym_LBRACK, + anon_sym_LPAREN, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH, @@ -5922,39 +6728,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1498] = 18, + [5004] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, + ACTIONS(389), 1, anon_sym_DOT, - ACTIONS(395), 1, + ACTIONS(391), 1, anon_sym_LPAREN, ACTIONS(397), 1, anon_sym_DASH, ACTIONS(399), 1, - anon_sym_PLUS_PLUS, + anon_sym_PIPE_PIPE, ACTIONS(401), 1, - anon_sym_PLUS, + anon_sym_AMP_AMP, ACTIONS(403), 1, - anon_sym_STAR, + anon_sym_PLUS_PLUS, ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, anon_sym_SLASH, ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(415), 1, anon_sym_AMP, - ACTIONS(421), 1, + ACTIONS(413), 1, anon_sym_SLASH_SLASH, - ACTIONS(423), 1, + ACTIONS(415), 1, anon_sym_default, - ACTIONS(433), 1, + ACTIONS(417), 1, anon_sym_as, - ACTIONS(407), 2, + ACTIONS(393), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(409), 4, + ACTIONS(395), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, @@ -5976,44 +6782,85 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - [1570] = 18, + [5076] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, + ACTIONS(389), 1, anon_sym_DOT, - ACTIONS(395), 1, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(493), 15, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_GT, + anon_sym_LT, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(491), 17, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + [5122] = 18, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, anon_sym_LPAREN, ACTIONS(397), 1, anon_sym_DASH, ACTIONS(399), 1, - anon_sym_PLUS_PLUS, + anon_sym_PIPE_PIPE, ACTIONS(401), 1, - anon_sym_PLUS, + anon_sym_AMP_AMP, ACTIONS(403), 1, - anon_sym_STAR, + anon_sym_PLUS_PLUS, ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, anon_sym_SLASH, ACTIONS(411), 1, - anon_sym_AMP_AMP, + anon_sym_AMP, ACTIONS(413), 1, - anon_sym_PIPE_PIPE, + anon_sym_SLASH_SLASH, ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(421), 1, - anon_sym_SLASH_SLASH, - ACTIONS(423), 1, anon_sym_default, - ACTIONS(433), 1, + ACTIONS(417), 1, anon_sym_as, - ACTIONS(407), 2, + ACTIONS(393), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(409), 4, + ACTIONS(395), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(491), 7, + ACTIONS(495), 7, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -6021,7 +6868,7 @@ static const uint16_t ts_small_parse_table[] = { sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, - ACTIONS(493), 8, + ACTIONS(497), 8, anon_sym_true, anon_sym_false, sym_integer, @@ -6030,30 +6877,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - [1642] = 5, + [5194] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, + ACTIONS(389), 1, anon_sym_DOT, - ACTIONS(395), 1, + ACTIONS(391), 1, anon_sym_LPAREN, - ACTIONS(497), 15, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(399), 1, + anon_sym_PIPE_PIPE, + ACTIONS(401), 1, + anon_sym_AMP_AMP, + ACTIONS(403), 1, + anon_sym_PLUS_PLUS, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(411), 1, + anon_sym_AMP, + ACTIONS(413), 1, + anon_sym_SLASH_SLASH, + ACTIONS(415), 1, + anon_sym_default, + ACTIONS(417), 1, + anon_sym_as, + ACTIONS(393), 2, anon_sym_GT, anon_sym_LT, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(495), 17, + ACTIONS(395), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(499), 7, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -6061,20 +6922,7 @@ static const uint16_t ts_small_parse_table[] = { sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - [1688] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(501), 15, + ACTIONS(501), 8, anon_sym_true, anon_sym_false, sym_integer, @@ -6082,35 +6930,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_let, anon_sym_match, anon_sym_import, - anon_sym_GT, - anon_sym_LT, anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - anon_sym_as, - ACTIONS(499), 19, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_DOT, - anon_sym_LBRACK, - anon_sym_LPAREN, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - [1730] = 3, + [5266] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(505), 15, @@ -6149,9 +6970,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1772] = 3, + [5308] = 5, ACTIONS(3), 1, sym_comment, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, ACTIONS(509), 15, anon_sym_true, anon_sym_false, @@ -6168,16 +6993,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP, anon_sym_default, anon_sym_as, - ACTIONS(507), 19, + ACTIONS(507), 17, ts_builtin_sym_end, anon_sym_SEMI, sym_string, sym_float, sym_regex_literal, anon_sym_LBRACE, - anon_sym_DOT, anon_sym_LBRACK, - anon_sym_LPAREN, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH, @@ -6188,52 +7011,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1814] = 18, + [5354] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(421), 1, - anon_sym_SLASH_SLASH, - ACTIONS(423), 1, - anon_sym_default, - ACTIONS(433), 1, - anon_sym_as, - ACTIONS(407), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(409), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(511), 7, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - ACTIONS(513), 8, + ACTIONS(513), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6241,8 +7022,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_let, anon_sym_match, anon_sym_import, + anon_sym_GT, + anon_sym_LT, anon_sym_BANG, - [1886] = 3, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(511), 19, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_DOT, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + [5396] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(517), 15, @@ -6281,7 +7089,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1928] = 3, + [5438] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(521), 15, @@ -6320,7 +7128,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [1970] = 3, + [5480] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(525), 15, @@ -6359,7 +7167,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [2012] = 3, + [5522] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(529), 15, @@ -6398,7 +7206,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [2054] = 3, + [5564] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(533), 15, @@ -6437,7 +7245,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [2096] = 3, + [5606] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(537), 15, @@ -6476,52 +7284,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [2138] = 18, + [5648] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, - anon_sym_DOT, - ACTIONS(395), 1, - anon_sym_LPAREN, - ACTIONS(397), 1, - anon_sym_DASH, - ACTIONS(399), 1, - anon_sym_PLUS_PLUS, - ACTIONS(401), 1, - anon_sym_PLUS, - ACTIONS(403), 1, - anon_sym_STAR, - ACTIONS(405), 1, - anon_sym_SLASH, - ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(415), 1, - anon_sym_AMP, - ACTIONS(421), 1, - anon_sym_SLASH_SLASH, - ACTIONS(423), 1, - anon_sym_default, - ACTIONS(433), 1, - anon_sym_as, - ACTIONS(407), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(409), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(539), 7, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - ACTIONS(541), 8, + ACTIONS(541), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6529,8 +7295,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_let, anon_sym_match, anon_sym_import, + anon_sym_GT, + anon_sym_LT, anon_sym_BANG, - [2210] = 3, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(539), 19, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_DOT, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + [5690] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(545), 15, @@ -6569,41 +7362,41 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [2252] = 19, + [5732] = 19, ACTIONS(3), 1, sym_comment, - ACTIONS(393), 1, + ACTIONS(389), 1, anon_sym_DOT, - ACTIONS(395), 1, + ACTIONS(391), 1, anon_sym_LPAREN, ACTIONS(397), 1, anon_sym_DASH, ACTIONS(399), 1, - anon_sym_PLUS_PLUS, + anon_sym_PIPE_PIPE, ACTIONS(401), 1, - anon_sym_PLUS, + anon_sym_AMP_AMP, ACTIONS(403), 1, - anon_sym_STAR, + anon_sym_PLUS_PLUS, ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, anon_sym_SLASH, ACTIONS(411), 1, - anon_sym_AMP_AMP, - ACTIONS(413), 1, - anon_sym_PIPE_PIPE, - ACTIONS(415), 1, anon_sym_AMP, - ACTIONS(421), 1, + ACTIONS(413), 1, anon_sym_SLASH_SLASH, - ACTIONS(423), 1, + ACTIONS(415), 1, anon_sym_default, - ACTIONS(433), 1, + ACTIONS(417), 1, anon_sym_as, ACTIONS(551), 1, anon_sym_SEMI, - ACTIONS(407), 2, + ACTIONS(393), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(409), 4, + ACTIONS(395), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, @@ -6624,25 +7417,89 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - [2326] = 3, + [5806] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(375), 5, + ACTIONS(389), 1, + anon_sym_DOT, + ACTIONS(391), 1, + anon_sym_LPAREN, + ACTIONS(397), 1, + anon_sym_DASH, + ACTIONS(399), 1, + anon_sym_PIPE_PIPE, + ACTIONS(401), 1, + anon_sym_AMP_AMP, + ACTIONS(403), 1, + anon_sym_PLUS_PLUS, + ACTIONS(405), 1, + anon_sym_PLUS, + ACTIONS(407), 1, + anon_sym_STAR, + ACTIONS(409), 1, + anon_sym_SLASH, + ACTIONS(411), 1, + anon_sym_AMP, + ACTIONS(413), 1, + anon_sym_SLASH_SLASH, + ACTIONS(415), 1, + anon_sym_default, + ACTIONS(417), 1, + anon_sym_as, + ACTIONS(393), 2, anon_sym_GT, anon_sym_LT, + ACTIONS(395), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(553), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + ACTIONS(555), 8, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + [5878] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(559), 15, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_GT, + anon_sym_LT, + anon_sym_BANG, anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(373), 21, + anon_sym_default, + anon_sym_as, + ACTIONS(557), 19, + ts_builtin_sym_end, anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, + anon_sym_LBRACK, anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH, @@ -6653,27 +7510,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2360] = 3, + [5920] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(437), 5, + ACTIONS(563), 15, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, anon_sym_GT, anon_sym_LT, + anon_sym_BANG, anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(435), 21, + anon_sym_default, + anon_sym_as, + ACTIONS(561), 19, + ts_builtin_sym_end, anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, anon_sym_LBRACE, - anon_sym_RBRACE, anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, + anon_sym_LBRACK, anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH, @@ -6684,575 +7549,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2394] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(449), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(447), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2428] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(451), 7, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - [2490] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(461), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(459), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2524] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(477), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(475), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2558] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(491), 7, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - [2620] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(501), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(499), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2654] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(509), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(507), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2688] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(539), 7, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - [2750] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(521), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(519), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2784] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(469), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(467), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2818] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(545), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(543), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2852] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(537), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(535), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2886] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(517), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(515), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [2920] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(487), 7, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - [2982] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(479), 7, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - [3044] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(457), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(455), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3078] = 3, + [5962] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(441), 5, @@ -7283,624 +7580,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH_SLASH, anon_sym_default, anon_sym_as, - [3112] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(425), 8, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_as, - [3172] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(417), 8, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_as, - [3232] = 14, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(389), 10, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3288] = 14, - ACTIONS(3), 1, - sym_comment, - ACTIONS(391), 1, - anon_sym_AMP, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(389), 10, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3344] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(391), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(389), 19, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3382] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(445), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(443), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3416] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(533), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(531), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3450] = 9, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(391), 3, - anon_sym_GT, - anon_sym_LT, - anon_sym_AMP, - ACTIONS(389), 17, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3496] = 12, - ACTIONS(3), 1, - sym_comment, - ACTIONS(391), 1, - anon_sym_AMP, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(389), 12, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3548] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(529), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(527), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3582] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(525), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(523), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3616] = 13, - ACTIONS(3), 1, - sym_comment, - ACTIONS(391), 1, - anon_sym_AMP, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(389), 11, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_PIPE_PIPE, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3670] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(505), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(503), 21, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DOT, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3704] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(497), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(495), 19, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3742] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(485), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(483), 19, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3780] = 7, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(391), 4, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_AMP, - ACTIONS(389), 18, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3822] = 10, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(391), 3, - anon_sym_GT, - anon_sym_LT, - anon_sym_AMP, - ACTIONS(389), 16, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_SLASH_SLASH, - anon_sym_default, - anon_sym_as, - [3870] = 3, + [5996] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(383), 5, @@ -7931,7 +7611,114 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH_SLASH, anon_sym_default, anon_sym_as, - [3904] = 3, + [6030] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(453), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(451), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6064] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(455), 7, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + [6126] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(461), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(459), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6160] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(379), 5, @@ -7962,16 +7749,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH_SLASH, anon_sym_default, anon_sym_as, - [3938] = 3, + [6194] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(465), 5, + ACTIONS(485), 5, anon_sym_GT, anon_sym_LT, anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(463), 21, + ACTIONS(483), 21, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7993,44 +7780,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH_SLASH, anon_sym_default, anon_sym_as, - [3972] = 17, + [6228] = 17, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, ACTIONS(565), 1, - anon_sym_AMP_AMP, + anon_sym_DOT, ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, + anon_sym_LPAREN, ACTIONS(573), 1, - anon_sym_SLASH, + anon_sym_DASH, ACTIONS(575), 1, - anon_sym_AMP, + anon_sym_PIPE_PIPE, ACTIONS(577), 1, - anon_sym_SLASH_SLASH, + anon_sym_AMP_AMP, ACTIONS(579), 1, - anon_sym_default, + anon_sym_PLUS_PLUS, ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, anon_sym_as, - ACTIONS(557), 2, + ACTIONS(569), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(559), 4, + ACTIONS(571), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(511), 7, + ACTIONS(499), 7, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -8038,16 +7825,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_RPAREN, anon_sym_COLON, - [4034] = 3, + [6290] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(387), 5, + ACTIONS(505), 5, anon_sym_GT, anon_sym_LT, anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(385), 21, + ACTIONS(503), 21, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -8069,7 +7856,359 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH_SLASH, anon_sym_default, anon_sym_as, - [4068] = 3, + [6324] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(517), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(515), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6358] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(533), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(531), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6392] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(553), 7, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + [6454] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(477), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(475), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6488] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(529), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(527), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6522] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(563), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(561), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6556] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(545), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(543), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6590] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(525), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(523), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6624] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(495), 7, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + [6686] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(487), 7, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + [6748] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(473), 5, @@ -8100,67 +8239,25 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH_SLASH, anon_sym_default, anon_sym_as, - [4102] = 19, + [6782] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(583), 1, - anon_sym_COMMA, - ACTIONS(585), 1, - anon_sym_RPAREN, - STATE(200), 1, - aux_sym_array_repeat1, - ACTIONS(557), 2, + ACTIONS(437), 5, anon_sym_GT, anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [4164] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(587), 1, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(435), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, anon_sym_COMMA, - ACTIONS(589), 1, + anon_sym_RBRACK, + anon_sym_LPAREN, anon_sym_RPAREN, - ACTIONS(592), 1, anon_sym_COLON, - ACTIONS(367), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(365), 14, - anon_sym_DOT, - anon_sym_LPAREN, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH, @@ -8173,257 +8270,1227 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH_SLASH, anon_sym_default, anon_sym_as, - [4200] = 19, + [6816] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, ACTIONS(565), 1, - anon_sym_AMP_AMP, + anon_sym_DOT, ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, + anon_sym_LPAREN, ACTIONS(573), 1, - anon_sym_SLASH, + anon_sym_DASH, ACTIONS(575), 1, - anon_sym_AMP, + anon_sym_PIPE_PIPE, ACTIONS(577), 1, - anon_sym_SLASH_SLASH, + anon_sym_AMP_AMP, ACTIONS(579), 1, - anon_sym_default, + anon_sym_PLUS_PLUS, ACTIONS(581), 1, - anon_sym_as, - ACTIONS(594), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(427), 8, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_COMMA, - ACTIONS(596), 1, anon_sym_RBRACK, - STATE(218), 1, - aux_sym_array_repeat1, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [4262] = 19, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(598), 1, - anon_sym_COMMA, - ACTIONS(600), 1, anon_sym_RPAREN, - STATE(209), 1, - aux_sym_array_repeat1, - ACTIONS(557), 2, + anon_sym_COLON, + anon_sym_as, + [6876] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(569), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(559), 4, + ACTIONS(571), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - [4324] = 19, + ACTIONS(423), 8, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_as, + [6936] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, ACTIONS(565), 1, - anon_sym_AMP_AMP, + anon_sym_DOT, ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, + anon_sym_LPAREN, ACTIONS(573), 1, - anon_sym_SLASH, + anon_sym_DASH, ACTIONS(575), 1, - anon_sym_AMP, + anon_sym_PIPE_PIPE, ACTIONS(577), 1, - anon_sym_SLASH_SLASH, + anon_sym_AMP_AMP, ACTIONS(579), 1, - anon_sym_default, + anon_sym_PLUS_PLUS, ACTIONS(581), 1, - anon_sym_as, - ACTIONS(602), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(419), 10, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [6992] = 14, + ACTIONS(3), 1, + sym_comment, + ACTIONS(421), 1, + anon_sym_AMP, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(419), 10, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7048] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(421), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(419), 19, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7086] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(421), 3, + anon_sym_GT, + anon_sym_LT, + anon_sym_AMP, + ACTIONS(419), 17, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7132] = 12, + ACTIONS(3), 1, + sym_comment, + ACTIONS(421), 1, + anon_sym_AMP, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(419), 12, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7184] = 13, + ACTIONS(3), 1, + sym_comment, + ACTIONS(421), 1, + anon_sym_AMP, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(419), 11, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_PIPE_PIPE, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7238] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(449), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(447), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7272] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(559), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(557), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7306] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(421), 4, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_AMP, + ACTIONS(419), 18, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7348] = 10, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(421), 3, + anon_sym_GT, + anon_sym_LT, + anon_sym_AMP, + ACTIONS(419), 16, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7396] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(537), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(535), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7430] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(521), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(519), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7464] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(469), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(467), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7498] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(513), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(511), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7532] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(509), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(507), 19, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7570] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(493), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(491), 19, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7608] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(541), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(539), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7642] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(465), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(463), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7676] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(385), 7, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_RPAREN, + anon_sym_COLON, + [7738] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(445), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(443), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7772] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(481), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(479), 21, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DOT, + anon_sym_COMMA, + anon_sym_RBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_COLON, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7806] = 19, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(595), 1, + anon_sym_COMMA, + ACTIONS(597), 1, + anon_sym_RPAREN, + STATE(198), 1, + aux_sym_array_repeat1, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [7868] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(599), 1, + anon_sym_COMMA, + ACTIONS(601), 1, + anon_sym_RPAREN, ACTIONS(604), 1, - anon_sym_RBRACK, - STATE(213), 1, - aux_sym_array_repeat1, - ACTIONS(557), 2, + anon_sym_COLON, + ACTIONS(371), 5, anon_sym_GT, anon_sym_LT, - ACTIONS(559), 4, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(369), 14, + anon_sym_DOT, + anon_sym_LPAREN, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_PIPE_PIPE, + anon_sym_AMP_AMP, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [7904] = 19, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(606), 1, + anon_sym_COMMA, + ACTIONS(608), 1, + anon_sym_RPAREN, + STATE(224), 1, + aux_sym_array_repeat1, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - [4386] = 17, + [7966] = 19, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, ACTIONS(565), 1, - anon_sym_AMP_AMP, + anon_sym_DOT, ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, + anon_sym_LPAREN, ACTIONS(573), 1, - anon_sym_SLASH, + anon_sym_DASH, ACTIONS(575), 1, - anon_sym_AMP, + anon_sym_PIPE_PIPE, ACTIONS(577), 1, - anon_sym_SLASH_SLASH, + anon_sym_AMP_AMP, ACTIONS(579), 1, - anon_sym_default, + anon_sym_PLUS_PLUS, ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, anon_sym_as, - ACTIONS(557), 2, + ACTIONS(610), 1, + anon_sym_COMMA, + ACTIONS(612), 1, + anon_sym_RBRACK, + STATE(217), 1, + aux_sym_array_repeat1, + ACTIONS(569), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(606), 3, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8028] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(614), 3, anon_sym_COMMA, anon_sym_RBRACK, anon_sym_RPAREN, - ACTIONS(559), 4, + ACTIONS(571), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - [4444] = 17, + [8086] = 19, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, ACTIONS(565), 1, - anon_sym_AMP_AMP, + anon_sym_DOT, ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, + anon_sym_LPAREN, ACTIONS(573), 1, - anon_sym_SLASH, + anon_sym_DASH, ACTIONS(575), 1, - anon_sym_AMP, + anon_sym_PIPE_PIPE, ACTIONS(577), 1, - anon_sym_SLASH_SLASH, + anon_sym_AMP_AMP, ACTIONS(579), 1, - anon_sym_default, + anon_sym_PLUS_PLUS, ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, anon_sym_as, - ACTIONS(557), 2, + ACTIONS(616), 1, + anon_sym_COMMA, + ACTIONS(618), 1, + anon_sym_RBRACK, + STATE(215), 1, + aux_sym_array_repeat1, + ACTIONS(569), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(608), 2, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8148] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(620), 2, anon_sym_SEMI, anon_sym_RBRACE, - ACTIONS(559), 4, + ACTIONS(571), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - [4501] = 17, + [8205] = 17, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, ACTIONS(565), 1, - anon_sym_AMP_AMP, + anon_sym_DOT, ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, + anon_sym_LPAREN, ACTIONS(573), 1, - anon_sym_SLASH, + anon_sym_DASH, ACTIONS(575), 1, - anon_sym_AMP, + anon_sym_PIPE_PIPE, ACTIONS(577), 1, - anon_sym_SLASH_SLASH, + anon_sym_AMP_AMP, ACTIONS(579), 1, - anon_sym_default, + anon_sym_PLUS_PLUS, ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, anon_sym_as, - ACTIONS(557), 2, + ACTIONS(569), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(610), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - ACTIONS(559), 4, + ACTIONS(622), 2, + anon_sym_SEMI, + anon_sym_RBRACE, + ACTIONS(571), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - [4558] = 4, + [8262] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(624), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8319] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(431), 2, + anon_sym_SEMI, + anon_sym_RBRACE, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8376] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(551), 1, @@ -8450,288 +9517,209 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_EQ, anon_sym_DASH, anon_sym_BANG, - [4589] = 18, + [8407] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(612), 1, - anon_sym_COMMA, - ACTIONS(614), 1, - anon_sym_RBRACK, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [4648] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(429), 2, - anon_sym_SEMI, - anon_sym_RBRACE, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [4705] = 18, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(616), 1, - anon_sym_COMMA, - ACTIONS(618), 1, - anon_sym_RBRACK, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [4764] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(620), 1, - anon_sym_LBRACE, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [4820] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(622), 1, - anon_sym_RBRACE, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [4876] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(624), 1, - anon_sym_RPAREN, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [4932] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, anon_sym_as, ACTIONS(626), 1, - anon_sym_RBRACE, - ACTIONS(557), 2, + anon_sym_COMMA, + ACTIONS(628), 1, + anon_sym_RBRACK, + ACTIONS(569), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(559), 4, + ACTIONS(571), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - [4988] = 3, + [8466] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(630), 9, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(630), 1, + anon_sym_COMMA, + ACTIONS(632), 1, + anon_sym_RBRACK, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8525] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(634), 1, + anon_sym_RPAREN, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8581] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(636), 1, + anon_sym_RBRACE, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8637] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(638), 1, + anon_sym_COLON, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8693] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(642), 9, anon_sym_true, anon_sym_false, sym_integer, @@ -8741,7 +9729,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_import, anon_sym_GT, anon_sym_LT, - ACTIONS(628), 11, + ACTIONS(640), 11, ts_builtin_sym_end, sym_string, sym_float, @@ -8753,832 +9741,996 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT_EQ, anon_sym_DASH, anon_sym_BANG, - [5016] = 17, + [8721] = 17, ACTIONS(3), 1, sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(632), 1, - anon_sym_RPAREN, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [5072] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, anon_sym_DOT, - ACTIONS(555), 1, - anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, - ACTIONS(573), 1, - anon_sym_SLASH, - ACTIONS(575), 1, - anon_sym_AMP, - ACTIONS(577), 1, - anon_sym_SLASH_SLASH, - ACTIONS(579), 1, - anon_sym_default, - ACTIONS(581), 1, - anon_sym_as, - ACTIONS(634), 1, - anon_sym_LBRACE, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [5128] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(553), 1, - anon_sym_DOT, - ACTIONS(555), 1, anon_sym_LPAREN, - ACTIONS(561), 1, - anon_sym_DASH, - ACTIONS(563), 1, - anon_sym_PIPE_PIPE, - ACTIONS(565), 1, - anon_sym_AMP_AMP, - ACTIONS(567), 1, - anon_sym_PLUS_PLUS, - ACTIONS(569), 1, - anon_sym_PLUS, - ACTIONS(571), 1, - anon_sym_STAR, ACTIONS(573), 1, - anon_sym_SLASH, + anon_sym_DASH, ACTIONS(575), 1, - anon_sym_AMP, + anon_sym_PIPE_PIPE, ACTIONS(577), 1, - anon_sym_SLASH_SLASH, + anon_sym_AMP_AMP, ACTIONS(579), 1, - anon_sym_default, + anon_sym_PLUS_PLUS, ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, anon_sym_as, - ACTIONS(636), 1, - anon_sym_COLON, - ACTIONS(557), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(559), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [5184] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(638), 1, - sym_identifier, - ACTIONS(640), 1, - anon_sym_in, - STATE(182), 1, - aux_sym_let_expression_repeat1, - STATE(231), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5203] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(638), 1, - sym_identifier, - ACTIONS(642), 1, - anon_sym_in, - STATE(182), 1, - aux_sym_let_expression_repeat1, - STATE(231), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5222] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(638), 1, - sym_identifier, ACTIONS(644), 1, - anon_sym_in, - STATE(179), 1, - aux_sym_let_expression_repeat1, - STATE(231), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5241] = 6, + anon_sym_LBRACE, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8777] = 17, ACTIONS(3), 1, sym_comment, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, ACTIONS(646), 1, - sym_identifier, - ACTIONS(649), 1, - anon_sym_in, - STATE(182), 1, - aux_sym_let_expression_repeat1, - STATE(231), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5260] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(638), 1, - sym_identifier, - ACTIONS(651), 1, - anon_sym_in, - STATE(180), 1, - aux_sym_let_expression_repeat1, - STATE(231), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5279] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(653), 1, - sym_identifier, - ACTIONS(655), 1, anon_sym_RBRACE, - ACTIONS(657), 1, - anon_sym_DOT_DOT_DOT, - STATE(208), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5298] = 6, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8833] = 17, ACTIONS(3), 1, sym_comment, - ACTIONS(653), 1, - sym_identifier, - ACTIONS(659), 1, - anon_sym_RBRACE, - ACTIONS(661), 1, - anon_sym_DOT_DOT_DOT, - STATE(212), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5317] = 5, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(648), 1, + anon_sym_LBRACE, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8889] = 17, ACTIONS(3), 1, sym_comment, - ACTIONS(653), 1, - sym_identifier, - ACTIONS(663), 1, - anon_sym_RBRACE, - STATE(222), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5333] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(653), 1, - sym_identifier, - ACTIONS(665), 1, - anon_sym_RBRACE, - STATE(222), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5349] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(667), 1, - anon_sym_COMMA, - STATE(188), 1, - aux_sym_array_repeat1, - ACTIONS(606), 2, - anon_sym_RBRACK, + ACTIONS(565), 1, + anon_sym_DOT, + ACTIONS(567), 1, + anon_sym_LPAREN, + ACTIONS(573), 1, + anon_sym_DASH, + ACTIONS(575), 1, + anon_sym_PIPE_PIPE, + ACTIONS(577), 1, + anon_sym_AMP_AMP, + ACTIONS(579), 1, + anon_sym_PLUS_PLUS, + ACTIONS(581), 1, + anon_sym_PLUS, + ACTIONS(583), 1, + anon_sym_STAR, + ACTIONS(585), 1, + anon_sym_SLASH, + ACTIONS(587), 1, + anon_sym_AMP, + ACTIONS(589), 1, + anon_sym_SLASH_SLASH, + ACTIONS(591), 1, + anon_sym_default, + ACTIONS(593), 1, + anon_sym_as, + ACTIONS(650), 1, anon_sym_RPAREN, - [5363] = 5, + ACTIONS(569), 2, + anon_sym_GT, + anon_sym_LT, + ACTIONS(571), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [8945] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(653), 1, + ACTIONS(652), 1, + sym_identifier, + ACTIONS(654), 1, + anon_sym_RBRACE, + ACTIONS(656), 1, + anon_sym_DOT_DOT_DOT, + STATE(225), 1, + sym_object_rest, + STATE(227), 1, + sym_field_definition, + STATE(253), 1, + sym_field_path, + [8967] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(652), 1, + sym_identifier, + ACTIONS(656), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(658), 1, + anon_sym_RBRACE, + STATE(227), 1, + sym_field_definition, + STATE(231), 1, + sym_object_rest, + STATE(253), 1, + sym_field_path, + [8989] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(652), 1, + sym_identifier, + ACTIONS(656), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(660), 1, + anon_sym_RBRACE, + STATE(226), 1, + sym_object_rest, + STATE(227), 1, + sym_field_definition, + STATE(253), 1, + sym_field_path, + [9011] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(652), 1, + sym_identifier, + ACTIONS(656), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(662), 1, + anon_sym_RBRACE, + STATE(227), 1, + sym_field_definition, + STATE(228), 1, + sym_object_rest, + STATE(253), 1, + sym_field_path, + [9033] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(664), 1, + sym_identifier, + ACTIONS(666), 1, + anon_sym_in, + STATE(193), 1, + aux_sym_let_expression_repeat1, + STATE(251), 1, + sym_field_definition, + STATE(253), 1, + sym_field_path, + [9052] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(664), 1, + sym_identifier, + ACTIONS(668), 1, + anon_sym_in, + STATE(193), 1, + aux_sym_let_expression_repeat1, + STATE(251), 1, + sym_field_definition, + STATE(253), 1, + sym_field_path, + [9071] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(664), 1, sym_identifier, ACTIONS(670), 1, - anon_sym_RBRACE, - STATE(222), 1, + anon_sym_in, + STATE(189), 1, + aux_sym_let_expression_repeat1, + STATE(251), 1, sym_field_definition, - STATE(233), 1, + STATE(253), 1, sym_field_path, - [5379] = 5, + [9090] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(653), 1, + ACTIONS(664), 1, sym_identifier, ACTIONS(672), 1, - anon_sym_RBRACE, - STATE(222), 1, + anon_sym_in, + STATE(190), 1, + aux_sym_let_expression_repeat1, + STATE(251), 1, sym_field_definition, - STATE(233), 1, + STATE(253), 1, sym_field_path, - [5395] = 4, + [9109] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(674), 1, - anon_sym_SEMI, + sym_identifier, ACTIONS(677), 1, - anon_sym_RBRACE, - STATE(191), 1, - aux_sym_match_expression_repeat1, - [5408] = 4, + anon_sym_in, + STATE(193), 1, + aux_sym_let_expression_repeat1, + STATE(251), 1, + sym_field_definition, + STATE(253), 1, + sym_field_path, + [9128] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(371), 1, - anon_sym_DOT, + ACTIONS(652), 1, + sym_identifier, ACTIONS(679), 1, - anon_sym_EQ, - STATE(202), 1, - aux_sym_field_path_repeat1, - [5421] = 4, + anon_sym_RBRACE, + ACTIONS(681), 1, + anon_sym_DOT_DOT_DOT, + STATE(218), 1, + sym_field_definition, + STATE(253), 1, + sym_field_path, + [9147] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(681), 1, + ACTIONS(652), 1, sym_identifier, ACTIONS(683), 1, - anon_sym_RPAREN, - STATE(224), 1, - sym_parameter, - [5434] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(113), 1, anon_sym_RBRACE, ACTIONS(685), 1, - anon_sym_SEMI, - STATE(191), 1, - aux_sym_match_expression_repeat1, - [5447] = 4, + anon_sym_DOT_DOT_DOT, + STATE(204), 1, + sym_field_definition, + STATE(253), 1, + sym_field_path, + [9166] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(687), 1, anon_sym_COMMA, - ACTIONS(690), 1, + STATE(196), 1, + aux_sym_array_repeat1, + ACTIONS(614), 2, + anon_sym_RBRACK, anon_sym_RPAREN, - STATE(195), 1, - aux_sym_function_expression_repeat1, - [5460] = 4, + [9180] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(681), 1, - sym_identifier, - ACTIONS(692), 1, + ACTIONS(658), 1, + anon_sym_RBRACE, + ACTIONS(690), 1, + anon_sym_SEMI, + STATE(222), 1, + aux_sym_object_repeat1, + [9193] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(157), 1, anon_sym_RPAREN, - STATE(224), 1, - sym_parameter, - [5473] = 4, + ACTIONS(692), 1, + anon_sym_COMMA, + STATE(196), 1, + aux_sym_array_repeat1, + [9206] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(694), 1, anon_sym_COMMA, ACTIONS(696), 1, anon_sym_RPAREN, - STATE(195), 1, + STATE(223), 1, aux_sym_function_expression_repeat1, - [5486] = 4, + [9219] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(681), 1, - sym_identifier, - ACTIONS(696), 1, - anon_sym_RPAREN, - STATE(224), 1, - sym_parameter, - [5499] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(653), 1, - sym_identifier, - STATE(222), 1, - sym_field_definition, - STATE(233), 1, - sym_field_path, - [5512] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(157), 1, - anon_sym_RPAREN, ACTIONS(698), 1, - anon_sym_COMMA, - STATE(188), 1, - aux_sym_array_repeat1, - [5525] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(700), 1, - anon_sym_SEMI, - ACTIONS(702), 1, - anon_sym_RBRACE, - STATE(194), 1, - aux_sym_match_expression_repeat1, - [5538] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(704), 1, anon_sym_EQ, - ACTIONS(706), 1, + ACTIONS(700), 1, anon_sym_DOT, - STATE(202), 1, + STATE(200), 1, aux_sym_field_path_repeat1, - [5551] = 4, + [9232] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(672), 1, - anon_sym_RBRACE, - ACTIONS(709), 1, + ACTIONS(703), 1, anon_sym_SEMI, - STATE(214), 1, - aux_sym_object_repeat1, - [5564] = 3, + ACTIONS(705), 1, + anon_sym_RBRACE, + STATE(220), 1, + aux_sym_match_expression_repeat1, + [9245] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(592), 1, - anon_sym_COLON, - ACTIONS(587), 2, - anon_sym_COMMA, + ACTIONS(707), 1, + sym_identifier, + ACTIONS(709), 1, anon_sym_RPAREN, - [5575] = 4, + STATE(229), 1, + sym_parameter, + [9258] = 4, ACTIONS(3), 1, sym_comment, + ACTIONS(113), 1, + anon_sym_RBRACE, ACTIONS(711), 1, - anon_sym_COMMA, - ACTIONS(713), 1, - anon_sym_RPAREN, - STATE(216), 1, - aux_sym_function_expression_repeat1, - [5588] = 4, + anon_sym_SEMI, + STATE(219), 1, + aux_sym_match_expression_repeat1, + [9271] = 4, ACTIONS(3), 1, sym_comment, + ACTIONS(713), 1, + anon_sym_SEMI, ACTIONS(715), 1, - anon_sym_COMMA, + anon_sym_RBRACE, + STATE(213), 1, + aux_sym_object_repeat1, + [9284] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(707), 1, + sym_identifier, ACTIONS(717), 1, anon_sym_RPAREN, - STATE(197), 1, - aux_sym_function_expression_repeat1, - [5601] = 4, + STATE(229), 1, + sym_parameter, + [9297] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(117), 1, - anon_sym_RBRACE, + ACTIONS(652), 1, + sym_identifier, + STATE(227), 1, + sym_field_definition, + STATE(253), 1, + sym_field_path, + [9310] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(375), 1, + anon_sym_DOT, ACTIONS(719), 1, - anon_sym_SEMI, - STATE(191), 1, - aux_sym_match_expression_repeat1, - [5614] = 4, + anon_sym_EQ, + STATE(221), 1, + aux_sym_field_path_repeat1, + [9323] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(721), 1, - anon_sym_SEMI, - ACTIONS(723), 1, - anon_sym_RBRACE, - STATE(217), 1, - aux_sym_object_repeat1, - [5627] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(167), 1, - anon_sym_RPAREN, - ACTIONS(725), 1, anon_sym_COMMA, - STATE(188), 1, - aux_sym_array_repeat1, - [5640] = 4, + ACTIONS(723), 1, + anon_sym_RPAREN, + STATE(214), 1, + aux_sym_function_expression_repeat1, + [9336] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(371), 1, - anon_sym_DOT, - ACTIONS(727), 1, - anon_sym_EQ, - STATE(192), 1, - aux_sym_field_path_repeat1, - [5653] = 4, + ACTIONS(707), 1, + sym_identifier, + ACTIONS(723), 1, + anon_sym_RPAREN, + STATE(229), 1, + sym_parameter, + [9349] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(729), 1, + ACTIONS(604), 1, + anon_sym_COLON, + ACTIONS(599), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [9360] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(725), 1, anon_sym_SEMI, - ACTIONS(731), 1, + ACTIONS(727), 1, anon_sym_RBRACE, - STATE(207), 1, + STATE(203), 1, aux_sym_match_expression_repeat1, - [5666] = 4, + [9373] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(707), 1, + sym_identifier, + ACTIONS(729), 1, + anon_sym_RPAREN, + STATE(229), 1, + sym_parameter, + [9386] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(662), 1, + anon_sym_RBRACE, + ACTIONS(731), 1, + anon_sym_SEMI, + STATE(222), 1, + aux_sym_object_repeat1, + [9399] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(733), 1, - anon_sym_SEMI, - ACTIONS(735), 1, - anon_sym_RBRACE, - STATE(203), 1, - aux_sym_object_repeat1, - [5679] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(153), 1, - anon_sym_RBRACK, - ACTIONS(737), 1, anon_sym_COMMA, - STATE(188), 1, - aux_sym_array_repeat1, - [5692] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(739), 1, - anon_sym_SEMI, - ACTIONS(742), 1, - anon_sym_RBRACE, + ACTIONS(736), 1, + anon_sym_RPAREN, STATE(214), 1, - aux_sym_object_repeat1, - [5705] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(681), 1, - sym_identifier, - ACTIONS(744), 1, - anon_sym_RPAREN, - STATE(224), 1, - sym_parameter, - [5718] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(744), 1, - anon_sym_RPAREN, - ACTIONS(746), 1, - anon_sym_COMMA, - STATE(195), 1, aux_sym_function_expression_repeat1, - [5731] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(663), 1, - anon_sym_RBRACE, - ACTIONS(748), 1, - anon_sym_SEMI, - STATE(214), 1, - aux_sym_object_repeat1, - [5744] = 4, + [9412] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(155), 1, anon_sym_RBRACK, - ACTIONS(750), 1, + ACTIONS(738), 1, anon_sym_COMMA, - STATE(188), 1, + STATE(196), 1, aux_sym_array_repeat1, - [5757] = 2, + [9425] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(677), 2, - anon_sym_SEMI, - anon_sym_RBRACE, - [5765] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(704), 2, - anon_sym_EQ, - anon_sym_DOT, - [5773] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(681), 1, - sym_identifier, - STATE(224), 1, - sym_parameter, - [5783] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(742), 2, - anon_sym_SEMI, - anon_sym_RBRACE, - [5791] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(649), 2, - sym_identifier, - anon_sym_in, - [5799] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(690), 2, + ACTIONS(740), 1, anon_sym_COMMA, + ACTIONS(742), 1, anon_sym_RPAREN, - [5807] = 2, + STATE(208), 1, + aux_sym_function_expression_repeat1, + [9438] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(752), 1, - anon_sym_EQ_GT, - [5814] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(754), 1, + ACTIONS(153), 1, anon_sym_RBRACK, - [5821] = 2, + ACTIONS(744), 1, + anon_sym_COMMA, + STATE(196), 1, + aux_sym_array_repeat1, + [9451] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(756), 1, - anon_sym_RBRACK, - [5828] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(758), 1, - anon_sym_EQ_GT, - [5835] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(760), 1, - anon_sym_EQ_GT, - [5842] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(636), 1, - anon_sym_COLON, - [5849] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(762), 1, + ACTIONS(746), 1, anon_sym_SEMI, - [5856] = 2, + ACTIONS(748), 1, + anon_sym_RBRACE, + STATE(197), 1, + aux_sym_object_repeat1, + [9464] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(764), 1, - anon_sym_EQ_GT, - [5863] = 2, + ACTIONS(750), 1, + anon_sym_SEMI, + ACTIONS(753), 1, + anon_sym_RBRACE, + STATE(219), 1, + aux_sym_match_expression_repeat1, + [9477] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(766), 1, + ACTIONS(117), 1, + anon_sym_RBRACE, + ACTIONS(755), 1, + anon_sym_SEMI, + STATE(219), 1, + aux_sym_match_expression_repeat1, + [9490] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(375), 1, + anon_sym_DOT, + ACTIONS(757), 1, anon_sym_EQ, - [5870] = 2, + STATE(200), 1, + aux_sym_field_path_repeat1, + [9503] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(759), 1, + anon_sym_SEMI, + ACTIONS(762), 1, + anon_sym_RBRACE, + STATE(222), 1, + aux_sym_object_repeat1, + [9516] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(729), 1, + anon_sym_RPAREN, + ACTIONS(764), 1, + anon_sym_COMMA, + STATE(214), 1, + aux_sym_function_expression_repeat1, + [9529] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(167), 1, + anon_sym_RPAREN, + ACTIONS(766), 1, + anon_sym_COMMA, + STATE(196), 1, + aux_sym_array_repeat1, + [9542] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(768), 1, - sym_identifier, - [5877] = 2, - ACTIONS(3), 1, - sym_comment, + anon_sym_SEMI, ACTIONS(770), 1, - anon_sym_EQ, - [5884] = 2, + anon_sym_RBRACE, + [9552] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(772), 1, - sym_identifier, - [5891] = 2, - ACTIONS(3), 1, - sym_comment, + anon_sym_SEMI, ACTIONS(774), 1, - ts_builtin_sym_end, - [5898] = 2, + anon_sym_RBRACE, + [9562] = 2, ACTIONS(3), 1, sym_comment, + ACTIONS(762), 2, + anon_sym_SEMI, + anon_sym_RBRACE, + [9570] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(654), 1, + anon_sym_RBRACE, ACTIONS(776), 1, - sym_string, - [5905] = 2, + anon_sym_SEMI, + [9580] = 2, ACTIONS(3), 1, sym_comment, + ACTIONS(736), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [9588] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(753), 2, + anon_sym_SEMI, + anon_sym_RBRACE, + [9596] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(660), 1, + anon_sym_RBRACE, ACTIONS(778), 1, - sym_string, - [5912] = 2, + anon_sym_SEMI, + [9606] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(677), 2, + sym_identifier, + anon_sym_in, + [9614] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(698), 2, + anon_sym_EQ, + anon_sym_DOT, + [9622] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(707), 1, + sym_identifier, + STATE(229), 1, + sym_parameter, + [9632] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(780), 1, - anon_sym_EQ_GT, - [5919] = 2, + sym_identifier, + [9639] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(782), 1, - anon_sym_EQ_GT, - [5926] = 2, + anon_sym_RBRACK, + [9646] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(784), 1, anon_sym_EQ_GT, - [5933] = 2, + [9653] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(786), 1, - sym_identifier, - [5940] = 2, + anon_sym_EQ_GT, + [9660] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(788), 1, anon_sym_EQ_GT, + [9667] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(790), 1, + ts_builtin_sym_end, + [9674] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(792), 1, + anon_sym_RBRACE, + [9681] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(774), 1, + anon_sym_RBRACE, + [9688] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(794), 1, + anon_sym_EQ_GT, + [9695] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(796), 1, + anon_sym_EQ_GT, + [9702] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(798), 1, + sym_identifier, + [9709] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(800), 1, + anon_sym_EQ_GT, + [9716] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(802), 1, + sym_identifier, + [9723] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(804), 1, + anon_sym_RBRACE, + [9730] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(806), 1, + anon_sym_EQ, + [9737] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(808), 1, + anon_sym_RBRACK, + [9744] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(810), 1, + anon_sym_SEMI, + [9751] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(812), 1, + sym_string, + [9758] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(814), 1, + anon_sym_EQ, + [9765] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(816), 1, + sym_string, + [9772] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(638), 1, + anon_sym_COLON, + [9779] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(818), 1, + anon_sym_EQ_GT, + [9786] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(770), 1, + anon_sym_RBRACE, + [9793] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(820), 1, + anon_sym_EQ_GT, }; static const uint32_t ts_small_parse_table_map[] = { - [SMALL_STATE(72)] = 0, - [SMALL_STATE(73)] = 50, - [SMALL_STATE(74)] = 92, - [SMALL_STATE(75)] = 134, - [SMALL_STATE(76)] = 176, - [SMALL_STATE(77)] = 218, - [SMALL_STATE(78)] = 274, - [SMALL_STATE(79)] = 324, - [SMALL_STATE(80)] = 386, - [SMALL_STATE(81)] = 446, - [SMALL_STATE(82)] = 500, - [SMALL_STATE(83)] = 546, - [SMALL_STATE(84)] = 610, - [SMALL_STATE(85)] = 676, - [SMALL_STATE(86)] = 746, - [SMALL_STATE(87)] = 816, - [SMALL_STATE(88)] = 888, - [SMALL_STATE(89)] = 930, - [SMALL_STATE(90)] = 972, - [SMALL_STATE(91)] = 1014, - [SMALL_STATE(92)] = 1056, - [SMALL_STATE(93)] = 1128, - [SMALL_STATE(94)] = 1170, - [SMALL_STATE(95)] = 1212, - [SMALL_STATE(96)] = 1254, - [SMALL_STATE(97)] = 1296, - [SMALL_STATE(98)] = 1338, - [SMALL_STATE(99)] = 1380, - [SMALL_STATE(100)] = 1452, - [SMALL_STATE(101)] = 1498, - [SMALL_STATE(102)] = 1570, - [SMALL_STATE(103)] = 1642, - [SMALL_STATE(104)] = 1688, - [SMALL_STATE(105)] = 1730, - [SMALL_STATE(106)] = 1772, - [SMALL_STATE(107)] = 1814, - [SMALL_STATE(108)] = 1886, - [SMALL_STATE(109)] = 1928, - [SMALL_STATE(110)] = 1970, - [SMALL_STATE(111)] = 2012, - [SMALL_STATE(112)] = 2054, - [SMALL_STATE(113)] = 2096, - [SMALL_STATE(114)] = 2138, - [SMALL_STATE(115)] = 2210, - [SMALL_STATE(116)] = 2252, - [SMALL_STATE(117)] = 2326, - [SMALL_STATE(118)] = 2360, - [SMALL_STATE(119)] = 2394, - [SMALL_STATE(120)] = 2428, - [SMALL_STATE(121)] = 2490, - [SMALL_STATE(122)] = 2524, - [SMALL_STATE(123)] = 2558, - [SMALL_STATE(124)] = 2620, - [SMALL_STATE(125)] = 2654, - [SMALL_STATE(126)] = 2688, - [SMALL_STATE(127)] = 2750, - [SMALL_STATE(128)] = 2784, - [SMALL_STATE(129)] = 2818, - [SMALL_STATE(130)] = 2852, - [SMALL_STATE(131)] = 2886, - [SMALL_STATE(132)] = 2920, - [SMALL_STATE(133)] = 2982, - [SMALL_STATE(134)] = 3044, - [SMALL_STATE(135)] = 3078, - [SMALL_STATE(136)] = 3112, - [SMALL_STATE(137)] = 3172, - [SMALL_STATE(138)] = 3232, - [SMALL_STATE(139)] = 3288, - [SMALL_STATE(140)] = 3344, - [SMALL_STATE(141)] = 3382, - [SMALL_STATE(142)] = 3416, - [SMALL_STATE(143)] = 3450, - [SMALL_STATE(144)] = 3496, - [SMALL_STATE(145)] = 3548, - [SMALL_STATE(146)] = 3582, - [SMALL_STATE(147)] = 3616, - [SMALL_STATE(148)] = 3670, - [SMALL_STATE(149)] = 3704, - [SMALL_STATE(150)] = 3742, - [SMALL_STATE(151)] = 3780, - [SMALL_STATE(152)] = 3822, - [SMALL_STATE(153)] = 3870, - [SMALL_STATE(154)] = 3904, - [SMALL_STATE(155)] = 3938, - [SMALL_STATE(156)] = 3972, - [SMALL_STATE(157)] = 4034, - [SMALL_STATE(158)] = 4068, - [SMALL_STATE(159)] = 4102, - [SMALL_STATE(160)] = 4164, - [SMALL_STATE(161)] = 4200, - [SMALL_STATE(162)] = 4262, - [SMALL_STATE(163)] = 4324, - [SMALL_STATE(164)] = 4386, - [SMALL_STATE(165)] = 4444, - [SMALL_STATE(166)] = 4501, - [SMALL_STATE(167)] = 4558, - [SMALL_STATE(168)] = 4589, - [SMALL_STATE(169)] = 4648, - [SMALL_STATE(170)] = 4705, - [SMALL_STATE(171)] = 4764, - [SMALL_STATE(172)] = 4820, - [SMALL_STATE(173)] = 4876, - [SMALL_STATE(174)] = 4932, - [SMALL_STATE(175)] = 4988, - [SMALL_STATE(176)] = 5016, - [SMALL_STATE(177)] = 5072, - [SMALL_STATE(178)] = 5128, - [SMALL_STATE(179)] = 5184, - [SMALL_STATE(180)] = 5203, - [SMALL_STATE(181)] = 5222, - [SMALL_STATE(182)] = 5241, - [SMALL_STATE(183)] = 5260, - [SMALL_STATE(184)] = 5279, - [SMALL_STATE(185)] = 5298, - [SMALL_STATE(186)] = 5317, - [SMALL_STATE(187)] = 5333, - [SMALL_STATE(188)] = 5349, - [SMALL_STATE(189)] = 5363, - [SMALL_STATE(190)] = 5379, - [SMALL_STATE(191)] = 5395, - [SMALL_STATE(192)] = 5408, - [SMALL_STATE(193)] = 5421, - [SMALL_STATE(194)] = 5434, - [SMALL_STATE(195)] = 5447, - [SMALL_STATE(196)] = 5460, - [SMALL_STATE(197)] = 5473, - [SMALL_STATE(198)] = 5486, - [SMALL_STATE(199)] = 5499, - [SMALL_STATE(200)] = 5512, - [SMALL_STATE(201)] = 5525, - [SMALL_STATE(202)] = 5538, - [SMALL_STATE(203)] = 5551, - [SMALL_STATE(204)] = 5564, - [SMALL_STATE(205)] = 5575, - [SMALL_STATE(206)] = 5588, - [SMALL_STATE(207)] = 5601, - [SMALL_STATE(208)] = 5614, - [SMALL_STATE(209)] = 5627, - [SMALL_STATE(210)] = 5640, - [SMALL_STATE(211)] = 5653, - [SMALL_STATE(212)] = 5666, - [SMALL_STATE(213)] = 5679, - [SMALL_STATE(214)] = 5692, - [SMALL_STATE(215)] = 5705, - [SMALL_STATE(216)] = 5718, - [SMALL_STATE(217)] = 5731, - [SMALL_STATE(218)] = 5744, - [SMALL_STATE(219)] = 5757, - [SMALL_STATE(220)] = 5765, - [SMALL_STATE(221)] = 5773, - [SMALL_STATE(222)] = 5783, - [SMALL_STATE(223)] = 5791, - [SMALL_STATE(224)] = 5799, - [SMALL_STATE(225)] = 5807, - [SMALL_STATE(226)] = 5814, - [SMALL_STATE(227)] = 5821, - [SMALL_STATE(228)] = 5828, - [SMALL_STATE(229)] = 5835, - [SMALL_STATE(230)] = 5842, - [SMALL_STATE(231)] = 5849, - [SMALL_STATE(232)] = 5856, - [SMALL_STATE(233)] = 5863, - [SMALL_STATE(234)] = 5870, - [SMALL_STATE(235)] = 5877, - [SMALL_STATE(236)] = 5884, - [SMALL_STATE(237)] = 5891, - [SMALL_STATE(238)] = 5898, - [SMALL_STATE(239)] = 5905, - [SMALL_STATE(240)] = 5912, - [SMALL_STATE(241)] = 5919, - [SMALL_STATE(242)] = 5926, - [SMALL_STATE(243)] = 5933, - [SMALL_STATE(244)] = 5940, + [SMALL_STATE(25)] = 0, + [SMALL_STATE(26)] = 74, + [SMALL_STATE(27)] = 148, + [SMALL_STATE(28)] = 222, + [SMALL_STATE(29)] = 296, + [SMALL_STATE(30)] = 370, + [SMALL_STATE(31)] = 444, + [SMALL_STATE(32)] = 518, + [SMALL_STATE(33)] = 592, + [SMALL_STATE(34)] = 666, + [SMALL_STATE(35)] = 740, + [SMALL_STATE(36)] = 814, + [SMALL_STATE(37)] = 888, + [SMALL_STATE(38)] = 962, + [SMALL_STATE(39)] = 1036, + [SMALL_STATE(40)] = 1110, + [SMALL_STATE(41)] = 1184, + [SMALL_STATE(42)] = 1258, + [SMALL_STATE(43)] = 1332, + [SMALL_STATE(44)] = 1406, + [SMALL_STATE(45)] = 1480, + [SMALL_STATE(46)] = 1554, + [SMALL_STATE(47)] = 1628, + [SMALL_STATE(48)] = 1702, + [SMALL_STATE(49)] = 1776, + [SMALL_STATE(50)] = 1850, + [SMALL_STATE(51)] = 1924, + [SMALL_STATE(52)] = 1998, + [SMALL_STATE(53)] = 2072, + [SMALL_STATE(54)] = 2146, + [SMALL_STATE(55)] = 2220, + [SMALL_STATE(56)] = 2294, + [SMALL_STATE(57)] = 2368, + [SMALL_STATE(58)] = 2442, + [SMALL_STATE(59)] = 2516, + [SMALL_STATE(60)] = 2590, + [SMALL_STATE(61)] = 2664, + [SMALL_STATE(62)] = 2738, + [SMALL_STATE(63)] = 2812, + [SMALL_STATE(64)] = 2886, + [SMALL_STATE(65)] = 2960, + [SMALL_STATE(66)] = 3034, + [SMALL_STATE(67)] = 3108, + [SMALL_STATE(68)] = 3182, + [SMALL_STATE(69)] = 3256, + [SMALL_STATE(70)] = 3330, + [SMALL_STATE(71)] = 3404, + [SMALL_STATE(72)] = 3478, + [SMALL_STATE(73)] = 3552, + [SMALL_STATE(74)] = 3602, + [SMALL_STATE(75)] = 3644, + [SMALL_STATE(76)] = 3686, + [SMALL_STATE(77)] = 3758, + [SMALL_STATE(78)] = 3814, + [SMALL_STATE(79)] = 3864, + [SMALL_STATE(80)] = 3926, + [SMALL_STATE(81)] = 3986, + [SMALL_STATE(82)] = 4040, + [SMALL_STATE(83)] = 4086, + [SMALL_STATE(84)] = 4150, + [SMALL_STATE(85)] = 4216, + [SMALL_STATE(86)] = 4286, + [SMALL_STATE(87)] = 4356, + [SMALL_STATE(88)] = 4428, + [SMALL_STATE(89)] = 4470, + [SMALL_STATE(90)] = 4512, + [SMALL_STATE(91)] = 4554, + [SMALL_STATE(92)] = 4596, + [SMALL_STATE(93)] = 4638, + [SMALL_STATE(94)] = 4710, + [SMALL_STATE(95)] = 4752, + [SMALL_STATE(96)] = 4794, + [SMALL_STATE(97)] = 4836, + [SMALL_STATE(98)] = 4878, + [SMALL_STATE(99)] = 4920, + [SMALL_STATE(100)] = 4962, + [SMALL_STATE(101)] = 5004, + [SMALL_STATE(102)] = 5076, + [SMALL_STATE(103)] = 5122, + [SMALL_STATE(104)] = 5194, + [SMALL_STATE(105)] = 5266, + [SMALL_STATE(106)] = 5308, + [SMALL_STATE(107)] = 5354, + [SMALL_STATE(108)] = 5396, + [SMALL_STATE(109)] = 5438, + [SMALL_STATE(110)] = 5480, + [SMALL_STATE(111)] = 5522, + [SMALL_STATE(112)] = 5564, + [SMALL_STATE(113)] = 5606, + [SMALL_STATE(114)] = 5648, + [SMALL_STATE(115)] = 5690, + [SMALL_STATE(116)] = 5732, + [SMALL_STATE(117)] = 5806, + [SMALL_STATE(118)] = 5878, + [SMALL_STATE(119)] = 5920, + [SMALL_STATE(120)] = 5962, + [SMALL_STATE(121)] = 5996, + [SMALL_STATE(122)] = 6030, + [SMALL_STATE(123)] = 6064, + [SMALL_STATE(124)] = 6126, + [SMALL_STATE(125)] = 6160, + [SMALL_STATE(126)] = 6194, + [SMALL_STATE(127)] = 6228, + [SMALL_STATE(128)] = 6290, + [SMALL_STATE(129)] = 6324, + [SMALL_STATE(130)] = 6358, + [SMALL_STATE(131)] = 6392, + [SMALL_STATE(132)] = 6454, + [SMALL_STATE(133)] = 6488, + [SMALL_STATE(134)] = 6522, + [SMALL_STATE(135)] = 6556, + [SMALL_STATE(136)] = 6590, + [SMALL_STATE(137)] = 6624, + [SMALL_STATE(138)] = 6686, + [SMALL_STATE(139)] = 6748, + [SMALL_STATE(140)] = 6782, + [SMALL_STATE(141)] = 6816, + [SMALL_STATE(142)] = 6876, + [SMALL_STATE(143)] = 6936, + [SMALL_STATE(144)] = 6992, + [SMALL_STATE(145)] = 7048, + [SMALL_STATE(146)] = 7086, + [SMALL_STATE(147)] = 7132, + [SMALL_STATE(148)] = 7184, + [SMALL_STATE(149)] = 7238, + [SMALL_STATE(150)] = 7272, + [SMALL_STATE(151)] = 7306, + [SMALL_STATE(152)] = 7348, + [SMALL_STATE(153)] = 7396, + [SMALL_STATE(154)] = 7430, + [SMALL_STATE(155)] = 7464, + [SMALL_STATE(156)] = 7498, + [SMALL_STATE(157)] = 7532, + [SMALL_STATE(158)] = 7570, + [SMALL_STATE(159)] = 7608, + [SMALL_STATE(160)] = 7642, + [SMALL_STATE(161)] = 7676, + [SMALL_STATE(162)] = 7738, + [SMALL_STATE(163)] = 7772, + [SMALL_STATE(164)] = 7806, + [SMALL_STATE(165)] = 7868, + [SMALL_STATE(166)] = 7904, + [SMALL_STATE(167)] = 7966, + [SMALL_STATE(168)] = 8028, + [SMALL_STATE(169)] = 8086, + [SMALL_STATE(170)] = 8148, + [SMALL_STATE(171)] = 8205, + [SMALL_STATE(172)] = 8262, + [SMALL_STATE(173)] = 8319, + [SMALL_STATE(174)] = 8376, + [SMALL_STATE(175)] = 8407, + [SMALL_STATE(176)] = 8466, + [SMALL_STATE(177)] = 8525, + [SMALL_STATE(178)] = 8581, + [SMALL_STATE(179)] = 8637, + [SMALL_STATE(180)] = 8693, + [SMALL_STATE(181)] = 8721, + [SMALL_STATE(182)] = 8777, + [SMALL_STATE(183)] = 8833, + [SMALL_STATE(184)] = 8889, + [SMALL_STATE(185)] = 8945, + [SMALL_STATE(186)] = 8967, + [SMALL_STATE(187)] = 8989, + [SMALL_STATE(188)] = 9011, + [SMALL_STATE(189)] = 9033, + [SMALL_STATE(190)] = 9052, + [SMALL_STATE(191)] = 9071, + [SMALL_STATE(192)] = 9090, + [SMALL_STATE(193)] = 9109, + [SMALL_STATE(194)] = 9128, + [SMALL_STATE(195)] = 9147, + [SMALL_STATE(196)] = 9166, + [SMALL_STATE(197)] = 9180, + [SMALL_STATE(198)] = 9193, + [SMALL_STATE(199)] = 9206, + [SMALL_STATE(200)] = 9219, + [SMALL_STATE(201)] = 9232, + [SMALL_STATE(202)] = 9245, + [SMALL_STATE(203)] = 9258, + [SMALL_STATE(204)] = 9271, + [SMALL_STATE(205)] = 9284, + [SMALL_STATE(206)] = 9297, + [SMALL_STATE(207)] = 9310, + [SMALL_STATE(208)] = 9323, + [SMALL_STATE(209)] = 9336, + [SMALL_STATE(210)] = 9349, + [SMALL_STATE(211)] = 9360, + [SMALL_STATE(212)] = 9373, + [SMALL_STATE(213)] = 9386, + [SMALL_STATE(214)] = 9399, + [SMALL_STATE(215)] = 9412, + [SMALL_STATE(216)] = 9425, + [SMALL_STATE(217)] = 9438, + [SMALL_STATE(218)] = 9451, + [SMALL_STATE(219)] = 9464, + [SMALL_STATE(220)] = 9477, + [SMALL_STATE(221)] = 9490, + [SMALL_STATE(222)] = 9503, + [SMALL_STATE(223)] = 9516, + [SMALL_STATE(224)] = 9529, + [SMALL_STATE(225)] = 9542, + [SMALL_STATE(226)] = 9552, + [SMALL_STATE(227)] = 9562, + [SMALL_STATE(228)] = 9570, + [SMALL_STATE(229)] = 9580, + [SMALL_STATE(230)] = 9588, + [SMALL_STATE(231)] = 9596, + [SMALL_STATE(232)] = 9606, + [SMALL_STATE(233)] = 9614, + [SMALL_STATE(234)] = 9622, + [SMALL_STATE(235)] = 9632, + [SMALL_STATE(236)] = 9639, + [SMALL_STATE(237)] = 9646, + [SMALL_STATE(238)] = 9653, + [SMALL_STATE(239)] = 9660, + [SMALL_STATE(240)] = 9667, + [SMALL_STATE(241)] = 9674, + [SMALL_STATE(242)] = 9681, + [SMALL_STATE(243)] = 9688, + [SMALL_STATE(244)] = 9695, + [SMALL_STATE(245)] = 9702, + [SMALL_STATE(246)] = 9709, + [SMALL_STATE(247)] = 9716, + [SMALL_STATE(248)] = 9723, + [SMALL_STATE(249)] = 9730, + [SMALL_STATE(250)] = 9737, + [SMALL_STATE(251)] = 9744, + [SMALL_STATE(252)] = 9751, + [SMALL_STATE(253)] = 9758, + [SMALL_STATE(254)] = 9765, + [SMALL_STATE(255)] = 9772, + [SMALL_STATE(256)] = 9779, + [SMALL_STATE(257)] = 9786, + [SMALL_STATE(258)] = 9793, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -9586,118 +10738,118 @@ static const TSParseActionEntry ts_parse_actions[] = { [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 0, 0, 0), - [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(72), - [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(90), - [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112), + [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(73), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(91), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(118), [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), - [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), - [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(181), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), - [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(238), - [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(63), - [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(252), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(69), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), [35] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), [37] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), - [39] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(72), - [42] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(90), - [45] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(112), - [48] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(112), + [39] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(73), + [42] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(91), + [45] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(118), + [48] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(118), [51] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(116), - [54] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(185), + [54] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(195), [57] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(10), - [60] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(181), + [60] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(191), [63] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(13), [66] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(59), - [69] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(238), - [72] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(63), - [75] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(63), - [78] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(71), - [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(178), - [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(141), - [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(142), - [89] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [91] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), - [93] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [69] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(252), + [72] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(69), + [75] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(69), + [78] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(72), + [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(179), + [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(149), + [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(150), + [89] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [91] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [93] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), [95] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(183), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(192), [99] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(38), - [103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), - [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(239), - [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(61), - [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), - [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(163), - [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(254), + [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(63), + [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), + [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), - [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), - [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), - [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), - [137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), - [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(161), - [143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(165), + [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), + [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(169), + [143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), [145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), - [149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(164), - [151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), - [153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), - [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), - [161] = {.entry = {.count = 1, .reusable = false}}, SHIFT(159), - [163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), - [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), - [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [171] = {.entry = {.count = 1, .reusable = false}}, SHIFT(162), - [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), - [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), - [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(143), - [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(156), - [187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [189] = {.entry = {.count = 1, .reusable = false}}, SHIFT(165), - [191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), - [193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), - [195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), - [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), - [201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168), - [203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), - [205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), - [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), - [211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), - [213] = {.entry = {.count = 1, .reusable = false}}, SHIFT(123), - [215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [217] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), - [219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [221] = {.entry = {.count = 1, .reusable = false}}, SHIFT(132), - [223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [225] = {.entry = {.count = 1, .reusable = false}}, SHIFT(114), - [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [229] = {.entry = {.count = 1, .reusable = false}}, SHIFT(177), - [231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [233] = {.entry = {.count = 1, .reusable = false}}, SHIFT(92), - [235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [237] = {.entry = {.count = 1, .reusable = false}}, SHIFT(133), - [239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [241] = {.entry = {.count = 1, .reusable = false}}, SHIFT(169), - [243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168), + [151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [161] = {.entry = {.count = 1, .reusable = false}}, SHIFT(164), + [163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [171] = {.entry = {.count = 1, .reusable = false}}, SHIFT(166), + [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(146), + [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(158), + [187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [189] = {.entry = {.count = 1, .reusable = false}}, SHIFT(104), + [191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(182), + [195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(175), + [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(171), + [203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(76), + [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(123), + [211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [213] = {.entry = {.count = 1, .reusable = false}}, SHIFT(127), + [215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [217] = {.entry = {.count = 1, .reusable = false}}, SHIFT(131), + [219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [221] = {.entry = {.count = 1, .reusable = false}}, SHIFT(137), + [223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [225] = {.entry = {.count = 1, .reusable = false}}, SHIFT(117), + [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [229] = {.entry = {.count = 1, .reusable = false}}, SHIFT(181), + [231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [233] = {.entry = {.count = 1, .reusable = false}}, SHIFT(93), + [235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [237] = {.entry = {.count = 1, .reusable = false}}, SHIFT(138), + [239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [241] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), + [243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), [245] = {.entry = {.count = 1, .reusable = false}}, SHIFT(77), [247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), [249] = {.entry = {.count = 1, .reusable = false}}, SHIFT(78), @@ -9720,253 +10872,269 @@ static const TSParseActionEntry ts_parse_actions[] = { [283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), [285] = {.entry = {.count = 1, .reusable = false}}, SHIFT(87), [287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [289] = {.entry = {.count = 1, .reusable = false}}, SHIFT(136), - [291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [293] = {.entry = {.count = 1, .reusable = false}}, SHIFT(137), - [295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [297] = {.entry = {.count = 1, .reusable = false}}, SHIFT(138), - [299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [301] = {.entry = {.count = 1, .reusable = false}}, SHIFT(139), - [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), - [307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), - [309] = {.entry = {.count = 1, .reusable = false}}, SHIFT(140), - [311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [313] = {.entry = {.count = 1, .reusable = false}}, SHIFT(171), - [315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), - [317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(172), - [319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [321] = {.entry = {.count = 1, .reusable = false}}, SHIFT(149), - [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(144), - [327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [329] = {.entry = {.count = 1, .reusable = false}}, SHIFT(103), - [331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [333] = {.entry = {.count = 1, .reusable = false}}, SHIFT(147), - [335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [337] = {.entry = {.count = 1, .reusable = false}}, SHIFT(99), - [339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [289] = {.entry = {.count = 1, .reusable = false}}, SHIFT(141), + [291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [293] = {.entry = {.count = 1, .reusable = false}}, SHIFT(142), + [295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [297] = {.entry = {.count = 1, .reusable = false}}, SHIFT(143), + [299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [301] = {.entry = {.count = 1, .reusable = false}}, SHIFT(144), + [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(176), + [307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [309] = {.entry = {.count = 1, .reusable = false}}, SHIFT(145), + [311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [313] = {.entry = {.count = 1, .reusable = false}}, SHIFT(183), + [315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(178), + [319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [321] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), + [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(147), + [327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [329] = {.entry = {.count = 1, .reusable = false}}, SHIFT(157), + [331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [333] = {.entry = {.count = 1, .reusable = false}}, SHIFT(148), + [335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [337] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101), + [339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), [341] = {.entry = {.count = 1, .reusable = false}}, SHIFT(151), [343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(166), - [347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101), - [351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), - [353] = {.entry = {.count = 1, .reusable = false}}, SHIFT(150), - [355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(172), + [347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(103), + [351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [353] = {.entry = {.count = 1, .reusable = false}}, SHIFT(106), + [355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), [357] = {.entry = {.count = 1, .reusable = false}}, SHIFT(152), [359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [361] = {.entry = {.count = 1, .reusable = false}}, SHIFT(100), - [363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [365] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), - [367] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 1, 0, 0), - [369] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_path, 1, 0, 0), - [371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), - [373] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_constraint, 4, 0, 13), - [375] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_constraint, 4, 0, 13), - [377] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_path_expression, 3, 0, 6), - [379] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_path_expression, 3, 0, 6), - [381] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 7), - [383] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 7), - [385] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 3, 0, 0), - [387] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 3, 0, 0), - [389] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 8), - [391] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 8), - [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), - [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [361] = {.entry = {.count = 1, .reusable = false}}, SHIFT(161), + [363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [365] = {.entry = {.count = 1, .reusable = false}}, SHIFT(102), + [367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), + [371] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 1, 0, 0), + [373] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_path, 1, 0, 0), + [375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [377] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 6, 0, 7), + [379] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 6, 0, 7), + [381] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 4, 0, 0), + [383] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 4, 0, 0), + [385] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_expression, 3, 0, 5), + [387] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_expression, 3, 0, 5), + [389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [393] = {.entry = {.count = 1, .reusable = false}}, SHIFT(42), + [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), [397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [401] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), - [403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [405] = {.entry = {.count = 1, .reusable = false}}, SHIFT(47), - [407] = {.entry = {.count = 1, .reusable = false}}, SHIFT(42), - [409] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [415] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48), - [417] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_default_expression, 3, 0, 9), - [419] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_default_expression, 3, 0, 9), - [421] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [423] = {.entry = {.count = 1, .reusable = false}}, SHIFT(50), - [425] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_as_expression, 3, 0, 10), - [427] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_as_expression, 3, 0, 10), - [429] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 3, 0, 11), - [431] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_definition, 3, 0, 11), - [433] = {.entry = {.count = 1, .reusable = false}}, SHIFT(51), + [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [405] = {.entry = {.count = 1, .reusable = false}}, SHIFT(43), + [407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [409] = {.entry = {.count = 1, .reusable = false}}, SHIFT(47), + [411] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48), + [413] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [415] = {.entry = {.count = 1, .reusable = false}}, SHIFT(50), + [417] = {.entry = {.count = 1, .reusable = false}}, SHIFT(51), + [419] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 8), + [421] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 8), + [423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_default_expression, 3, 0, 9), + [425] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_default_expression, 3, 0, 9), + [427] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_as_expression, 3, 0, 10), + [429] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_as_expression, 3, 0, 10), + [431] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 3, 0, 11), + [433] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_definition, 3, 0, 11), [435] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_constraint, 4, 0, 12), [437] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_constraint, 4, 0, 12), - [439] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 4, 0, 0), - [441] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 4, 0, 0), - [443] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), - [445] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), - [447] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 7, 0, 16), - [449] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 7, 0, 16), - [451] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 7, 0, 20), - [453] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 7, 0, 20), - [455] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 4, 0, 0), - [457] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 4, 0, 0), - [459] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 6, 0, 7), - [461] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 6, 0, 7), + [439] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 4, 0, 0), + [441] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 4, 0, 0), + [443] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 3, 0, 0), + [445] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 3, 0, 0), + [447] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), + [449] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), + [451] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 7, 0, 16), + [453] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 7, 0, 16), + [455] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 7, 0, 21), + [457] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 7, 0, 21), + [459] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 7, 0, 0), + [461] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 7, 0, 0), [463] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), [465] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), - [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_constraint, 5, 0, 13), - [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_constraint, 5, 0, 13), - [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 3, 0, 0), - [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 3, 0, 0), - [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 6, 0, 16), - [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 6, 0, 16), - [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_expression, 4, 0, 14), - [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_expression, 4, 0, 14), - [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 4), - [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 4), - [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 4, 0, 14), - [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 4, 0, 14), - [491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 6, 0, 18), - [493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 6, 0, 18), - [495] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_constraint, 2, 0, 3), - [497] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_constraint, 2, 0, 3), - [499] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 7), - [501] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 7), - [503] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_expression, 2, 0, 2), - [505] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_expression, 2, 0, 2), - [507] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 0, 16), - [509] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 0, 16), - [511] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_expression, 3, 0, 5), - [513] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_expression, 3, 0, 5), - [515] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 0, 16), - [517] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 0, 16), - [519] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 5, 0, 0), - [521] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 5, 0, 0), - [523] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 2, 0, 0), - [525] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 2, 0, 0), - [527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 2, 0, 0), - [529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 2, 0, 0), - [531] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), - [533] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), - [535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 7), - [537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 7), - [539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 5, 0, 17), - [541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 5, 0, 17), - [543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 5, 0, 0), - [545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 5, 0, 0), + [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 7), + [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 7), + [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_constraint, 4, 0, 13), + [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_constraint, 4, 0, 13), + [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 5, 0, 0), + [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 5, 0, 0), + [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 3, 0, 0), + [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 3, 0, 0), + [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 6, 0, 16), + [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 6, 0, 16), + [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_expression, 4, 0, 14), + [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_expression, 4, 0, 14), + [491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 4), + [493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 4), + [495] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 4, 0, 14), + [497] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 4, 0, 14), + [499] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 6, 0, 19), + [501] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 6, 0, 19), + [503] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 6, 0, 0), + [505] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 6, 0, 0), + [507] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_constraint, 2, 0, 3), + [509] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_constraint, 2, 0, 3), + [511] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_expression, 2, 0, 2), + [513] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_expression, 2, 0, 2), + [515] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 7), + [517] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 7), + [519] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 2, 0, 0), + [521] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 2, 0, 0), + [523] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 0, 16), + [525] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 0, 16), + [527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_constraint, 5, 0, 13), + [529] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_constraint, 5, 0, 13), + [531] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 0, 16), + [533] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 0, 16), + [535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 2, 0, 0), + [537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 2, 0, 0), + [539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_path_expression, 3, 0, 6), + [541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_path_expression, 3, 0, 6), + [543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 7), + [545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 7), [547] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1, 0, 0), [549] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1, 0, 0), - [551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), - [555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [557] = {.entry = {.count = 1, .reusable = false}}, SHIFT(70), - [559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [569] = {.entry = {.count = 1, .reusable = false}}, SHIFT(66), - [571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [573] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), - [575] = {.entry = {.count = 1, .reusable = false}}, SHIFT(56), - [577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), - [579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [581] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), - [585] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), - [587] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 1), - [589] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), REDUCE(sym_parameter, 1, 0, 1), - [592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), - [596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), - [600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), - [604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [606] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0), - [608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 19), - [610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 15), - [612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), - [614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), - [618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [628] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 2, 0, 0), - [630] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 2, 0, 0), - [632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), - [636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [638] = {.entry = {.count = 1, .reusable = false}}, SHIFT(210), - [640] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), - [642] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40), - [644] = {.entry = {.count = 1, .reusable = false}}, SHIFT(32), - [646] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_let_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(210), - [649] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_let_expression_repeat1, 2, 0, 0), - [651] = {.entry = {.count = 1, .reusable = false}}, SHIFT(26), - [653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), - [655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), - [661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [667] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0), SHIFT_REPEAT(31), - [670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [674] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(12), - [677] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), - [679] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_path, 2, 0, 0), - [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), - [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), - [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), - [687] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(221), - [690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_expression_repeat1, 2, 0, 0), - [692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), - [694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), - [696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), - [698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), - [704] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_path_repeat1, 2, 0, 0), - [706] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_path_repeat1, 2, 0, 0), SHIFT_REPEAT(234), - [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), - [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), - [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), - [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 5, 0, 18), + [555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 5, 0, 18), + [557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), + [559] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), + [561] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 5, 0, 0), + [563] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 5, 0, 0), + [565] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), + [567] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [569] = {.entry = {.count = 1, .reusable = false}}, SHIFT(70), + [571] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [573] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [575] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [577] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [579] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [581] = {.entry = {.count = 1, .reusable = false}}, SHIFT(66), + [583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [585] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), + [587] = {.entry = {.count = 1, .reusable = false}}, SHIFT(56), + [589] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [591] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [593] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 1), + [601] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), REDUCE(sym_parameter, 1, 0, 1), + [604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [614] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0), + [616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [620] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_rest, 2, 0, 17), + [622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 20), + [624] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 15), + [626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [640] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 2, 0, 0), + [642] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 2, 0, 0), + [644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [664] = {.entry = {.count = 1, .reusable = false}}, SHIFT(207), + [666] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), + [668] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40), + [670] = {.entry = {.count = 1, .reusable = false}}, SHIFT(32), + [672] = {.entry = {.count = 1, .reusable = false}}, SHIFT(71), + [674] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_let_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(207), + [677] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_let_expression_repeat1, 2, 0, 0), + [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), + [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [687] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0), SHIFT_REPEAT(28), + [690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), + [692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), + [696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [698] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_path_repeat1, 2, 0, 0), + [700] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_path_repeat1, 2, 0, 0), SHIFT_REPEAT(247), + [703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), + [711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [715] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), [717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), - [719] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), - [727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_path, 1, 0, 0), - [729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), - [731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), - [733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), - [735] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), - [737] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [739] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_object_repeat1, 2, 0, 0), SHIFT_REPEAT(199), - [742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_repeat1, 2, 0, 0), - [744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), - [746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), - [760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), - [770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), - [772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [774] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), - [778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_path, 1, 0, 0), + [721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), + [725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [731] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [733] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(234), + [736] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_expression_repeat1, 2, 0, 0), + [738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), + [748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [750] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(12), + [753] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), + [755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [757] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_path, 2, 0, 0), + [759] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_object_repeat1, 2, 0, 0), SHIFT_REPEAT(206), + [762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_repeat1, 2, 0, 0), + [764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), + [770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), [788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [790] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), + [804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), }; #ifdef __cplusplus diff --git a/examples/open-object.dcdl b/examples/open-object.dcdl new file mode 100644 index 0000000..7f6f11c --- /dev/null +++ b/examples/open-object.dcdl @@ -0,0 +1,11 @@ +OpenConfig = { + enabled = Bool default true; + ...Unknown +}; + +config = { + enabled = false; + plugin = { + name = "cache"; + }; +} as OpenConfig; diff --git a/packages/decodal-codemirror/src/decodal-parser-jsr.js b/packages/decodal-codemirror/src/decodal-parser-jsr.js index 60a27de..d04e026 100644 --- a/packages/decodal-codemirror/src/decodal-parser-jsr.js +++ b/packages/decodal-codemirror/src/decodal-parser-jsr.js @@ -1,18 +1,18 @@ // This file was generated by lezer-generator. You probably shouldn't edit it. import {LRParser} from "npm:@lezer/lr@^1.4.10" -const spec_Identifier = {__proto__:null,as:182} +const spec_Identifier = {__proto__:null,as:184} export const parser = LRParser.deserialize({ version: 14, - states: "9zQYQPOOO#qQPO'#CaOOQO'#Cs'#CsO$zQPO'#CzO&XQQO'#DTO&dQQO'#DZO&nQPO'#D[O&vQPO'#CrO$zQPO'#DgO'QQPO'#DlOOQO'#Cr'#CrOOQO'#Cq'#CqO'VQPO'#CpO$zQPO'#CpOOQO'#Co'#CoO)rQPO'#CnO.kQPO'#CmO0rQPO'#ClOOQO'#Ck'#CkO2mQPO'#CjO4eQPO'#CiO6YQPO'#ChO7wQPO'#CgOOQO'#Cf'#CfO8RQPO'#CeO9iQPO'#C`O9nQPO'#C_OOQO'#EP'#EPQYQPOOO;RQPO'#EQO;WQPO,58{OOQO,59f,59fO;`QPO'#CaO$zQPO,59kOOQO,59o,59oO;hQPO,59oO$zQPO,59qOOQO,59u,59uO;pQPO,59uO;xQPO'#ETO;}QPO'#D^OQQPO1G/aO>XQPO1G/aOOQO1G/a1G/aOOQO,5:o,5:oOOQO-E8R-E8RO$zQPO1G/bO$zQPO,59}O>aQPO,59|O>iQPO,59|O$zQPO1G/fO>qQQO1G/fOOQO1G.x1G.xO>vQPO1G/mO?QQPO'#DoOOQO,5:Y,5:YO?YQPO,5:YOOQO1G.w1G.wOOQO1G.u1G.uO?_QPO1G.tOB{QPO1G.sODjQPO1G.rOOQO1G.q1G.qOFeQPO1G.pOH]QPO1G.oOJQQPO1G.nOOQO1G.m1G.mOOQO1G.l1G.lOOQO1G.f1G.fOOQO1G.t1G.tOOQO1G.s1G.sOOQO1G.r1G.rOOQO1G.p1G.pOOQO1G.o1G.oOOQO1G.n1G.nOOQO7+$q7+$qOOQO,5:m,5:mOOQO7+$u7+$uOKdQPO7+$uOOQO-E8P-E8POOQO7+$w7+$wOKlQPO7+$wOOQO,5:n,5:nOOQO7+${7+${OKqQPO7+${OOQO-E8Q-E8QOOQO7+$|7+$|OOQO1G/i1G/iOKxQPO'#DcOOQO,5:p,5:pOK}QPO1G/hOOQO-E8S-E8SOOQO7+%Q7+%QO$zQPO7+%QOOQO'#Dj'#DjOLVQPO'#DiOOQO7+%X7+%XOL[QPO7+%XOLdQPO,5:ZOLkQPO,5:ZOOQO1G/t1G/tOOQO<_AN>_OMhQPOAN>_OOQO-E8T-E8TOOQOG23yG23yP>yQPO'#EVO$zQPO,59YO$zQPO,59XO$zQPO,59WO$zQPO,59UO$zQPO,59TO$zQPO,59SOMrQPO1G.sONYQPO'#CmONmQPO'#ClO! aQPO'#CiO!!aQPO'#ChO!#dQPO'#CgO$zQPO,59XO$zQPO,59VO$zQPO,59RO$zQPO,59QO!$mQPO1G.rO!%TQPO'#ClO!&eQPO'#CjO!'bQPO'#CeO$zQPO,59WO$zQPO,59VO$zQPO,59UO$zQPO,59TO$zQPO,59SO$zQPO,59RO$zQPO,59QO$zQPO,58zO!(kQPO1G.pO!)RQPO1G.oO!)iQPO1G.nO!*PQPO'#CjO!*zQPO'#CiO!+rQPO'#ChO!,gQPO'#CgO!-XQPO'#CeO!-sQPO'#C`", - stateData: "!.V~O!|OSPOS~OUPOhQOiQOjQOkQOlQOmQOoROpROqROrROtSOzTO!PUO!TVO![WO!aXO!d]O!e]O~OofXpfXqfXrfX!TfX!efX!ffX!gfX!hfX!ifX!kfX!lfX!mfX!nfX!ofX!pfX!qfX!}fX~OVmOUfXWTXhfXifXjfXkfXlfXmfXtfXxfXzfX!PfX![fX!afX!dfX!zfX~P!gOUYOhQOiQOjQOkQOlQOmQOoROpROqROrROtSOzTO!PUO!TVO![WO!aXO!d]O!e]O~OUpOuqOvrO~OutO|uO~P$zOUpO!R!QP~OUzO!X|O~P]Oh!QO~OV!TO!T!ROUdXhdXidXjdXkdXldXmdXodXpdXqdXrdXtdXxdXzdX!PdX![dX!adX!ddX!edX!fdX!gdX!hdX!idX!kdX!ldX!mdX!ndX!odX!pdX!qdX!zdX!}dX{dX|dX!XdXvdX!WdX~O!f!VO!g!VOUbXhbXibXjbXkbXlbXmbXobXpbXqbXrbXtbXxbXzbX!PbX!TbX![bX!abX!dbX!ebX!hbX!ibX!kbX!lbX!mbX!nbX!obX!pbX!qbX!zbX!}bXVbX{bX|bX!XbXvbX!WbX~OUaXhaXiaXjaXkaXlaXmaXoaXpaXqaXraXtaXxaXzaX!PaX!TaX![aX!aaX!daX!iaX!kaX!laX!maX!naX!oaX!paX!qaX!zaX!}aX{aX|aX!XaXvaX!WaX~O!e!WO!h!WO~P,_Oo!YOp!YOq!YOr!YO!k!YO!l!YOU`Xh`Xi`Xj`Xk`Xl`Xm`Xt`Xx`Xz`X!P`X!T`X![`X!a`X!d`X!e`X!m`X!n`X!o`X!p`X!q`X!z`X!}`X~O!i!XO~P.uOU^Xh^Xi^Xj^Xk^Xl^Xm^Xo^Xp^Xq^Xr^Xt^Xx^Xz^X!P^X!T^X![^X!a^X!d^X!e^X!n^X!o^X!p^X!q^X!z^X!}^X~O!m![O~P0yOU]Xh]Xi]Xj]Xk]Xl]Xm]Xo]Xp]Xq]Xr]Xt]Xx]Xz]X!P]X!T]X![]X!a]X!d]X!e]X!o]X!p]X!q]X!z]X!}]X~O!n!]O~P2tOU[Xh[Xi[Xj[Xk[Xl[Xm[Xo[Xp[Xq[Xr[Xt[Xx[Xz[X!P[X!T[X![[X!a[X!d[X!e[X!p[X!q[X!z[X!}[X~O!o!^O~P4lOUZXhZXiZXjZXkZXlZXmZXoZXpZXqZXrZXtZXxZXzZX!PZX!TZX![ZX!aZX!dZX!eZX!zZX!}ZX~O!p!_O!q!`O~P6aO!}!aOUXXhXXiXXjXXkXXlXXmXXoXXpXXqXXrXXtXXxXXzXX!PXX!TXX![XX!aXX!dXX!eXX!zXX~OW!cO~Ox!dOURXhRXiRXjRXkRXlRXmRXoRXpRXqRXrRXtRXzRX!PRX!TRX![RX!aRX!dRX!eRX!zRX~OU!fO~OVmOWTa~OVmOWTX~Ov!kOx!iO~O{!mO|!oO~Ox!pO~OUpO!R!QX~O!R!rO~O!W!sOVfX!XfX~P!gO{!tO!X!UX~O!Y!vO~O!X!wO~O!X!xO~Ot!yO~O!X!{O~P$zOU!}O~Ov#aO~OUpOv#cO~Ov#cOx#dO~O{#gO|#fO~O|#iO~P$zO{#jO|#iO~OU#nO!X!Ua~O{#pO!X!Ua~O!Y#sO~Ov#vO!_#tO~P$zO{#xO!X!cX~O!X#zO~O!f!VO!g!VOUbihbiibijbikbilbimbiobipbiqbirbitbixbizbi!Pbi!Tbi![bi!abi!dbi!ebi!hbi!ibi!kbi!lbi!mbi!nbi!obi!pbi!qbi!zbi!}bi{bi|bi!Xbivbi!Wbi~O!h!WOoaipaiqairaitaixai!iai!kai!lai!mai!nai!oai!pai!qai!}ai~OUaihaiiaijaikailaimaizai!Pai!Tai![ai!aai!dai!eai!zai~PAwOt`ix`i!m`i!n`i!o`i!p`i!q`i!}`i~O!i!XOU`ih`ii`ij`ik`il`im`io`ip`iq`ir`iz`i!P`i!T`i![`i!a`i!d`i!e`i!z`i~PDOOt^ix^i!n^i!o^i!p^i!q^i!}^i~O!m![OU^ih^ii^ij^ik^il^im^io^ip^iq^ir^iz^i!P^i!T^i![^i!a^i!d^i!e^i!z^i~PE|Ot]ix]i!o]i!p]i!q]i!}]i~O!n!]OU]ih]ii]ij]ik]il]im]io]ip]iq]ir]iz]i!P]i!T]i![]i!a]i!d]i!e]i!z]i~PGwOt[ix[i!p[i!q[i!}[i~O!o!^OU[ih[ii[ij[ik[il[im[io[ip[iq[ir[iz[i!P[i!T[i![[i!a[i!d[i!e[i!z[i~PIoOUpOv#{O~O|#}O~O|$OO~P$zO!W!sO~OU#nO!X!Ui~O!W$SO~Ov$VOx$TO~O!X!ca~P$zO{$WO!X!ca~OUpO~OU#nO~Ov$ZO!_#tO~P$zOv$ZOx$[O~O!X!ci~P$zOv$^O!_#tO~P$zO!e!WO{ai|ai!Xaivai!Wai~PAwO!e$`O!h$`OVaX!faX!gaX~P,_O!i$aOV`X!f`X!g`X!h`X{`X|`X!X`Xv`X!W`X~P.uO!n$cOV]X!f]X!g]X!h]X!i]X!k]X!l]X!m]X{]X|]X!X]Xv]X!W]X~P2tO!o$dOV[X!f[X!g[X!h[X!i[X!k[X!l[X!m[X!n[X{[X|[X!X[Xv[X!W[X~P4lO!p$eO!q$nOVZX!fZX!gZX!hZX!iZX!kZX!lZX!mZX!nZX!oZX{ZX|ZX!XZXvZX!WZX~P6aO!i$lO{`i|`i!X`iv`i!W`i~PDOOo!YOp!YOq!YOr!YO!i$lO!k!YO!l!YO{`X|`X!m`X!n`X!o`X!p`X!q`X!}`X!X`Xt`Xv`Xx`X!W`X~O!m$mOV^X!f^X!g^X!h^X!i^X!k^X!l^X{^X|^X!X^Xv^X!W^X~P0yOVXX!fXX!gXX!hXX!iXX!kXX!lXX!mXX!nXX!oXX!pXX!qXX{XX|XX!XXXvXX!WXX~P8RO!m$uO{^i|^i!X^iv^i!W^i~PE|O!n$vO{]i|]i!X]iv]i!W]i~PGwO!o$wO{[i|[i!X[iv[i!W[i~PIoO!m$uO{^X|^X!n^X!o^X!p^X!q^X!}^X!X^Xt^Xv^Xx^X!W^X~O!n$vO{]X|]X!o]X!p]X!q]X!}]X!X]Xt]Xv]Xx]X!W]X~O!o$wO{[X|[X!p[X!q[X!}[X!X[Xt[Xv[Xx[X!W[X~O!p$xO!q$yO{ZX|ZX!}ZX!XZXtZXvZXxZX!WZX~O!}!aO{XX|XX!XXXtXXvXXxXX!WXX~OW${O~O!P!R![!a!qklji!_Uk~", - goto: "6W!zPPP!{#P#aPPP#m$x%i&`'V(V)Y*`+a,m-z/V0d1m2vPPPPPP2vPPPP2vPPP2vP2vPPP2v2vP4PP2vP4S4VPPP2vP4_4gP2vP4m4pPPPPPP4sPPPPPPP4|5V5]5d5j5t5z6QTkOlSjOlQsSSwUxV#b!i#d#|SiOl]%USUx!i#d#|SjOlQoRQvTQ!OVQ!PWQ!hqQ!ltQ!z!RS#Y!c${Y#h!m#j#x$P$WQ#l!rQ#m!sQ#r!vW#t!y$T$[$_Q$R#sR$X$SUhOl!cW$sR!r!v#su%TTVWqt!R!m!s!y#j#x$P$S$T$W$[$_${!SgORTVWlqt!R!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_${U#W!`$n$yV#X!b$o$zYfOl!`!b!c[$kR!r!v#s$n$oy%STVWqt!R!m!s!y#j#x$P$S$T$W$[$_$y$z${YeOl!`!b!cQ#V!_Q#`$e[$jR!r!v#s$n$oQ%O$xy%RTVWqt!R!m!s!y#j#x$P$S$T$W$[$_$y$z${[dOl!_!`!b!cQ#U!^Q#_$d^$iR!r!v#s$e$n$oQ$}$w{%QTVWqt!R!m!s!y#j#x$P$S$T$W$[$_$x$y$z${^cOl!^!_!`!b!cQ#T!]Q#^$c`$rR!r!v#s$d$e$n$oQ$|$v}%PTVWqt!R!m!s!y#j#x$P$S$T$W$[$_$w$x$y$z${!rbORTVWlqt!R!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$c$d$e$n$o$v$w$x$y$z${V#S![$m$ubaOl![!]!^!_!`!b!cQ#R!ZQ#]$bd$hR!r!v#s$c$d$e$m$n$oQ$p$t!R$qTVWqt!R!m!s!y#j#x$P$S$T$W$[$_$u$v$w$x$y$z${!h`OTVWlqt!R!Z![!]!^!_!`!b!c!m!s!y#j#x$P$S$T$W$[$_$t$u$v$w$x$y$z${Q#Q!XQ#[$aQ$f$lg$gR!r!v#s$b$c$d$e$m$n$o#U_ORTVWlqt!R!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${Q#P!WR#Z$`#Y^ORTVWlqt!R!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$`$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${Q!U]R#O!V#_[ORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$`$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${#_ZORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$`$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${#_YORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$`$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${RyUR}VQ{VV#o!t#p$QQ#w!yV$Y$T$[$_X#u!y$T$[$_R!S[R!|!RQ!ZaQ$b$hR$t$qQ!bhQ$o$sR$z%TQlOR!elSnPpR!gnQ!jsR#e!jQ!nvS#k!n#yR#y!zQxUR!qxQ!u{R#q!uQ$U#wR$]$U", - nodeNames: "⚠ Comment Source Statement FieldDefinition FieldPath Identifier Dot Equal Expression AsExpression DefaultExpression PatchExpression ComposeExpression LogicalOrExpression LogicalAndExpression ComparisonExpression ConcatExpression AdditiveExpression MultiplicativeExpression UnaryExpression PostfixExpression PrimaryExpression Literal String Integer Float True False Regex ComparisonConstraint Lt Lte Gt Gte MapConstraint LBrace Ellipsis RBrace Object Semicolon ArrayConstraint LBracket Comma RBracket Array LetExpression Let FieldDefinitionList In FunctionExpression LParen ParameterList Parameter Colon RParen Arrow MatchExpression Match MatchArm Pattern Underscore ImportExpression Import CallSuffix ArgumentList Bang Minus Star Slash Plus PlusPlus CompareOperator EqualEqual BangEqual AmpAmp PipePipe Amp SlashSlash Default As", - maxTerm: 91, + states: ":|QYQPOOO#qQPO'#CaOOQO'#Cs'#CsO$zQPO'#CzO&XQQO'#DTO&dQQO'#D[O&nQPO'#D]O&vQPO'#CrO$zQPO'#DhO'QQPO'#DmOOQO'#Cr'#CrOOQO'#Cq'#CqO'VQPO'#CpO$zQPO'#CpOOQO'#Co'#CoO)rQPO'#CnO.kQPO'#CmO0rQPO'#ClOOQO'#Ck'#CkO2mQPO'#CjO4eQPO'#CiO6YQPO'#ChO7wQPO'#CgOOQO'#Cf'#CfO8RQPO'#CeO9iQPO'#C`O9nQPO'#C_OOQO'#EQ'#EQQYQPOOO;RQPO'#ERO;WQPO,58{OOQO,59f,59fO;`QPO'#CaO$zQPO,59kOOQO,59o,59oO;hQPO,59oO$zQPO,59rOOQO,59v,59vO;pQPO,59vO;xQPO'#EUO;}QPO'#D_OTQPO1G/bO>[QPO1G/bOOQO1G/b1G/bOOQO,5:p,5:pOOQO-E8S-E8SO$zQPO1G/cO$zQPO,5:OO>dQPO,59}O>lQPO,59}O$zQPO1G/gO>tQQO1G/gOOQO1G.x1G.xO>yQPO1G/nO?TQPO'#DpOOQO,5:Z,5:ZO?]QPO,5:ZOOQO1G.w1G.wOOQO1G.u1G.uO?bQPO1G.tOCOQPO1G.sODmQPO1G.rOOQO1G.q1G.qOFhQPO1G.pOH`QPO1G.oOJTQPO1G.nOOQO1G.m1G.mOOQO1G.l1G.lOOQO1G.f1G.fOOQO1G.t1G.tOOQO1G.s1G.sOOQO1G.r1G.rOOQO1G.p1G.pOOQO1G.o1G.oOOQO1G.n1G.nOOQO7+$q7+$qOOQO,5:n,5:nO$zQPO'#DVOOQO7+$u7+$uOKgQPO7+$uOKoQQO7+$uOOQO-E8Q-E8QOOQO7+$x7+$xOKzQPO7+$xOOQO,5:o,5:oOOQO7+$|7+$|OLPQPO7+$|OOQO-E8R-E8ROOQO7+$}7+$}OOQO1G/j1G/jOLWQPO'#DdOOQO,5:q,5:qOL]QPO1G/iOOQO-E8T-E8TOOQO7+%R7+%RO$zQPO7+%ROOQO'#Dk'#DkOLeQPO'#DjOOQO7+%Y7+%YOLjQPO7+%YOLrQPO,5:[OLyQPO,5:[OOQO1G/u1G/uOOQO,59q,59qOOQO<`AN>`ONYQPOAN>`OOQO-E8U-E8UOOQOG23gG23gOOQOG23zG23zP>|QPO'#EWO$zQPO,59YO$zQPO,59XO$zQPO,59WO$zQPO,59UO$zQPO,59TO$zQPO,59SONdQPO1G.sONzQPO'#CmO! _QPO'#ClO!!RQPO'#CiO!#RQPO'#ChO!$UQPO'#CgO$zQPO,59XO$zQPO,59VO$zQPO,59RO$zQPO,59QO!%_QPO1G.rO!%uQPO'#ClO!'VQPO'#CjO!(SQPO'#CeO$zQPO,59WO$zQPO,59VO$zQPO,59UO$zQPO,59TO$zQPO,59SO$zQPO,59RO$zQPO,59QO$zQPO,58zO!)]QPO1G.pO!)sQPO1G.oO!*ZQPO1G.nO!*qQPO'#CjO!+lQPO'#CiO!,dQPO'#ChO!-XQPO'#CgO!-yQPO'#CeO!.eQPO'#C`", + stateData: "!.w~O!}OSPOS~OUPOhQOiQOjQOkQOlQOmQOoROpROqROrROtSO{TO!QUO!UVO!]WO!bXO!e]O!f]O~OofXpfXqfXrfX!UfX!ffX!gfX!hfX!ifX!jfX!lfX!mfX!nfX!ofX!pfX!qfX!rfX#OfX~OVmOUfXWTXhfXifXjfXkfXlfXmfXtfXxfX{fX!QfX!]fX!bfX!efX!{fX~P!gOUYOhQOiQOjQOkQOlQOmQOoROpROqROrROtSO{TO!QUO!UVO!]WO!bXO!e]O!f]O~OUpOuqOvrO~OutO}uO~P$zOUpO!S!RP~OUzO!Y|O~P]Oh!QO~OV!TO!U!ROUdXhdXidXjdXkdXldXmdXodXpdXqdXrdXtdXxdX{dX!QdX!]dX!bdX!edX!fdX!gdX!hdX!idX!jdX!ldX!mdX!ndX!odX!pdX!qdX!rdX!{dX#OdX|dX}dX!YdXvdX!XdX~O!g!VO!h!VOUbXhbXibXjbXkbXlbXmbXobXpbXqbXrbXtbXxbX{bX!QbX!UbX!]bX!bbX!ebX!fbX!ibX!jbX!lbX!mbX!nbX!obX!pbX!qbX!rbX!{bX#ObXVbX|bX}bX!YbXvbX!XbX~OUaXhaXiaXjaXkaXlaXmaXoaXpaXqaXraXtaXxaX{aX!QaX!UaX!]aX!baX!eaX!jaX!laX!maX!naX!oaX!paX!qaX!raX!{aX#OaX|aX}aX!YaXvaX!XaX~O!f!WO!i!WO~P,_Oo!YOp!YOq!YOr!YO!l!YO!m!YOU`Xh`Xi`Xj`Xk`Xl`Xm`Xt`Xx`X{`X!Q`X!U`X!]`X!b`X!e`X!f`X!n`X!o`X!p`X!q`X!r`X!{`X#O`X~O!j!XO~P.uOU^Xh^Xi^Xj^Xk^Xl^Xm^Xo^Xp^Xq^Xr^Xt^Xx^X{^X!Q^X!U^X!]^X!b^X!e^X!f^X!o^X!p^X!q^X!r^X!{^X#O^X~O!n![O~P0yOU]Xh]Xi]Xj]Xk]Xl]Xm]Xo]Xp]Xq]Xr]Xt]Xx]X{]X!Q]X!U]X!]]X!b]X!e]X!f]X!p]X!q]X!r]X!{]X#O]X~O!o!]O~P2tOU[Xh[Xi[Xj[Xk[Xl[Xm[Xo[Xp[Xq[Xr[Xt[Xx[X{[X!Q[X!U[X!][X!b[X!e[X!f[X!q[X!r[X!{[X#O[X~O!p!^O~P4lOUZXhZXiZXjZXkZXlZXmZXoZXpZXqZXrZXtZXxZX{ZX!QZX!UZX!]ZX!bZX!eZX!fZX!{ZX#OZX~O!q!_O!r!`O~P6aO#O!aOUXXhXXiXXjXXkXXlXXmXXoXXpXXqXXrXXtXXxXX{XX!QXX!UXX!]XX!bXX!eXX!fXX!{XX~OW!cO~Ox!dOURXhRXiRXjRXkRXlRXmRXoRXpRXqRXrRXtRX{RX!QRX!URX!]RX!bRX!eRX!fRX!{RX~OU!fO~OVmOWTa~OVmOWTX~Ov!kOx!iO~O|!mO}!oO~Ox!pO~OUpO!S!RX~O!S!rO~O!X!sOVfX!YfX~P!gO|!tO!Y!VX~O!Z!vO~O!Y!wO~O!Y!xO~Ot!yO~O!Y!{O~P$zOU!}O~Ov#aO~OUpOu#cOv#dO~Ov#dOx#fO~O|#iO}#hO~O}#kO~P$zO|#lO}#kO~OU#pO!Y!Va~O|#rO!Y!Va~O!Z#uO~Ov#xO!`#vO~P$zO|#zO!Y!dX~O!Y#|O~O!g!VO!h!VOUbihbiibijbikbilbimbiobipbiqbirbitbixbi{bi!Qbi!Ubi!]bi!bbi!ebi!fbi!ibi!jbi!lbi!mbi!nbi!obi!pbi!qbi!rbi!{bi#Obi|bi}bi!Ybivbi!Xbi~O!i!WOoaipaiqairaitaixai!jai!lai!mai!nai!oai!pai!qai!rai#Oai~OUaihaiiaijaikailaimai{ai!Qai!Uai!]ai!bai!eai!fai!{ai~PAzOt`ix`i!n`i!o`i!p`i!q`i!r`i#O`i~O!j!XOU`ih`ii`ij`ik`il`im`io`ip`iq`ir`i{`i!Q`i!U`i!]`i!b`i!e`i!f`i!{`i~PDROt^ix^i!o^i!p^i!q^i!r^i#O^i~O!n![OU^ih^ii^ij^ik^il^im^io^ip^iq^ir^i{^i!Q^i!U^i!]^i!b^i!e^i!f^i!{^i~PFPOt]ix]i!p]i!q]i!r]i#O]i~O!o!]OU]ih]ii]ij]ik]il]im]io]ip]iq]ir]i{]i!Q]i!U]i!]]i!b]i!e]i!f]i!{]i~PGzOt[ix[i!q[i!r[i#O[i~O!p!^OU[ih[ii[ij[ik[il[im[io[ip[iq[ir[i{[i!Q[i!U[i!][i!b[i!e[i!f[i!{[i~PIrOv$OOx$PO~OUpOu#cOv$OO~O}$SO~O}$TO~P$zO!X!sO~OU#pO!Y!Vi~O!X$XO~Ov$[Ox$YO~O!Y!da~P$zO|$]O!Y!da~Ov$^O~Ov$^Ox$_O~OUpO~OU#pO~Ov$bO!`#vO~P$zOv$bOx$cO~O!Y!di~P$zOv$eO~Ov$fO!`#vO~P$zO!f!WO|ai}ai!Yaivai!Xai~PAzO!f$hO!i$hOVaX!gaX!haX~P,_O!j$iOV`X!g`X!h`X!i`X|`X}`X!Y`Xv`X!X`X~P.uO!o$kOV]X!g]X!h]X!i]X!j]X!l]X!m]X!n]X|]X}]X!Y]Xv]X!X]X~P2tO!p$lOV[X!g[X!h[X!i[X!j[X!l[X!m[X!n[X!o[X|[X}[X!Y[Xv[X!X[X~P4lO!q$mO!r$vOVZX!gZX!hZX!iZX!jZX!lZX!mZX!nZX!oZX!pZX|ZX}ZX!YZXvZX!XZX~P6aO!j$tO|`i}`i!Y`iv`i!X`i~PDROo!YOp!YOq!YOr!YO!j$tO!l!YO!m!YO|`X}`X!n`X!o`X!p`X!q`X!r`X#O`X!Y`Xt`Xv`Xx`X!X`X~O!n$uOV^X!g^X!h^X!i^X!j^X!l^X!m^X|^X}^X!Y^Xv^X!X^X~P0yOVXX!gXX!hXX!iXX!jXX!lXX!mXX!nXX!oXX!pXX!qXX!rXX|XX}XX!YXXvXX!XXX~P8RO!n$}O|^i}^i!Y^iv^i!X^i~PFPO!o%OO|]i}]i!Y]iv]i!X]i~PGzO!p%PO|[i}[i!Y[iv[i!X[i~PIrO!n$}O|^X}^X!o^X!p^X!q^X!r^X#O^X!Y^Xt^Xv^Xx^X!X^X~O!o%OO|]X}]X!p]X!q]X!r]X#O]X!Y]Xt]Xv]Xx]X!X]X~O!p%PO|[X}[X!q[X!r[X#O[X!Y[Xt[Xv[Xx[X!X[X~O!q%QO!r%RO|ZX}ZX#OZX!YZXtZXvZXxZX!XZX~O#O!aO|XX}XX!YXXtXXvXXxXX!XXX~OW%TO~O!Q!S!]!b!rklji!`Uk~", + goto: "6p!{PPP!|#Q#bPPP#n$|%n&f'^(_)c*j+l,y.X/e0s1}3XPPPPPP3XPPPP3XPPP3XP4c3XPPP3X3XP4iP3XP4l4oPPP3XP4w5PP3XP5V5YPPPPPP5]PPPPPPP5f5o5u5|6S6^6d6jTkOlSjOlQsSSwUxV#b!i#f$RSiOl]%^SUx!i#f$RSjOlQoRQvTQ!OVQ!PWQ!hqQ!ltQ!z!RS#Y!c%TY#j!m#l#z$U$]Q#n!rQ#o!sQ#t!vW#v!y$Y$c$gQ#}#cQ$W#uR$`$XUhOl!cW${R!r!v#uw%]TVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%T!UgORTVWlqt!R!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g%TU#W!`$v%RV#X!b$w%SYfOl!`!b!c[$sR!r!v#u$v$w{%[TVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%R%S%TYeOl!`!b!cQ#V!_Q#`$m[$rR!r!v#u$v$wQ%W%Q{%ZTVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%R%S%T[dOl!_!`!b!cQ#U!^Q#_$l^$qR!r!v#u$m$v$wQ%V%P}%YTVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%Q%R%S%T^cOl!^!_!`!b!cQ#T!]Q#^$k`$zR!r!v#u$l$m$v$wQ%U%O!P%XTVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%P%Q%R%S%T!tbORTVWlqt!R!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$k$l$m$v$w%O%P%Q%R%S%TV#S![$u$}baOl![!]!^!_!`!b!cQ#R!ZQ#]$jd$pR!r!v#u$k$l$m$u$v$wQ$x$|!T$yTVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g$}%O%P%Q%R%S%T!j`OTVWlqt!R!Z![!]!^!_!`!b!c!m!s!y#c#l#z$U$X$Y$]$c$g$|$}%O%P%Q%R%S%TQ#Q!XQ#[$iQ$n$tg$oR!r!v#u$j$k$l$m$u$v$w#W_ORTVWlqt!R!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%TQ#P!WR#Z$h#[^ORTVWlqt!R!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$h$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%TQ!U]R#O!V#a[ORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$h$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%T#aZORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$h$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%T#aYORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$h$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%TQ#e!iR$Q#fRyUR}VQ{VV#q!t#r$VQ#y!yV$a$Y$c$gX#w!y$Y$c$gR!S[R!|!RQ!ZaQ$j$pR$|$yQ!bhQ$w${R%S%]QlOR!elSnPpR!gnQ!jsR#g!jQ!nvS#m!n#{R#{!zQxUR!qxQ!u{R#s!uQ$Z#yR$d$Z", + nodeNames: "⚠ Comment Source Statement FieldDefinition FieldPath Identifier Dot Equal Expression AsExpression DefaultExpression PatchExpression ComposeExpression LogicalOrExpression LogicalAndExpression ComparisonExpression ConcatExpression AdditiveExpression MultiplicativeExpression UnaryExpression PostfixExpression PrimaryExpression Literal String Integer Float True False Regex ComparisonConstraint Lt Lte Gt Gte MapConstraint LBrace Ellipsis RBrace Object Semicolon ObjectRest ArrayConstraint LBracket Comma RBracket Array LetExpression Let FieldDefinitionList In FunctionExpression LParen ParameterList Parameter Colon RParen Arrow MatchExpression Match MatchArm Pattern Underscore ImportExpression Import CallSuffix ArgumentList Bang Minus Star Slash Plus PlusPlus CompareOperator EqualEqual BangEqual AmpAmp PipePipe Amp SlashSlash Default As", + maxTerm: 92, skippedNodes: [0,1], repeatNodeCount: 7, - tokenData: "=c~R!PX^$Upq$Uqr$yrs%Wst&zvw'cxy'pyz'uz{'z{|(P|}(^}!O(c!O!P(h!P!Q({!Q![+c![!]+|!]!^,R!^!_,W!_!`,e!`!a,z!c!}-X!}#O-j#P#Q-o#R#S-t#T#W-X#W#X.X#X#Y-X#Y#Z1i#Z#]-X#]#^3y#^#`-X#`#a7]#a#b8p#b#h-X#h#i;Q#i#o-X#o#p<|#p#q=R#q#r=^#y#z$U$f$g$U#BY#BZ$U$IS$I_$U$I|$JO$U$JT$JU$U$KV$KW$U&FU&FV$U~$ZY!|~X^$Upq$U#y#z$U$f$g$U#BY#BZ$U$IS$I_$U$I|$JO$U$JT$JU$U$KV$KW$U&FU&FV$U~%OP!d~!_!`%R~%WO!l~~%ZWOY%WZr%Wrs%ss#O%W#O#P%x#P;'S%W;'S;=`&t<%lO%W~%xOh~~%{RO;'S%W;'S;=`&U;=`O%W~&XXOY%WZr%Wrs%ss#O%W#O#P%x#P;'S%W;'S;=`&t;=`<%l%W<%lO%W~&wP;=`<%l%W~'PSP~OY&zZ;'S&z;'S;=`']<%lO&z~'`P;=`<%l&z~'hP!o~vw'k~'pO!m~~'uO!T~~'zO!X~~(PO!f~~(UP!h~{|(X~(^O!i~~(cO{~~(hO!e~R(mPVP!O!P(pQ(sP!O!P(vQ({OuQ~)QW!g~OY)jZ!P)j!P!Q+^!Q#O)j#O#P*[#P;'S)j;'S;=`+W<%lO)j~)mWOY)jZ!P)j!P!Q*V!Q#O)j#O#P*[#P;'S)j;'S;=`+W<%lO)j~*[Om~~*_RO;'S)j;'S;=`*h;=`O)j~*kXOY)jZ!P)j!P!Q*V!Q#O)j#O#P*[#P;'S)j;'S;=`+W;=`<%l)j<%lO)j~+ZP;=`<%l)j~+cO!p~~+hQi~!O!P+n!Q![+c~+qP!Q![+t~+yPj~!Q![+t~,RO!W~~,WOx~~,]Po~!_!`,`~,eOp~~,jQWP!_!`,p!`!a,u~,uO!k~Q,zO!YQ~-PPq~!_!`-S~-XOr~~-^SU~!Q![-X!c!}-X#R#S-X#T#o-X~-oOz~~-tO|~~-{S!_~U~!Q![-X!c!}-X#R#S-X#T#o-X~.^UU~!Q![-X!c!}-X#R#S-X#T#X-X#X#Y.p#Y#o-X~.uUU~!Q![-X!c!}-X#R#S-X#T#Y-X#Y#Z/X#Z#o-X~/^TU~!Q![-X!c!}-X#R#S-X#T#U/m#U#o-X~/rUU~!Q![-X!c!}-X#R#S-X#T#i-X#i#j0U#j#o-X~0ZUU~!Q![-X!c!}-X#R#S-X#T#`-X#`#a0m#a#o-X~0rUU~!Q![-X!c!}-X#R#S-X#T#h-X#h#i1U#i#o-X~1]S!q~U~!Q![-X!c!}-X#R#S-X#T#o-X~1nTU~!Q![-X!c!}-X#R#S-X#T#U1}#U#o-X~2SUU~!Q![-X!c!}-X#R#S-X#T#`-X#`#a2f#a#o-X~2kUU~!Q![-X!c!}-X#R#S-X#T#g-X#g#h2}#h#o-X~3SUU~!Q![-X!c!}-X#R#S-X#T#X-X#X#Y3f#Y#o-X~3mSl~U~!Q![-X!c!}-X#R#S-X#T#o-X~4OVU~!Q![-X!c!}-X#R#S-X#T#a-X#a#b4e#b#c6x#c#o-X~4jUU~!Q![-X!c!}-X#R#S-X#T#d-X#d#e4|#e#o-X~5RUU~!Q![-X!c!}-X#R#S-X#T#c-X#c#d5e#d#o-X~5jUU~!Q![-X!c!}-X#R#S-X#T#f-X#f#g5|#g#o-X~6RUU~!Q![-X!c!}-X#R#S-X#T#h-X#h#i6e#i#o-X~6lS!a~U~!Q![-X!c!}-X#R#S-X#T#o-X~7PS!R~U~!Q![-X!c!}-X#R#S-X#T#o-X~7bUU~!Q![-X!c!}-X#R#S-X#T#X-X#X#Y7t#Y#o-X~7yUU~!Q![-X!c!}-X#R#S-X#T#h-X#h#i8]#i#o-X~8dS!P~U~!Q![-X!c!}-X#R#S-X#T#o-X~8uTU~!Q![-X!c!}-X#R#S-X#T#U9U#U#o-X~9ZUU~!Q![-X!c!}-X#R#S-X#T#h-X#h#i9m#i#o-X~9rUU~!Q![-X!c!}-X#R#S-X#T#V-X#V#W:U#W#o-X~:ZUU~!Q![-X!c!}-X#R#S-X#T#[-X#[#]:m#]#o-X~:tS![~U~!Q![-X!c!}-X#R#S-X#T#o-X~;VUU~!Q![-X!c!}-X#R#S-X#T#f-X#f#g;i#g#o-X~;nUU~!Q![-X!c!}-X#R#S-X#T#i-X#i#j spec_Identifier[value] || -1}], - tokenPrec: 2708 + tokenPrec: 2740 }) diff --git a/packages/decodal-codemirror/src/decodal-parser.js b/packages/decodal-codemirror/src/decodal-parser.js index 5b2f800..a1d14f1 100644 --- a/packages/decodal-codemirror/src/decodal-parser.js +++ b/packages/decodal-codemirror/src/decodal-parser.js @@ -1,18 +1,18 @@ // This file was generated by lezer-generator. You probably shouldn't edit it. import {LRParser} from "@lezer/lr" -const spec_Identifier = {__proto__:null,as:182} +const spec_Identifier = {__proto__:null,as:184} export const parser = LRParser.deserialize({ version: 14, - states: "9zQYQPOOO#qQPO'#CaOOQO'#Cs'#CsO$zQPO'#CzO&XQQO'#DTO&dQQO'#DZO&nQPO'#D[O&vQPO'#CrO$zQPO'#DgO'QQPO'#DlOOQO'#Cr'#CrOOQO'#Cq'#CqO'VQPO'#CpO$zQPO'#CpOOQO'#Co'#CoO)rQPO'#CnO.kQPO'#CmO0rQPO'#ClOOQO'#Ck'#CkO2mQPO'#CjO4eQPO'#CiO6YQPO'#ChO7wQPO'#CgOOQO'#Cf'#CfO8RQPO'#CeO9iQPO'#C`O9nQPO'#C_OOQO'#EP'#EPQYQPOOO;RQPO'#EQO;WQPO,58{OOQO,59f,59fO;`QPO'#CaO$zQPO,59kOOQO,59o,59oO;hQPO,59oO$zQPO,59qOOQO,59u,59uO;pQPO,59uO;xQPO'#ETO;}QPO'#D^OQQPO1G/aO>XQPO1G/aOOQO1G/a1G/aOOQO,5:o,5:oOOQO-E8R-E8RO$zQPO1G/bO$zQPO,59}O>aQPO,59|O>iQPO,59|O$zQPO1G/fO>qQQO1G/fOOQO1G.x1G.xO>vQPO1G/mO?QQPO'#DoOOQO,5:Y,5:YO?YQPO,5:YOOQO1G.w1G.wOOQO1G.u1G.uO?_QPO1G.tOB{QPO1G.sODjQPO1G.rOOQO1G.q1G.qOFeQPO1G.pOH]QPO1G.oOJQQPO1G.nOOQO1G.m1G.mOOQO1G.l1G.lOOQO1G.f1G.fOOQO1G.t1G.tOOQO1G.s1G.sOOQO1G.r1G.rOOQO1G.p1G.pOOQO1G.o1G.oOOQO1G.n1G.nOOQO7+$q7+$qOOQO,5:m,5:mOOQO7+$u7+$uOKdQPO7+$uOOQO-E8P-E8POOQO7+$w7+$wOKlQPO7+$wOOQO,5:n,5:nOOQO7+${7+${OKqQPO7+${OOQO-E8Q-E8QOOQO7+$|7+$|OOQO1G/i1G/iOKxQPO'#DcOOQO,5:p,5:pOK}QPO1G/hOOQO-E8S-E8SOOQO7+%Q7+%QO$zQPO7+%QOOQO'#Dj'#DjOLVQPO'#DiOOQO7+%X7+%XOL[QPO7+%XOLdQPO,5:ZOLkQPO,5:ZOOQO1G/t1G/tOOQO<_AN>_OMhQPOAN>_OOQO-E8T-E8TOOQOG23yG23yP>yQPO'#EVO$zQPO,59YO$zQPO,59XO$zQPO,59WO$zQPO,59UO$zQPO,59TO$zQPO,59SOMrQPO1G.sONYQPO'#CmONmQPO'#ClO! aQPO'#CiO!!aQPO'#ChO!#dQPO'#CgO$zQPO,59XO$zQPO,59VO$zQPO,59RO$zQPO,59QO!$mQPO1G.rO!%TQPO'#ClO!&eQPO'#CjO!'bQPO'#CeO$zQPO,59WO$zQPO,59VO$zQPO,59UO$zQPO,59TO$zQPO,59SO$zQPO,59RO$zQPO,59QO$zQPO,58zO!(kQPO1G.pO!)RQPO1G.oO!)iQPO1G.nO!*PQPO'#CjO!*zQPO'#CiO!+rQPO'#ChO!,gQPO'#CgO!-XQPO'#CeO!-sQPO'#C`", - stateData: "!.V~O!|OSPOS~OUPOhQOiQOjQOkQOlQOmQOoROpROqROrROtSOzTO!PUO!TVO![WO!aXO!d]O!e]O~OofXpfXqfXrfX!TfX!efX!ffX!gfX!hfX!ifX!kfX!lfX!mfX!nfX!ofX!pfX!qfX!}fX~OVmOUfXWTXhfXifXjfXkfXlfXmfXtfXxfXzfX!PfX![fX!afX!dfX!zfX~P!gOUYOhQOiQOjQOkQOlQOmQOoROpROqROrROtSOzTO!PUO!TVO![WO!aXO!d]O!e]O~OUpOuqOvrO~OutO|uO~P$zOUpO!R!QP~OUzO!X|O~P]Oh!QO~OV!TO!T!ROUdXhdXidXjdXkdXldXmdXodXpdXqdXrdXtdXxdXzdX!PdX![dX!adX!ddX!edX!fdX!gdX!hdX!idX!kdX!ldX!mdX!ndX!odX!pdX!qdX!zdX!}dX{dX|dX!XdXvdX!WdX~O!f!VO!g!VOUbXhbXibXjbXkbXlbXmbXobXpbXqbXrbXtbXxbXzbX!PbX!TbX![bX!abX!dbX!ebX!hbX!ibX!kbX!lbX!mbX!nbX!obX!pbX!qbX!zbX!}bXVbX{bX|bX!XbXvbX!WbX~OUaXhaXiaXjaXkaXlaXmaXoaXpaXqaXraXtaXxaXzaX!PaX!TaX![aX!aaX!daX!iaX!kaX!laX!maX!naX!oaX!paX!qaX!zaX!}aX{aX|aX!XaXvaX!WaX~O!e!WO!h!WO~P,_Oo!YOp!YOq!YOr!YO!k!YO!l!YOU`Xh`Xi`Xj`Xk`Xl`Xm`Xt`Xx`Xz`X!P`X!T`X![`X!a`X!d`X!e`X!m`X!n`X!o`X!p`X!q`X!z`X!}`X~O!i!XO~P.uOU^Xh^Xi^Xj^Xk^Xl^Xm^Xo^Xp^Xq^Xr^Xt^Xx^Xz^X!P^X!T^X![^X!a^X!d^X!e^X!n^X!o^X!p^X!q^X!z^X!}^X~O!m![O~P0yOU]Xh]Xi]Xj]Xk]Xl]Xm]Xo]Xp]Xq]Xr]Xt]Xx]Xz]X!P]X!T]X![]X!a]X!d]X!e]X!o]X!p]X!q]X!z]X!}]X~O!n!]O~P2tOU[Xh[Xi[Xj[Xk[Xl[Xm[Xo[Xp[Xq[Xr[Xt[Xx[Xz[X!P[X!T[X![[X!a[X!d[X!e[X!p[X!q[X!z[X!}[X~O!o!^O~P4lOUZXhZXiZXjZXkZXlZXmZXoZXpZXqZXrZXtZXxZXzZX!PZX!TZX![ZX!aZX!dZX!eZX!zZX!}ZX~O!p!_O!q!`O~P6aO!}!aOUXXhXXiXXjXXkXXlXXmXXoXXpXXqXXrXXtXXxXXzXX!PXX!TXX![XX!aXX!dXX!eXX!zXX~OW!cO~Ox!dOURXhRXiRXjRXkRXlRXmRXoRXpRXqRXrRXtRXzRX!PRX!TRX![RX!aRX!dRX!eRX!zRX~OU!fO~OVmOWTa~OVmOWTX~Ov!kOx!iO~O{!mO|!oO~Ox!pO~OUpO!R!QX~O!R!rO~O!W!sOVfX!XfX~P!gO{!tO!X!UX~O!Y!vO~O!X!wO~O!X!xO~Ot!yO~O!X!{O~P$zOU!}O~Ov#aO~OUpOv#cO~Ov#cOx#dO~O{#gO|#fO~O|#iO~P$zO{#jO|#iO~OU#nO!X!Ua~O{#pO!X!Ua~O!Y#sO~Ov#vO!_#tO~P$zO{#xO!X!cX~O!X#zO~O!f!VO!g!VOUbihbiibijbikbilbimbiobipbiqbirbitbixbizbi!Pbi!Tbi![bi!abi!dbi!ebi!hbi!ibi!kbi!lbi!mbi!nbi!obi!pbi!qbi!zbi!}bi{bi|bi!Xbivbi!Wbi~O!h!WOoaipaiqairaitaixai!iai!kai!lai!mai!nai!oai!pai!qai!}ai~OUaihaiiaijaikailaimaizai!Pai!Tai![ai!aai!dai!eai!zai~PAwOt`ix`i!m`i!n`i!o`i!p`i!q`i!}`i~O!i!XOU`ih`ii`ij`ik`il`im`io`ip`iq`ir`iz`i!P`i!T`i![`i!a`i!d`i!e`i!z`i~PDOOt^ix^i!n^i!o^i!p^i!q^i!}^i~O!m![OU^ih^ii^ij^ik^il^im^io^ip^iq^ir^iz^i!P^i!T^i![^i!a^i!d^i!e^i!z^i~PE|Ot]ix]i!o]i!p]i!q]i!}]i~O!n!]OU]ih]ii]ij]ik]il]im]io]ip]iq]ir]iz]i!P]i!T]i![]i!a]i!d]i!e]i!z]i~PGwOt[ix[i!p[i!q[i!}[i~O!o!^OU[ih[ii[ij[ik[il[im[io[ip[iq[ir[iz[i!P[i!T[i![[i!a[i!d[i!e[i!z[i~PIoOUpOv#{O~O|#}O~O|$OO~P$zO!W!sO~OU#nO!X!Ui~O!W$SO~Ov$VOx$TO~O!X!ca~P$zO{$WO!X!ca~OUpO~OU#nO~Ov$ZO!_#tO~P$zOv$ZOx$[O~O!X!ci~P$zOv$^O!_#tO~P$zO!e!WO{ai|ai!Xaivai!Wai~PAwO!e$`O!h$`OVaX!faX!gaX~P,_O!i$aOV`X!f`X!g`X!h`X{`X|`X!X`Xv`X!W`X~P.uO!n$cOV]X!f]X!g]X!h]X!i]X!k]X!l]X!m]X{]X|]X!X]Xv]X!W]X~P2tO!o$dOV[X!f[X!g[X!h[X!i[X!k[X!l[X!m[X!n[X{[X|[X!X[Xv[X!W[X~P4lO!p$eO!q$nOVZX!fZX!gZX!hZX!iZX!kZX!lZX!mZX!nZX!oZX{ZX|ZX!XZXvZX!WZX~P6aO!i$lO{`i|`i!X`iv`i!W`i~PDOOo!YOp!YOq!YOr!YO!i$lO!k!YO!l!YO{`X|`X!m`X!n`X!o`X!p`X!q`X!}`X!X`Xt`Xv`Xx`X!W`X~O!m$mOV^X!f^X!g^X!h^X!i^X!k^X!l^X{^X|^X!X^Xv^X!W^X~P0yOVXX!fXX!gXX!hXX!iXX!kXX!lXX!mXX!nXX!oXX!pXX!qXX{XX|XX!XXXvXX!WXX~P8RO!m$uO{^i|^i!X^iv^i!W^i~PE|O!n$vO{]i|]i!X]iv]i!W]i~PGwO!o$wO{[i|[i!X[iv[i!W[i~PIoO!m$uO{^X|^X!n^X!o^X!p^X!q^X!}^X!X^Xt^Xv^Xx^X!W^X~O!n$vO{]X|]X!o]X!p]X!q]X!}]X!X]Xt]Xv]Xx]X!W]X~O!o$wO{[X|[X!p[X!q[X!}[X!X[Xt[Xv[Xx[X!W[X~O!p$xO!q$yO{ZX|ZX!}ZX!XZXtZXvZXxZX!WZX~O!}!aO{XX|XX!XXXtXXvXXxXX!WXX~OW${O~O!P!R![!a!qklji!_Uk~", - goto: "6W!zPPP!{#P#aPPP#m$x%i&`'V(V)Y*`+a,m-z/V0d1m2vPPPPPP2vPPPP2vPPP2vP2vPPP2v2vP4PP2vP4S4VPPP2vP4_4gP2vP4m4pPPPPPP4sPPPPPPP4|5V5]5d5j5t5z6QTkOlSjOlQsSSwUxV#b!i#d#|SiOl]%USUx!i#d#|SjOlQoRQvTQ!OVQ!PWQ!hqQ!ltQ!z!RS#Y!c${Y#h!m#j#x$P$WQ#l!rQ#m!sQ#r!vW#t!y$T$[$_Q$R#sR$X$SUhOl!cW$sR!r!v#su%TTVWqt!R!m!s!y#j#x$P$S$T$W$[$_${!SgORTVWlqt!R!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_${U#W!`$n$yV#X!b$o$zYfOl!`!b!c[$kR!r!v#s$n$oy%STVWqt!R!m!s!y#j#x$P$S$T$W$[$_$y$z${YeOl!`!b!cQ#V!_Q#`$e[$jR!r!v#s$n$oQ%O$xy%RTVWqt!R!m!s!y#j#x$P$S$T$W$[$_$y$z${[dOl!_!`!b!cQ#U!^Q#_$d^$iR!r!v#s$e$n$oQ$}$w{%QTVWqt!R!m!s!y#j#x$P$S$T$W$[$_$x$y$z${^cOl!^!_!`!b!cQ#T!]Q#^$c`$rR!r!v#s$d$e$n$oQ$|$v}%PTVWqt!R!m!s!y#j#x$P$S$T$W$[$_$w$x$y$z${!rbORTVWlqt!R!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$c$d$e$n$o$v$w$x$y$z${V#S![$m$ubaOl![!]!^!_!`!b!cQ#R!ZQ#]$bd$hR!r!v#s$c$d$e$m$n$oQ$p$t!R$qTVWqt!R!m!s!y#j#x$P$S$T$W$[$_$u$v$w$x$y$z${!h`OTVWlqt!R!Z![!]!^!_!`!b!c!m!s!y#j#x$P$S$T$W$[$_$t$u$v$w$x$y$z${Q#Q!XQ#[$aQ$f$lg$gR!r!v#s$b$c$d$e$m$n$o#U_ORTVWlqt!R!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${Q#P!WR#Z$`#Y^ORTVWlqt!R!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$`$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${Q!U]R#O!V#_[ORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$`$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${#_ZORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$`$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${#_YORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#j#s#x$P$S$T$W$[$_$`$a$b$c$d$e$l$m$n$o$t$u$v$w$x$y$z${RyUR}VQ{VV#o!t#p$QQ#w!yV$Y$T$[$_X#u!y$T$[$_R!S[R!|!RQ!ZaQ$b$hR$t$qQ!bhQ$o$sR$z%TQlOR!elSnPpR!gnQ!jsR#e!jQ!nvS#k!n#yR#y!zQxUR!qxQ!u{R#q!uQ$U#wR$]$U", - nodeNames: "⚠ Comment Source Statement FieldDefinition FieldPath Identifier Dot Equal Expression AsExpression DefaultExpression PatchExpression ComposeExpression LogicalOrExpression LogicalAndExpression ComparisonExpression ConcatExpression AdditiveExpression MultiplicativeExpression UnaryExpression PostfixExpression PrimaryExpression Literal String Integer Float True False Regex ComparisonConstraint Lt Lte Gt Gte MapConstraint LBrace Ellipsis RBrace Object Semicolon ArrayConstraint LBracket Comma RBracket Array LetExpression Let FieldDefinitionList In FunctionExpression LParen ParameterList Parameter Colon RParen Arrow MatchExpression Match MatchArm Pattern Underscore ImportExpression Import CallSuffix ArgumentList Bang Minus Star Slash Plus PlusPlus CompareOperator EqualEqual BangEqual AmpAmp PipePipe Amp SlashSlash Default As", - maxTerm: 91, + states: ":|QYQPOOO#qQPO'#CaOOQO'#Cs'#CsO$zQPO'#CzO&XQQO'#DTO&dQQO'#D[O&nQPO'#D]O&vQPO'#CrO$zQPO'#DhO'QQPO'#DmOOQO'#Cr'#CrOOQO'#Cq'#CqO'VQPO'#CpO$zQPO'#CpOOQO'#Co'#CoO)rQPO'#CnO.kQPO'#CmO0rQPO'#ClOOQO'#Ck'#CkO2mQPO'#CjO4eQPO'#CiO6YQPO'#ChO7wQPO'#CgOOQO'#Cf'#CfO8RQPO'#CeO9iQPO'#C`O9nQPO'#C_OOQO'#EQ'#EQQYQPOOO;RQPO'#ERO;WQPO,58{OOQO,59f,59fO;`QPO'#CaO$zQPO,59kOOQO,59o,59oO;hQPO,59oO$zQPO,59rOOQO,59v,59vO;pQPO,59vO;xQPO'#EUO;}QPO'#D_OTQPO1G/bO>[QPO1G/bOOQO1G/b1G/bOOQO,5:p,5:pOOQO-E8S-E8SO$zQPO1G/cO$zQPO,5:OO>dQPO,59}O>lQPO,59}O$zQPO1G/gO>tQQO1G/gOOQO1G.x1G.xO>yQPO1G/nO?TQPO'#DpOOQO,5:Z,5:ZO?]QPO,5:ZOOQO1G.w1G.wOOQO1G.u1G.uO?bQPO1G.tOCOQPO1G.sODmQPO1G.rOOQO1G.q1G.qOFhQPO1G.pOH`QPO1G.oOJTQPO1G.nOOQO1G.m1G.mOOQO1G.l1G.lOOQO1G.f1G.fOOQO1G.t1G.tOOQO1G.s1G.sOOQO1G.r1G.rOOQO1G.p1G.pOOQO1G.o1G.oOOQO1G.n1G.nOOQO7+$q7+$qOOQO,5:n,5:nO$zQPO'#DVOOQO7+$u7+$uOKgQPO7+$uOKoQQO7+$uOOQO-E8Q-E8QOOQO7+$x7+$xOKzQPO7+$xOOQO,5:o,5:oOOQO7+$|7+$|OLPQPO7+$|OOQO-E8R-E8ROOQO7+$}7+$}OOQO1G/j1G/jOLWQPO'#DdOOQO,5:q,5:qOL]QPO1G/iOOQO-E8T-E8TOOQO7+%R7+%RO$zQPO7+%ROOQO'#Dk'#DkOLeQPO'#DjOOQO7+%Y7+%YOLjQPO7+%YOLrQPO,5:[OLyQPO,5:[OOQO1G/u1G/uOOQO,59q,59qOOQO<`AN>`ONYQPOAN>`OOQO-E8U-E8UOOQOG23gG23gOOQOG23zG23zP>|QPO'#EWO$zQPO,59YO$zQPO,59XO$zQPO,59WO$zQPO,59UO$zQPO,59TO$zQPO,59SONdQPO1G.sONzQPO'#CmO! _QPO'#ClO!!RQPO'#CiO!#RQPO'#ChO!$UQPO'#CgO$zQPO,59XO$zQPO,59VO$zQPO,59RO$zQPO,59QO!%_QPO1G.rO!%uQPO'#ClO!'VQPO'#CjO!(SQPO'#CeO$zQPO,59WO$zQPO,59VO$zQPO,59UO$zQPO,59TO$zQPO,59SO$zQPO,59RO$zQPO,59QO$zQPO,58zO!)]QPO1G.pO!)sQPO1G.oO!*ZQPO1G.nO!*qQPO'#CjO!+lQPO'#CiO!,dQPO'#ChO!-XQPO'#CgO!-yQPO'#CeO!.eQPO'#C`", + stateData: "!.w~O!}OSPOS~OUPOhQOiQOjQOkQOlQOmQOoROpROqROrROtSO{TO!QUO!UVO!]WO!bXO!e]O!f]O~OofXpfXqfXrfX!UfX!ffX!gfX!hfX!ifX!jfX!lfX!mfX!nfX!ofX!pfX!qfX!rfX#OfX~OVmOUfXWTXhfXifXjfXkfXlfXmfXtfXxfX{fX!QfX!]fX!bfX!efX!{fX~P!gOUYOhQOiQOjQOkQOlQOmQOoROpROqROrROtSO{TO!QUO!UVO!]WO!bXO!e]O!f]O~OUpOuqOvrO~OutO}uO~P$zOUpO!S!RP~OUzO!Y|O~P]Oh!QO~OV!TO!U!ROUdXhdXidXjdXkdXldXmdXodXpdXqdXrdXtdXxdX{dX!QdX!]dX!bdX!edX!fdX!gdX!hdX!idX!jdX!ldX!mdX!ndX!odX!pdX!qdX!rdX!{dX#OdX|dX}dX!YdXvdX!XdX~O!g!VO!h!VOUbXhbXibXjbXkbXlbXmbXobXpbXqbXrbXtbXxbX{bX!QbX!UbX!]bX!bbX!ebX!fbX!ibX!jbX!lbX!mbX!nbX!obX!pbX!qbX!rbX!{bX#ObXVbX|bX}bX!YbXvbX!XbX~OUaXhaXiaXjaXkaXlaXmaXoaXpaXqaXraXtaXxaX{aX!QaX!UaX!]aX!baX!eaX!jaX!laX!maX!naX!oaX!paX!qaX!raX!{aX#OaX|aX}aX!YaXvaX!XaX~O!f!WO!i!WO~P,_Oo!YOp!YOq!YOr!YO!l!YO!m!YOU`Xh`Xi`Xj`Xk`Xl`Xm`Xt`Xx`X{`X!Q`X!U`X!]`X!b`X!e`X!f`X!n`X!o`X!p`X!q`X!r`X!{`X#O`X~O!j!XO~P.uOU^Xh^Xi^Xj^Xk^Xl^Xm^Xo^Xp^Xq^Xr^Xt^Xx^X{^X!Q^X!U^X!]^X!b^X!e^X!f^X!o^X!p^X!q^X!r^X!{^X#O^X~O!n![O~P0yOU]Xh]Xi]Xj]Xk]Xl]Xm]Xo]Xp]Xq]Xr]Xt]Xx]X{]X!Q]X!U]X!]]X!b]X!e]X!f]X!p]X!q]X!r]X!{]X#O]X~O!o!]O~P2tOU[Xh[Xi[Xj[Xk[Xl[Xm[Xo[Xp[Xq[Xr[Xt[Xx[X{[X!Q[X!U[X!][X!b[X!e[X!f[X!q[X!r[X!{[X#O[X~O!p!^O~P4lOUZXhZXiZXjZXkZXlZXmZXoZXpZXqZXrZXtZXxZX{ZX!QZX!UZX!]ZX!bZX!eZX!fZX!{ZX#OZX~O!q!_O!r!`O~P6aO#O!aOUXXhXXiXXjXXkXXlXXmXXoXXpXXqXXrXXtXXxXX{XX!QXX!UXX!]XX!bXX!eXX!fXX!{XX~OW!cO~Ox!dOURXhRXiRXjRXkRXlRXmRXoRXpRXqRXrRXtRX{RX!QRX!URX!]RX!bRX!eRX!fRX!{RX~OU!fO~OVmOWTa~OVmOWTX~Ov!kOx!iO~O|!mO}!oO~Ox!pO~OUpO!S!RX~O!S!rO~O!X!sOVfX!YfX~P!gO|!tO!Y!VX~O!Z!vO~O!Y!wO~O!Y!xO~Ot!yO~O!Y!{O~P$zOU!}O~Ov#aO~OUpOu#cOv#dO~Ov#dOx#fO~O|#iO}#hO~O}#kO~P$zO|#lO}#kO~OU#pO!Y!Va~O|#rO!Y!Va~O!Z#uO~Ov#xO!`#vO~P$zO|#zO!Y!dX~O!Y#|O~O!g!VO!h!VOUbihbiibijbikbilbimbiobipbiqbirbitbixbi{bi!Qbi!Ubi!]bi!bbi!ebi!fbi!ibi!jbi!lbi!mbi!nbi!obi!pbi!qbi!rbi!{bi#Obi|bi}bi!Ybivbi!Xbi~O!i!WOoaipaiqairaitaixai!jai!lai!mai!nai!oai!pai!qai!rai#Oai~OUaihaiiaijaikailaimai{ai!Qai!Uai!]ai!bai!eai!fai!{ai~PAzOt`ix`i!n`i!o`i!p`i!q`i!r`i#O`i~O!j!XOU`ih`ii`ij`ik`il`im`io`ip`iq`ir`i{`i!Q`i!U`i!]`i!b`i!e`i!f`i!{`i~PDROt^ix^i!o^i!p^i!q^i!r^i#O^i~O!n![OU^ih^ii^ij^ik^il^im^io^ip^iq^ir^i{^i!Q^i!U^i!]^i!b^i!e^i!f^i!{^i~PFPOt]ix]i!p]i!q]i!r]i#O]i~O!o!]OU]ih]ii]ij]ik]il]im]io]ip]iq]ir]i{]i!Q]i!U]i!]]i!b]i!e]i!f]i!{]i~PGzOt[ix[i!q[i!r[i#O[i~O!p!^OU[ih[ii[ij[ik[il[im[io[ip[iq[ir[i{[i!Q[i!U[i!][i!b[i!e[i!f[i!{[i~PIrOv$OOx$PO~OUpOu#cOv$OO~O}$SO~O}$TO~P$zO!X!sO~OU#pO!Y!Vi~O!X$XO~Ov$[Ox$YO~O!Y!da~P$zO|$]O!Y!da~Ov$^O~Ov$^Ox$_O~OUpO~OU#pO~Ov$bO!`#vO~P$zOv$bOx$cO~O!Y!di~P$zOv$eO~Ov$fO!`#vO~P$zO!f!WO|ai}ai!Yaivai!Xai~PAzO!f$hO!i$hOVaX!gaX!haX~P,_O!j$iOV`X!g`X!h`X!i`X|`X}`X!Y`Xv`X!X`X~P.uO!o$kOV]X!g]X!h]X!i]X!j]X!l]X!m]X!n]X|]X}]X!Y]Xv]X!X]X~P2tO!p$lOV[X!g[X!h[X!i[X!j[X!l[X!m[X!n[X!o[X|[X}[X!Y[Xv[X!X[X~P4lO!q$mO!r$vOVZX!gZX!hZX!iZX!jZX!lZX!mZX!nZX!oZX!pZX|ZX}ZX!YZXvZX!XZX~P6aO!j$tO|`i}`i!Y`iv`i!X`i~PDROo!YOp!YOq!YOr!YO!j$tO!l!YO!m!YO|`X}`X!n`X!o`X!p`X!q`X!r`X#O`X!Y`Xt`Xv`Xx`X!X`X~O!n$uOV^X!g^X!h^X!i^X!j^X!l^X!m^X|^X}^X!Y^Xv^X!X^X~P0yOVXX!gXX!hXX!iXX!jXX!lXX!mXX!nXX!oXX!pXX!qXX!rXX|XX}XX!YXXvXX!XXX~P8RO!n$}O|^i}^i!Y^iv^i!X^i~PFPO!o%OO|]i}]i!Y]iv]i!X]i~PGzO!p%PO|[i}[i!Y[iv[i!X[i~PIrO!n$}O|^X}^X!o^X!p^X!q^X!r^X#O^X!Y^Xt^Xv^Xx^X!X^X~O!o%OO|]X}]X!p]X!q]X!r]X#O]X!Y]Xt]Xv]Xx]X!X]X~O!p%PO|[X}[X!q[X!r[X#O[X!Y[Xt[Xv[Xx[X!X[X~O!q%QO!r%RO|ZX}ZX#OZX!YZXtZXvZXxZX!XZX~O#O!aO|XX}XX!YXXtXXvXXxXX!XXX~OW%TO~O!Q!S!]!b!rklji!`Uk~", + goto: "6p!{PPP!|#Q#bPPP#n$|%n&f'^(_)c*j+l,y.X/e0s1}3XPPPPPP3XPPPP3XPPP3XP4c3XPPP3X3XP4iP3XP4l4oPPP3XP4w5PP3XP5V5YPPPPPP5]PPPPPPP5f5o5u5|6S6^6d6jTkOlSjOlQsSSwUxV#b!i#f$RSiOl]%^SUx!i#f$RSjOlQoRQvTQ!OVQ!PWQ!hqQ!ltQ!z!RS#Y!c%TY#j!m#l#z$U$]Q#n!rQ#o!sQ#t!vW#v!y$Y$c$gQ#}#cQ$W#uR$`$XUhOl!cW${R!r!v#uw%]TVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%T!UgORTVWlqt!R!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g%TU#W!`$v%RV#X!b$w%SYfOl!`!b!c[$sR!r!v#u$v$w{%[TVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%R%S%TYeOl!`!b!cQ#V!_Q#`$m[$rR!r!v#u$v$wQ%W%Q{%ZTVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%R%S%T[dOl!_!`!b!cQ#U!^Q#_$l^$qR!r!v#u$m$v$wQ%V%P}%YTVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%Q%R%S%T^cOl!^!_!`!b!cQ#T!]Q#^$k`$zR!r!v#u$l$m$v$wQ%U%O!P%XTVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g%P%Q%R%S%T!tbORTVWlqt!R!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$k$l$m$v$w%O%P%Q%R%S%TV#S![$u$}baOl![!]!^!_!`!b!cQ#R!ZQ#]$jd$pR!r!v#u$k$l$m$u$v$wQ$x$|!T$yTVWqt!R!m!s!y#c#l#z$U$X$Y$]$c$g$}%O%P%Q%R%S%T!j`OTVWlqt!R!Z![!]!^!_!`!b!c!m!s!y#c#l#z$U$X$Y$]$c$g$|$}%O%P%Q%R%S%TQ#Q!XQ#[$iQ$n$tg$oR!r!v#u$j$k$l$m$u$v$w#W_ORTVWlqt!R!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%TQ#P!WR#Z$h#[^ORTVWlqt!R!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$h$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%TQ!U]R#O!V#a[ORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$h$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%T#aZORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$h$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%T#aYORTVW]lqt!R!V!W!X!Z![!]!^!_!`!b!c!m!r!s!v!y#c#l#u#z$U$X$Y$]$c$g$h$i$j$k$l$m$t$u$v$w$|$}%O%P%Q%R%S%TQ#e!iR$Q#fRyUR}VQ{VV#q!t#r$VQ#y!yV$a$Y$c$gX#w!y$Y$c$gR!S[R!|!RQ!ZaQ$j$pR$|$yQ!bhQ$w${R%S%]QlOR!elSnPpR!gnQ!jsR#g!jQ!nvS#m!n#{R#{!zQxUR!qxQ!u{R#s!uQ$Z#yR$d$Z", + nodeNames: "⚠ Comment Source Statement FieldDefinition FieldPath Identifier Dot Equal Expression AsExpression DefaultExpression PatchExpression ComposeExpression LogicalOrExpression LogicalAndExpression ComparisonExpression ConcatExpression AdditiveExpression MultiplicativeExpression UnaryExpression PostfixExpression PrimaryExpression Literal String Integer Float True False Regex ComparisonConstraint Lt Lte Gt Gte MapConstraint LBrace Ellipsis RBrace Object Semicolon ObjectRest ArrayConstraint LBracket Comma RBracket Array LetExpression Let FieldDefinitionList In FunctionExpression LParen ParameterList Parameter Colon RParen Arrow MatchExpression Match MatchArm Pattern Underscore ImportExpression Import CallSuffix ArgumentList Bang Minus Star Slash Plus PlusPlus CompareOperator EqualEqual BangEqual AmpAmp PipePipe Amp SlashSlash Default As", + maxTerm: 92, skippedNodes: [0,1], repeatNodeCount: 7, - tokenData: "=c~R!PX^$Upq$Uqr$yrs%Wst&zvw'cxy'pyz'uz{'z{|(P|}(^}!O(c!O!P(h!P!Q({!Q![+c![!]+|!]!^,R!^!_,W!_!`,e!`!a,z!c!}-X!}#O-j#P#Q-o#R#S-t#T#W-X#W#X.X#X#Y-X#Y#Z1i#Z#]-X#]#^3y#^#`-X#`#a7]#a#b8p#b#h-X#h#i;Q#i#o-X#o#p<|#p#q=R#q#r=^#y#z$U$f$g$U#BY#BZ$U$IS$I_$U$I|$JO$U$JT$JU$U$KV$KW$U&FU&FV$U~$ZY!|~X^$Upq$U#y#z$U$f$g$U#BY#BZ$U$IS$I_$U$I|$JO$U$JT$JU$U$KV$KW$U&FU&FV$U~%OP!d~!_!`%R~%WO!l~~%ZWOY%WZr%Wrs%ss#O%W#O#P%x#P;'S%W;'S;=`&t<%lO%W~%xOh~~%{RO;'S%W;'S;=`&U;=`O%W~&XXOY%WZr%Wrs%ss#O%W#O#P%x#P;'S%W;'S;=`&t;=`<%l%W<%lO%W~&wP;=`<%l%W~'PSP~OY&zZ;'S&z;'S;=`']<%lO&z~'`P;=`<%l&z~'hP!o~vw'k~'pO!m~~'uO!T~~'zO!X~~(PO!f~~(UP!h~{|(X~(^O!i~~(cO{~~(hO!e~R(mPVP!O!P(pQ(sP!O!P(vQ({OuQ~)QW!g~OY)jZ!P)j!P!Q+^!Q#O)j#O#P*[#P;'S)j;'S;=`+W<%lO)j~)mWOY)jZ!P)j!P!Q*V!Q#O)j#O#P*[#P;'S)j;'S;=`+W<%lO)j~*[Om~~*_RO;'S)j;'S;=`*h;=`O)j~*kXOY)jZ!P)j!P!Q*V!Q#O)j#O#P*[#P;'S)j;'S;=`+W;=`<%l)j<%lO)j~+ZP;=`<%l)j~+cO!p~~+hQi~!O!P+n!Q![+c~+qP!Q![+t~+yPj~!Q![+t~,RO!W~~,WOx~~,]Po~!_!`,`~,eOp~~,jQWP!_!`,p!`!a,u~,uO!k~Q,zO!YQ~-PPq~!_!`-S~-XOr~~-^SU~!Q![-X!c!}-X#R#S-X#T#o-X~-oOz~~-tO|~~-{S!_~U~!Q![-X!c!}-X#R#S-X#T#o-X~.^UU~!Q![-X!c!}-X#R#S-X#T#X-X#X#Y.p#Y#o-X~.uUU~!Q![-X!c!}-X#R#S-X#T#Y-X#Y#Z/X#Z#o-X~/^TU~!Q![-X!c!}-X#R#S-X#T#U/m#U#o-X~/rUU~!Q![-X!c!}-X#R#S-X#T#i-X#i#j0U#j#o-X~0ZUU~!Q![-X!c!}-X#R#S-X#T#`-X#`#a0m#a#o-X~0rUU~!Q![-X!c!}-X#R#S-X#T#h-X#h#i1U#i#o-X~1]S!q~U~!Q![-X!c!}-X#R#S-X#T#o-X~1nTU~!Q![-X!c!}-X#R#S-X#T#U1}#U#o-X~2SUU~!Q![-X!c!}-X#R#S-X#T#`-X#`#a2f#a#o-X~2kUU~!Q![-X!c!}-X#R#S-X#T#g-X#g#h2}#h#o-X~3SUU~!Q![-X!c!}-X#R#S-X#T#X-X#X#Y3f#Y#o-X~3mSl~U~!Q![-X!c!}-X#R#S-X#T#o-X~4OVU~!Q![-X!c!}-X#R#S-X#T#a-X#a#b4e#b#c6x#c#o-X~4jUU~!Q![-X!c!}-X#R#S-X#T#d-X#d#e4|#e#o-X~5RUU~!Q![-X!c!}-X#R#S-X#T#c-X#c#d5e#d#o-X~5jUU~!Q![-X!c!}-X#R#S-X#T#f-X#f#g5|#g#o-X~6RUU~!Q![-X!c!}-X#R#S-X#T#h-X#h#i6e#i#o-X~6lS!a~U~!Q![-X!c!}-X#R#S-X#T#o-X~7PS!R~U~!Q![-X!c!}-X#R#S-X#T#o-X~7bUU~!Q![-X!c!}-X#R#S-X#T#X-X#X#Y7t#Y#o-X~7yUU~!Q![-X!c!}-X#R#S-X#T#h-X#h#i8]#i#o-X~8dS!P~U~!Q![-X!c!}-X#R#S-X#T#o-X~8uTU~!Q![-X!c!}-X#R#S-X#T#U9U#U#o-X~9ZUU~!Q![-X!c!}-X#R#S-X#T#h-X#h#i9m#i#o-X~9rUU~!Q![-X!c!}-X#R#S-X#T#V-X#V#W:U#W#o-X~:ZUU~!Q![-X!c!}-X#R#S-X#T#[-X#[#]:m#]#o-X~:tS![~U~!Q![-X!c!}-X#R#S-X#T#o-X~;VUU~!Q![-X!c!}-X#R#S-X#T#f-X#f#g;i#g#o-X~;nUU~!Q![-X!c!}-X#R#S-X#T#i-X#i#j spec_Identifier[value] || -1}], - tokenPrec: 2708 + tokenPrec: 2740 }) diff --git a/packages/decodal-codemirror/src/decodal-parser.terms.js b/packages/decodal-codemirror/src/decodal-parser.terms.js index 1d20889..bea761b 100644 --- a/packages/decodal-codemirror/src/decodal-parser.terms.js +++ b/packages/decodal-codemirror/src/decodal-parser.terms.js @@ -40,43 +40,44 @@ export const RBrace = 38, Object = 39, Semicolon = 40, - ArrayConstraint = 41, - LBracket = 42, - Comma = 43, - RBracket = 44, - Array = 45, - LetExpression = 46, - Let = 47, - FieldDefinitionList = 48, - In = 49, - FunctionExpression = 50, - LParen = 51, - ParameterList = 52, - Parameter = 53, - Colon = 54, - RParen = 55, - Arrow = 56, - MatchExpression = 57, - Match = 58, - MatchArm = 59, - Pattern = 60, - Underscore = 61, - ImportExpression = 62, - Import = 63, - CallSuffix = 64, - ArgumentList = 65, - Bang = 66, - Minus = 67, - Star = 68, - Slash = 69, - Plus = 70, - PlusPlus = 71, - CompareOperator = 72, - EqualEqual = 73, - BangEqual = 74, - AmpAmp = 75, - PipePipe = 76, - Amp = 77, - SlashSlash = 78, - Default = 79, - As = 80 + ObjectRest = 41, + ArrayConstraint = 42, + LBracket = 43, + Comma = 44, + RBracket = 45, + Array = 46, + LetExpression = 47, + Let = 48, + FieldDefinitionList = 49, + In = 50, + FunctionExpression = 51, + LParen = 52, + ParameterList = 53, + Parameter = 54, + Colon = 55, + RParen = 56, + Arrow = 57, + MatchExpression = 58, + Match = 59, + MatchArm = 60, + Pattern = 61, + Underscore = 62, + ImportExpression = 63, + Import = 64, + CallSuffix = 65, + ArgumentList = 66, + Bang = 67, + Minus = 68, + Star = 69, + Slash = 70, + Plus = 71, + PlusPlus = 72, + CompareOperator = 73, + EqualEqual = 74, + BangEqual = 75, + AmpAmp = 76, + PipePipe = 77, + Amp = 78, + SlashSlash = 79, + Default = 80, + As = 81 diff --git a/packages/decodal-codemirror/src/decodal.test.mjs b/packages/decodal-codemirror/src/decodal.test.mjs index 12284bc..9e8ed22 100644 --- a/packages/decodal-codemirror/src/decodal.test.mjs +++ b/packages/decodal-codemirror/src/decodal.test.mjs @@ -52,6 +52,16 @@ test('parses map constraints and range refinement', () => { assert.deepEqual(parseErrors(source), []); }); +test('parses unknown and object rest constraints', () => { + const source = `value = { + hoge = Int; + fuga = String; + ...Unknown +};`; + + assert.deepEqual(parseErrors(source), []); +}); + test('only treats the exact as keyword as an operator', () => { assert.deepEqual(parseErrors('asset = 1; value = asset as Int;'), []); }); diff --git a/packages/decodal-codemirror/wasm/decodal_language_tools_bg.wasm b/packages/decodal-codemirror/wasm/decodal_language_tools_bg.wasm index 9248ab8..8fd89d8 100644 Binary files a/packages/decodal-codemirror/wasm/decodal_language_tools_bg.wasm and b/packages/decodal-codemirror/wasm/decodal_language_tools_bg.wasm differ diff --git a/packages/decodal-wasm/README.md b/packages/decodal-wasm/README.md index bb20a29..689ddbd 100644 --- a/packages/decodal-wasm/README.md +++ b/packages/decodal-wasm/README.md @@ -64,6 +64,10 @@ console.log(JSON.parse(completion)); `globals`, `loadImport`, and `completeImport` are host-owned. The package does not assume a filesystem or virtual project model. Import callbacks are synchronous; preload or cache remote content before evaluation. -Plain strings, numbers, booleans, arrays, and objects are concrete host values. Use `{ $decodal: 'String' | 'Int' | 'Float' | 'Bool' }` for primitive schemas, `{ $decodal: 'Array', item: value }` for array schemas, and `{ $decodal: 'Map', value: value }` for associative-array schemas. Descriptors also accept `constraints` and `default`. +Plain strings, numbers, booleans, arrays, and objects are concrete values. Use `{ $decodal: 'String' | 'Int' | 'Float' | 'Bool' }` for primitive ranges, `{ $decodal: 'Unknown' }` for the top range, `{ $decodal: 'Array', item: value }` for array ranges, and `{ $decodal: 'Map', value: value }` for associative-array ranges. Primitive, unknown, array, and map descriptors also accept `constraints` and `default`. + +Use `{ $decodal: 'Range', constraints, default }` when constructing a general range directly. + +An object with named fields and an open rest range uses `{ $decodal: 'Object', fields, rest }`. The `fields` property is a record of values and `rest` is the range applied to every other field. Methods return JSON strings so callers can handle diagnostics and successful results without depending on Rust data structures. diff --git a/packages/decodal-wasm/decodal_wasm.d.ts b/packages/decodal-wasm/decodal_wasm.d.ts index 3cd83ce..4872040 100644 --- a/packages/decodal-wasm/decodal_wasm.d.ts +++ b/packages/decodal-wasm/decodal_wasm.d.ts @@ -1,21 +1,24 @@ /* tslint:disable */ /* eslint-disable */ -/** A concrete JavaScript value or Decodal schema descriptor supplied by the host. */ -export type DecodalHostValue = +/** A concrete JavaScript value or Decodal range descriptor. */ +export type DecodalValue = | string | number | boolean - | DecodalHostValue[] - | { [field: string]: DecodalHostValue } + | DecodalValue[] + | { [field: string]: DecodalValue } | DecodalPrimitiveDescriptor + | DecodalUnknownDescriptor | DecodalArrayDescriptor | DecodalMapDescriptor - | DecodalAbstractDescriptor; + | DecodalObjectDescriptor + | DecodalRangeDescriptor; export type DecodalPrimitiveType = 'String' | 'Int' | 'Float' | 'Bool'; export type DecodalConstraint = + | { kind: 'unknown' } | { kind: 'type'; value: DecodalPrimitiveType } | { kind: 'compare'; op: '>' | '>=' | '<' | '<='; value: string | number | boolean } | { kind: 'regex'; value: string } @@ -24,32 +27,44 @@ export type DecodalConstraint = export interface DecodalPrimitiveDescriptor { $decodal: DecodalPrimitiveType; constraints?: DecodalConstraint[]; - default?: DecodalHostValue; + default?: DecodalValue; +} + +export interface DecodalUnknownDescriptor { + $decodal: 'Unknown'; + constraints?: DecodalConstraint[]; + default?: DecodalValue; } export interface DecodalArrayDescriptor { $decodal: 'Array'; - item: DecodalHostValue; + item: DecodalValue; constraints?: DecodalConstraint[]; - default?: DecodalHostValue; + default?: DecodalValue; } export interface DecodalMapDescriptor { $decodal: 'Map'; - value: DecodalHostValue; + value: DecodalValue; constraints?: DecodalConstraint[]; - default?: DecodalHostValue; + default?: DecodalValue; } -export interface DecodalAbstractDescriptor { - $decodal: 'Abstract'; +export interface DecodalObjectDescriptor { + $decodal: 'Object'; + fields: Record; + rest: DecodalValue; +} + +export interface DecodalRangeDescriptor { + $decodal: 'Range'; constraints?: DecodalConstraint[]; - default?: DecodalHostValue; + default?: DecodalValue; } export type DecodalLoadedImport = | { kind: 'source'; key: string; name?: string; source: string } - | { kind: 'value'; key: string; value: DecodalHostValue }; + | { kind: 'value'; key: string; value: DecodalValue }; export type DecodalImportCandidate = | string @@ -57,7 +72,7 @@ export type DecodalImportCandidate = /** Host-owned environment shared by evaluation and language tooling. */ export interface DecodalEnvironment { - globals?: Record; + globals?: Record; /** Synchronous import callback. Preload or cache asynchronous resources first. */ loadImport?: (currentKey: string | null, specifier: string) => DecodalLoadedImport; /** Synchronous import completion callback. */ diff --git a/packages/decodal-wasm/decodal_wasm_bg.wasm b/packages/decodal-wasm/decodal_wasm_bg.wasm index bbc876f..c9f1226 100644 Binary files a/packages/decodal-wasm/decodal_wasm_bg.wasm and b/packages/decodal-wasm/decodal_wasm_bg.wasm differ diff --git a/packages/decodal-wasm/mod.ts b/packages/decodal-wasm/mod.ts index 7f4e66d..f573fdd 100644 --- a/packages/decodal-wasm/mod.ts +++ b/packages/decodal-wasm/mod.ts @@ -11,16 +11,18 @@ export { } from './decodal_wasm.js'; export type { - DecodalAbstractDescriptor, DecodalArrayDescriptor, - DecodalMapDescriptor, DecodalConstraint, DecodalEnvironment, - DecodalHostValue, DecodalImportCandidate, DecodalLoadedImport, + DecodalMapDescriptor, + DecodalObjectDescriptor, DecodalPrimitiveDescriptor, DecodalPrimitiveType, + DecodalRangeDescriptor, + DecodalUnknownDescriptor, + DecodalValue, InitInput, InitOutput, SyncInitInput, diff --git a/site/decodal-site/scripts/prepare-wasm-package.mjs b/site/decodal-site/scripts/prepare-wasm-package.mjs index ef775e2..27368de 100644 --- a/site/decodal-site/scripts/prepare-wasm-package.mjs +++ b/site/decodal-site/scripts/prepare-wasm-package.mjs @@ -8,22 +8,25 @@ copyFileSync(resolve(packageDir, '../../LICENSE-APACHE'), resolve(packageDir, 'L const declarationPath = resolve(packageDir, 'decodal_wasm.d.ts'); let declarations = readFileSync(declarationPath, 'utf8'); -const hostTypes = ` -/** A concrete JavaScript value or Decodal schema descriptor supplied by the host. */ -export type DecodalHostValue = +const valueTypes = ` +/** A concrete JavaScript value or Decodal range descriptor. */ +export type DecodalValue = | string | number | boolean - | DecodalHostValue[] - | { [field: string]: DecodalHostValue } + | DecodalValue[] + | { [field: string]: DecodalValue } | DecodalPrimitiveDescriptor + | DecodalUnknownDescriptor | DecodalArrayDescriptor | DecodalMapDescriptor - | DecodalAbstractDescriptor; + | DecodalObjectDescriptor + | DecodalRangeDescriptor; export type DecodalPrimitiveType = 'String' | 'Int' | 'Float' | 'Bool'; export type DecodalConstraint = + | { kind: 'unknown' } | { kind: 'type'; value: DecodalPrimitiveType } | { kind: 'compare'; op: '>' | '>=' | '<' | '<='; value: string | number | boolean } | { kind: 'regex'; value: string } @@ -32,32 +35,44 @@ export type DecodalConstraint = export interface DecodalPrimitiveDescriptor { $decodal: DecodalPrimitiveType; constraints?: DecodalConstraint[]; - default?: DecodalHostValue; + default?: DecodalValue; +} + +export interface DecodalUnknownDescriptor { + $decodal: 'Unknown'; + constraints?: DecodalConstraint[]; + default?: DecodalValue; } export interface DecodalArrayDescriptor { $decodal: 'Array'; - item: DecodalHostValue; + item: DecodalValue; constraints?: DecodalConstraint[]; - default?: DecodalHostValue; + default?: DecodalValue; } export interface DecodalMapDescriptor { $decodal: 'Map'; - value: DecodalHostValue; + value: DecodalValue; constraints?: DecodalConstraint[]; - default?: DecodalHostValue; + default?: DecodalValue; } -export interface DecodalAbstractDescriptor { - $decodal: 'Abstract'; +export interface DecodalObjectDescriptor { + $decodal: 'Object'; + fields: Record; + rest: DecodalValue; +} + +export interface DecodalRangeDescriptor { + $decodal: 'Range'; constraints?: DecodalConstraint[]; - default?: DecodalHostValue; + default?: DecodalValue; } export type DecodalLoadedImport = | { kind: 'source'; key: string; name?: string; source: string } - | { kind: 'value'; key: string; value: DecodalHostValue }; + | { kind: 'value'; key: string; value: DecodalValue }; export type DecodalImportCandidate = | string @@ -65,7 +80,7 @@ export type DecodalImportCandidate = /** Host-owned environment shared by evaluation and language tooling. */ export interface DecodalEnvironment { - globals?: Record; + globals?: Record; /** Synchronous import callback. Preload or cache asynchronous resources first. */ loadImport?: (currentKey: string | null, specifier: string) => DecodalLoadedImport; /** Synchronous import completion callback. */ @@ -73,7 +88,7 @@ export interface DecodalEnvironment { } `; if (!declarations.includes('export interface DecodalEnvironment')) { - declarations = declarations.replace('/* eslint-disable */\n', `/* eslint-disable */\n${hostTypes}`); + declarations = declarations.replace('/* eslint-disable */\n', `/* eslint-disable */\n${valueTypes}`); } declarations = declarations.replace( 'constructor(options: any);', @@ -175,7 +190,11 @@ console.log(JSON.parse(completion)); \`globals\`, \`loadImport\`, and \`completeImport\` are host-owned. The package does not assume a filesystem or virtual project model. Import callbacks are synchronous; preload or cache remote content before evaluation. -Plain strings, numbers, booleans, arrays, and objects are concrete host values. Use \`{ $decodal: 'String' | 'Int' | 'Float' | 'Bool' }\` for primitive schemas, \`{ $decodal: 'Array', item: value }\` for array schemas, and \`{ $decodal: 'Map', value: value }\` for associative-array schemas. Descriptors also accept \`constraints\` and \`default\`. +Plain strings, numbers, booleans, arrays, and objects are concrete values. Use \`{ $decodal: 'String' | 'Int' | 'Float' | 'Bool' }\` for primitive ranges, \`{ $decodal: 'Unknown' }\` for the top range, \`{ $decodal: 'Array', item: value }\` for array ranges, and \`{ $decodal: 'Map', value: value }\` for associative-array ranges. Primitive, unknown, array, and map descriptors also accept \`constraints\` and \`default\`. + +Use \`{ $decodal: 'Range', constraints, default }\` when constructing a general range directly. + +An object with named fields and an open rest range uses \`{ $decodal: 'Object', fields, rest }\`. The \`fields\` property is a record of values and \`rest\` is the range applied to every other field. Methods return JSON strings so callers can handle diagnostics and successful results without depending on Rust data structures. `, diff --git a/site/decodal-site/src/lib/highlight.js b/site/decodal-site/src/lib/highlight.js index 4009e1a..ac90641 100644 --- a/site/decodal-site/src/lib/highlight.js +++ b/site/decodal-site/src/lib/highlight.js @@ -1,5 +1,5 @@ const DECODAL_KEYWORDS = new Set(['let', 'in', 'fn', 'match', 'import', 'default']); -const DECODAL_TYPES = new Set(['String', 'Int', 'Float', 'Bool']); +const DECODAL_TYPES = new Set(['String', 'Int', 'Float', 'Bool', 'Unknown']); const DECODAL_LITERALS = new Set(['true', 'false']); const HTML_ESCAPE = { @@ -41,7 +41,7 @@ export function highlightDecodalTokens(source, tokens) { function tokenClass(kind, text) { if (['let', 'in', 'fn', 'match', 'import', 'default'].includes(kind)) return 'tok-keyword'; - if (kind === 'ident' && ['String', 'Int', 'Float', 'Bool'].includes(text)) return 'tok-type'; + if (kind === 'ident' && ['String', 'Int', 'Float', 'Bool', 'Unknown'].includes(text)) return 'tok-type'; if (kind === 'ident') return ''; if (['true', 'false'].includes(kind)) return 'tok-literal'; if (['int', 'float'].includes(kind)) return 'tok-number'; diff --git a/site/decodal-site/src/scripts/playground-runtime.test.mjs b/site/decodal-site/src/scripts/playground-runtime.test.mjs index 93cbeae..0fa7781 100644 --- a/site/decodal-site/src/scripts/playground-runtime.test.mjs +++ b/site/decodal-site/src/scripts/playground-runtime.test.mjs @@ -22,6 +22,13 @@ test('injects one JavaScript host environment into evaluation and completion', a active: { $decodal: 'Bool', default: true }, }, }, + OpenConfig: { + $decodal: 'Object', + fields: { + enabled: { $decodal: 'Bool', default: true }, + }, + rest: { $decodal: 'Unknown' }, + }, }, }, loadImport(_currentKey, specifier) { @@ -46,11 +53,12 @@ test('injects one JavaScript host environment into evaluation and completion', a const evaluated = JSON.parse(service.evaluate( 'main.dcdl', 'main.dcdl', - 'let s = import "./schema.dcdl"; in { server = { port = 8080; } as s.Server; services = { api = { port = 8081; }; } as App.Services; enabled = App.enabled; post = import "./post.md" as { frontmatter = { draft = Bool; }; body = String; }; }', + 'let s = import "./schema.dcdl"; in { server = { port = 8080; } as s.Server; services = { api = { port = 8081; }; } as App.Services; open = { enabled = false; plugin = { name = "cache"; }; } as App.OpenConfig; enabled = App.enabled; post = import "./post.md" as { frontmatter = { draft = Bool; }; body = String; }; }', )); assert.equal(evaluated.ok, true, evaluated.error); assert.match(evaluated.output, /"port": 8080/); assert.match(evaluated.output, /"active": true/); + assert.match(evaluated.output, /"plugin": \{/); assert.match(evaluated.output, /"body": "# Hello"/); const member = JSON.parse(service.complete('main.dcdl', 'App.en', 6, false)); @@ -61,5 +69,9 @@ test('injects one JavaScript host environment into evaluation and completion', a assert.equal(imported.ok, true, imported.error); assert.ok(imported.completion.options.some((item) => item.label === './schema.dcdl')); + const unknown = JSON.parse(service.complete('main.dcdl', 'Unk', 3, false)); + assert.equal(unknown.ok, true, unknown.error); + assert.ok(unknown.completion.options.some((item) => item.label === 'Unknown')); + service.free(); });