diff --git a/README.md b/README.md index 0dec0f7..839e5dc 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,8 @@ It is designed around a lightweight Rust library: - shared host environments for production and semantic editor tooling - 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}` - deterministic expression evaluation - optional regex support behind a Cargo feature - browser playground support through WebAssembly diff --git a/crates/decodal-core/src/ast.rs b/crates/decodal-core/src/ast.rs index db5177d..fc001d9 100644 --- a/crates/decodal-core/src/ast.rs +++ b/crates/decodal-core/src/ast.rs @@ -53,6 +53,9 @@ pub enum Expr { ArrayConstraint { item: ExprId, }, + MapConstraint { + value: ExprId, + }, Let { bindings: Vec, body: ExprId, @@ -94,6 +97,10 @@ pub enum Expr { base: ExprId, fallback: ExprId, }, + As { + narrower: ExprId, + wider: ExprId, + }, CompareConstraint { op: CompareOp, value: ExprId, diff --git a/crates/decodal-core/src/constraints.rs b/crates/decodal-core/src/constraints.rs index 2f6b110..157568d 100644 --- a/crates/decodal-core/src/constraints.rs +++ b/crates/decodal-core/src/constraints.rs @@ -12,6 +12,7 @@ pub fn normalize_constraints( ) -> crate::Result> { let mut primitive: Option<(PrimitiveType, Span)> = None; let mut array_span: Option = None; + let mut map_span: Option = None; let mut lower: Option<(Bound, Span)> = None; let mut upper: Option<(Bound, Span)> = None; let mut rest = Vec::new(); @@ -69,6 +70,13 @@ pub fn normalize_constraints( span: entry.span, }); } + Constraint::MapValues(value) => { + map_span.get_or_insert(entry.span); + rest.push(ConstraintEntry { + constraint: Constraint::MapValues(value), + span: entry.span, + }); + } Constraint::BuiltinPredicate(name) => rest.push(ConstraintEntry { constraint: Constraint::BuiltinPredicate(name), span: entry.span, @@ -86,6 +94,26 @@ pub fn normalize_constraints( .with_label(array_span, "array element constraint")); } + if let (Some((_, primitive_span)), Some(map_span)) = (primitive, map_span) { + return Err(Diagnostic::new( + DiagnosticKind::Conflict, + span, + "map value constraints conflict with primitive type constraints", + ) + .with_label(primitive_span, "primitive constraint") + .with_label(map_span, "map value constraint")); + } + + if let (Some(array_span), Some(map_span)) = (array_span, map_span) { + return Err(Diagnostic::new( + DiagnosticKind::Conflict, + span, + "array and map constraints conflict", + ) + .with_label(array_span, "array element constraint") + .with_label(map_span, "map value constraint")); + } + if let Some(array_span) = array_span && (lower.is_some() || upper.is_some()) { @@ -104,6 +132,24 @@ pub fn normalize_constraints( return Err(diagnostic); } + if let Some(map_span) = map_span + && (lower.is_some() || upper.is_some()) + { + let mut diagnostic = Diagnostic::new( + DiagnosticKind::Conflict, + span, + "numeric comparison constraints conflict with map value constraints", + ) + .with_label(map_span, "map value constraint"); + if let Some((_, lower_span)) = lower { + diagnostic = diagnostic.with_label(lower_span, "numeric comparison constraint"); + } + if let Some((_, upper_span)) = upper { + diagnostic = diagnostic.with_label(upper_span, "numeric comparison constraint"); + } + return Err(diagnostic); + } + if matches!( primitive, Some((PrimitiveType::String | PrimitiveType::Bool, _)) diff --git a/crates/decodal-core/src/embedding.rs b/crates/decodal-core/src/embedding.rs index 39214ad..bb522a6 100644 --- a/crates/decodal-core/src/embedding.rs +++ b/crates/decodal-core/src/embedding.rs @@ -15,6 +15,11 @@ pub enum HostValue { constraints: Vec, default: Option>, }, + MapConstraint { + value: Box, + constraints: Vec, + default: Option>, + }, Object(Vec), Abstract { constraints: Vec, @@ -104,6 +109,14 @@ impl HostValue { } } + pub fn map_of(value: HostValue) -> Self { + Self::MapConstraint { + value: Box::new(value), + constraints: Vec::new(), + default: None, + } + } + pub fn builtin_predicate(name: impl Into) -> Self { Self::abstract_with_constraint(Constraint::BuiltinPredicate(name.into())) } @@ -118,7 +131,9 @@ impl HostValue { pub fn with_constraint(mut self, constraint: Constraint) -> Self { match &mut self { Self::Abstract { constraints, .. } => constraints.push(constraint), - Self::ArrayConstraint { constraints, .. } => constraints.push(constraint), + Self::ArrayConstraint { constraints, .. } | Self::MapConstraint { constraints, .. } => { + constraints.push(constraint) + } _ => { self = Self::Abstract { constraints: alloc::vec![constraint], @@ -169,6 +184,22 @@ impl HostValue { Span::default(), "host value already has a default", )), + Self::MapConstraint { + value: map_value, + constraints, + default: None, + } => Ok(Self::MapConstraint { + value: map_value, + constraints, + default: Some(Box::new(value)), + }), + Self::MapConstraint { + default: Some(_), .. + } => Err(Diagnostic::new( + DiagnosticKind::DefaultConflict, + Span::default(), + "host value already has a default", + )), Self::Abstract { constraints, default: None, diff --git a/crates/decodal-core/src/eval.rs b/crates/decodal-core/src/eval.rs index b8830ea..636ef3b 100644 --- a/crates/decodal-core/src/eval.rs +++ b/crates/decodal-core/src/eval.rs @@ -388,6 +388,22 @@ impl Engine { default: None, })) } + Expr::MapConstraint { value } => { + let value = self.add_expr_thunk( + ExprRef { + module: reference.module, + expr: value, + }, + env, + ); + Ok(RuntimeValue::Abstract(AbstractValue { + constraints: vec![ConstraintEntry { + constraint: Constraint::MapValues(value), + span, + }], + default: None, + })) + } Expr::Let { bindings, body } => { let let_env = self.new_env(Some(env)); for binding in bindings { @@ -631,6 +647,21 @@ impl Engine { concrete @ RuntimeValue::Concrete(_) => Ok(concrete), } } + Expr::As { narrower, wider } => { + let narrower_ref = ExprRef { + module: reference.module, + expr: narrower, + }; + let wider_ref = ExprRef { + module: reference.module, + expr: wider, + }; + let narrower_span = self.expr_span(narrower_ref); + let wider_span = self.expr_span(wider_ref); + let narrower = self.eval_expr(narrower_ref, env)?; + let wider = self.eval_expr(wider_ref, env)?; + self.apply_as(narrower, wider, span, narrower_span, wider_span) + } Expr::CompareConstraint { op, value } => { let value_ref = ExprRef { module: reference.module, @@ -843,6 +874,7 @@ impl Engine { env, ), Expr::ArrayConstraint { .. } + | Expr::MapConstraint { .. } | Expr::CompareConstraint { .. } | Expr::RegexConstraint(_) | Expr::Ident(_) => { @@ -911,6 +943,378 @@ impl Engine { } } + fn apply_as( + &mut self, + narrower: RuntimeValue, + wider: RuntimeValue, + operation_span: Span, + narrower_span: Span, + wider_span: Span, + ) -> Result { + let narrower_diagnostic_span = source_span_or(narrower_span, operation_span); + let wider_diagnostic_span = source_span_or(wider_span, operation_span); + match (narrower, wider) { + (RuntimeValue::Abstract(narrower), RuntimeValue::Abstract(wider)) => { + self.ensure_abstract_narrower( + &narrower, + &wider, + operation_span, + narrower_span, + wider_span, + )?; + Ok(RuntimeValue::Abstract(narrower)) + } + (narrower @ RuntimeValue::Concrete(_), RuntimeValue::Abstract(wider)) => self + .apply_constraints( + narrower, + &wider.constraints, + operation_span, + Some((narrower_span, "narrower value checked here")), + ), + (narrower, RuntimeValue::Concrete(ConcreteValue::Object(wider))) => { + self.apply_object_as(narrower, wider, operation_span, narrower_span, wider_span) + } + (narrower, RuntimeValue::Concrete(ConcreteValue::Array(wider))) => { + self.apply_array_as(narrower, wider, operation_span, narrower_span, wider_span) + } + (_, RuntimeValue::Concrete(ConcreteValue::Function(_))) => Err(Diagnostic::new( + DiagnosticKind::UnsupportedFeature, + wider_diagnostic_span, + "functions cannot be used as the wider side of `as`", + ) + .with_label(operation_span, "`as` applied here")), + (RuntimeValue::Abstract(_), RuntimeValue::Concrete(_)) => { + let diagnostic = Diagnostic::new( + DiagnosticKind::ConstraintViolation, + narrower_diagnostic_span, + "left side of `as` is not known to be narrower than the concrete right side", + ) + .with_label(operation_span, "`as` applied here"); + Err(with_source_label( + diagnostic, + wider_span, + "concrete wider value declared here", + )) + } + (RuntimeValue::Concrete(narrower), RuntimeValue::Concrete(wider)) => { + let narrower_kind = concrete_value_kind(&narrower); + if concrete_scalar_eq(&narrower, &wider) { + Ok(RuntimeValue::Concrete(narrower)) + } else { + let diagnostic = Diagnostic::new( + DiagnosticKind::ConstraintViolation, + narrower_diagnostic_span, + "left side of `as` does not equal the concrete right side", + ) + .with_label(operation_span, "`as` applied here"); + let diagnostic = with_source_label( + diagnostic, + narrower_span, + format!("{narrower_kind} value supplied here"), + ); + Err(with_source_label( + diagnostic, + wider_span, + "required concrete value declared here", + )) + } + } + } + } + + fn ensure_abstract_narrower( + &mut self, + narrower: &AbstractValue, + wider: &AbstractValue, + operation_span: Span, + narrower_span: Span, + wider_span: Span, + ) -> Result<()> { + for wider_entry in &wider.constraints { + let implied = match &wider_entry.constraint { + Constraint::Type(wider_type) => narrower.constraints.iter().any(|entry| { + matches!(entry.constraint, Constraint::Type(narrower_type) if narrower_type == *wider_type) + }), + Constraint::Compare(wider_op, wider_value) => comparison_constraint_is_implied( + &narrower.constraints, + *wider_op, + wider_value, + ), + Constraint::Regex(wider_pattern) => narrower.constraints.iter().any(|entry| { + matches!(&entry.constraint, Constraint::Regex(narrower_pattern) if narrower_pattern == wider_pattern) + }), + Constraint::BuiltinPredicate(wider_name) => { + narrower.constraints.iter().any(|entry| { + matches!(&entry.constraint, Constraint::BuiltinPredicate(narrower_name) if narrower_name == wider_name) + }) + } + Constraint::ArrayItems(wider_item) => self.collection_constraint_is_implied( + &narrower.constraints, + *wider_item, + true, + operation_span, + narrower_span, + wider_entry.span, + )?, + Constraint::MapValues(wider_value) => self.collection_constraint_is_implied( + &narrower.constraints, + *wider_value, + false, + operation_span, + narrower_span, + wider_entry.span, + )?, + }; + if !implied { + let diagnostic = Diagnostic::new( + DiagnosticKind::ConstraintViolation, + source_span_or(narrower_span, operation_span), + "left side of `as` is not known to be narrower than the right side", + ) + .with_label(operation_span, "`as` applied here"); + let diagnostic = with_source_label( + diagnostic, + narrower_span, + "narrower constraints declared here", + ); + return Err(with_source_label( + diagnostic, + source_span_or(wider_entry.span, wider_span), + format!( + "right side requires {}", + constraint_description(&wider_entry.constraint) + ), + )); + } + } + Ok(()) + } + + fn collection_constraint_is_implied( + &mut self, + narrower: &[ConstraintEntry], + wider_item: ThunkId, + array: bool, + operation_span: Span, + narrower_span: Span, + wider_span: Span, + ) -> Result { + let narrower_items: Vec<_> = narrower + .iter() + .filter_map(|entry| match (&entry.constraint, array) { + (Constraint::ArrayItems(item), true) | (Constraint::MapValues(item), false) => { + Some(*item) + } + _ => None, + }) + .collect(); + let Some((first, rest)) = narrower_items.split_first() else { + return Ok(false); + }; + let mut combined = self.force(*first)?; + for item in rest { + let next = self.force(*item)?; + combined = self.compose_and(combined, next, operation_span)?; + } + let wider = self.force(wider_item)?; + self.apply_as(combined, wider, operation_span, narrower_span, wider_span)?; + Ok(true) + } + + fn apply_object_as( + &mut self, + narrower: RuntimeValue, + wider: ObjectValue, + operation_span: Span, + narrower_span: Span, + wider_span: Span, + ) -> Result { + let narrower_kind = runtime_value_kind(&narrower); + let narrower_diagnostic_span = source_span_or(narrower_span, operation_span); + let RuntimeValue::Concrete(ConcreteValue::Object(narrower)) = narrower else { + let diagnostic = Diagnostic::new( + DiagnosticKind::TypeMismatch, + narrower_diagnostic_span, + format!("expected Object on the left of `as`, found {narrower_kind}"), + ) + .with_label(operation_span, "`as` applied here"); + return Err(with_source_label( + diagnostic, + wider_span, + "wider object declared here", + )); + }; + + for narrower_field in &narrower.fields { + if wider + .fields + .iter() + .all(|wider_field| wider_field.name != narrower_field.name) + { + let origin = self.thunk_import_origin(narrower_field.value).cloned(); + let diagnostic_span = if origin.is_some() { + operation_span + } else { + narrower_field.span + }; + let diagnostic = Diagnostic::new( + DiagnosticKind::ConstraintViolation, + diagnostic_span, + format!( + "field `{}` is not present on the wider side of `as`", + narrower_field.name + ), + ) + .with_label(operation_span, "`as` applied here"); + let diagnostic = + with_source_label(diagnostic, wider_span, "wider object declared here"); + return Err(annotate_imported_value(diagnostic, origin.as_ref(), None)); + } + } + + let mut refined = ObjectValue { fields: Vec::new() }; + for wider_field in wider.fields { + let Some(narrower_field) = narrower + .fields + .iter() + .find(|narrower_field| narrower_field.name == wider_field.name) + else { + // The right-only portion remains untouched and abstract. In particular, + // `as` never forces its value or decides whether a default is required. + refined.fields.push(wider_field); + continue; + }; + + let narrower_origin = self.thunk_import_origin(narrower_field.value).cloned(); + let narrower_value = self.force(narrower_field.value)?; + let wider_value = self.force(wider_field.value)?; + let field_name = wider_field.name.clone(); + let narrowed = self + .apply_as( + narrower_value.clone(), + wider_value, + operation_span, + narrower_field.span, + wider_field.span, + ) + .map_err(|diagnostic| { + let diagnostic = with_source_label( + diagnostic, + wider_field.span, + format!("wider range for field `{field_name}`"), + ); + 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!("narrower range for field `{field_name}`"), + ) + } + })?; + 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, + }); + } + Ok(RuntimeValue::Concrete(ConcreteValue::Object(refined))) + } + + fn apply_array_as( + &mut self, + narrower: RuntimeValue, + wider: Vec, + operation_span: Span, + narrower_span: Span, + wider_span: Span, + ) -> Result { + let narrower_kind = runtime_value_kind(&narrower); + let narrower_diagnostic_span = source_span_or(narrower_span, operation_span); + let RuntimeValue::Concrete(ConcreteValue::Array(narrower)) = narrower else { + let diagnostic = Diagnostic::new( + DiagnosticKind::TypeMismatch, + narrower_diagnostic_span, + format!("expected Array on the left of `as`, found {narrower_kind}"), + ) + .with_label(operation_span, "`as` applied here"); + return Err(with_source_label( + diagnostic, + wider_span, + "wider array declared here", + )); + }; + if narrower.len() != wider.len() { + let diagnostic = Diagnostic::new( + DiagnosticKind::ConstraintViolation, + narrower_diagnostic_span, + format!( + "array length mismatch: right side has {}, left side has {}", + wider.len(), + narrower.len() + ), + ) + .with_label(operation_span, "`as` applied here"); + return Err(with_source_label( + diagnostic, + wider_span, + "wider array declared here", + )); + } + + let mut refined = Vec::with_capacity(narrower.len()); + for (index, (narrower, wider)) in narrower.into_iter().zip(wider).enumerate() { + let narrower_span = self.thunk_span(narrower); + let wider_span = self.thunk_span(wider); + let narrower_origin = self.thunk_import_origin(narrower).cloned(); + let narrower_value = self.force(narrower)?; + let wider_value = self.force(wider)?; + let narrowed = self + .apply_as( + narrower_value.clone(), + wider_value, + operation_span, + narrower_span, + wider_span, + ) + .map_err(|diagnostic| { + let diagnostic = with_source_label( + diagnostic, + wider_span, + format!("wider range for array item [{index}]"), + ); + if narrower_origin.is_some() { + annotate_imported_value( + diagnostic, + narrower_origin.as_ref(), + Some(&narrower_value), + ) + } else { + with_source_label( + diagnostic, + narrower_span, + format!("narrower range for array item [{index}]"), + ) + } + })?; + refined.push(self.add_value_thunk_with_span_and_import_origin( + narrowed, + narrower_span, + narrower_origin, + )); + } + Ok(RuntimeValue::Concrete(ConcreteValue::Array(refined))) + } + fn compose_objects( &mut self, mut lhs: ObjectValue, @@ -1049,6 +1453,11 @@ impl Engine { value_label: Option<(Span, &'static str)>, ) -> Result { let constraint_value = &constraint.constraint; + let constraint_span = if constraint.span == Span::default() { + span + } else { + constraint.span + }; match constraint_value { Constraint::Type(primitive) => { if value_matches_primitive(&value, *primitive) { @@ -1082,19 +1491,21 @@ impl Engine { let item_origin = self.thunk_import_origin(item).cloned(); let item_value = self.force(item)?; let composition_span = if item_origin.is_some() { - constraint.span + span } else { item_span }; let constrained = self - .compose_and( - item_constraint_value.clone(), + .apply_as( item_value.clone(), + item_constraint_value.clone(), + span, composition_span, + constraint_span, ) .map_err(|diagnostic| { let diagnostic = diagnostic.with_label( - constraint.span, + constraint_span, "array element constraint declared here", ); if item_origin.is_some() { @@ -1111,7 +1522,7 @@ impl Engine { } })?; let constrained_span = if item_origin.is_some() { - constraint.span + span } else { item_span }; @@ -1125,6 +1536,66 @@ impl Engine { constrained_items, ))) } + Constraint::MapValues(value_constraint) => { + let value_kind = runtime_value_kind(&value); + let RuntimeValue::Concrete(ConcreteValue::Object(object)) = value else { + return Err(self.constraint_violation( + constraint, + span, + value_label, + format!("expected Object, found {value_kind}"), + )); + }; + let value_schema = self.force(*value_constraint)?; + let mut constrained_fields = Vec::with_capacity(object.fields.len()); + for field in object.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)?; + let validation_span = if field_origin.is_some() { + span + } else { + field_span + }; + let constrained = self + .apply_as( + field_value.clone(), + value_schema.clone(), + span, + validation_span, + constraint_span, + ) + .map_err(|diagnostic| { + let diagnostic = diagnostic + .with_label(constraint_span, "map value constraint declared here"); + if field_origin.is_some() { + annotate_imported_value( + diagnostic, + field_origin.as_ref(), + Some(&field_value), + ) + } else { + with_source_label( + diagnostic, + field_span, + format!("map value `{}` checked here", field.name), + ) + } + })?; + constrained_fields.push(ObjectField { + name: field.name, + value: self.add_value_thunk_with_span_and_import_origin( + constrained, + validation_span, + field_origin, + ), + span: field.span, + }); + } + Ok(RuntimeValue::Concrete(ConcreteValue::Object(ObjectValue { + fields: constrained_fields, + }))) + } Constraint::Compare(op, expected) => compare_value(&value, *op, expected) .then_some(value) .ok_or_else(|| { @@ -1136,10 +1607,10 @@ impl Engine { ) }), Constraint::Regex(pattern) => { - satisfies_regex(&value, pattern, constraint.span).map_err(|diag| { - let diag = diag.with_label(constraint.span, "regex constraint declared here"); + satisfies_regex(&value, pattern, constraint_span).map_err(|diag| { + let diag = diag.with_label(constraint_span, "regex constraint declared here"); if let Some((span, message)) = value_label { - diag.with_label(span, message) + with_source_label(diag, span, message) } else { diag } @@ -1148,7 +1619,7 @@ impl Engine { } Constraint::BuiltinPredicate(name) => Err(Diagnostic::new( DiagnosticKind::UnsupportedFeature, - constraint.span, + constraint_span, format!("builtin predicate `{name}` is not implemented"), ) .with_label(span, "constraint checked during this operation")), @@ -1162,15 +1633,20 @@ impl Engine { value_label: Option<(Span, &'static str)>, message: impl Into, ) -> Diagnostic { - let mut diagnostic = Diagnostic::new( - DiagnosticKind::ConstraintViolation, - constraint.span, - message, - ) - .with_label(constraint.span, "constraint declared here") - .with_label(operation_span, "constraint checked during this operation"); + let mut diagnostic = if constraint.span == Span::default() { + Diagnostic::new(DiagnosticKind::ConstraintViolation, operation_span, message) + .with_label(operation_span, "host constraint checked here") + } else { + Diagnostic::new( + DiagnosticKind::ConstraintViolation, + constraint.span, + message, + ) + .with_label(constraint.span, "constraint declared here") + .with_label(operation_span, "constraint checked during this operation") + }; if let Some((span, message)) = value_label { - diagnostic = diagnostic.with_label(span, message); + diagnostic = with_source_label(diagnostic, span, message); } diagnostic } @@ -1247,6 +1723,34 @@ impl Engine { default, })) } + HostValue::MapConstraint { + value, + mut constraints, + default, + } => { + let value = self.internalize_host_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)?; + Some(self.add_value_thunk_with_optional_import_origin(value, origin.cloned())) + } else { + None + }; + constraints.push(Constraint::MapValues(value)); + let constraints = constraints + .into_iter() + .map(|constraint| ConstraintEntry { + constraint, + span: Span::default(), + }) + .collect(); + let constraints = normalize_constraints(constraints, Span::default())?; + Ok(RuntimeValue::Abstract(AbstractValue { + constraints, + default, + })) + } HostValue::Object(fields) => { let mut object = ObjectValue { fields: Vec::new() }; for field in fields { @@ -1337,10 +1841,11 @@ impl Engine { value, value_env, } => { - let span = self.expr_span(value); - let constraint = self.eval_expr(constraint, constraint_env)?; - let value = self.eval_expr(value, value_env)?; - self.compose_and(constraint, value, span) + let value_span = self.expr_span(value); + let wider_span = self.expr_span(constraint); + let wider = self.eval_expr(constraint, constraint_env)?; + let narrower = self.eval_expr(value, value_env)?; + self.apply_as(narrower, wider, value_span, value_span, wider_span) } ThunkKind::Value(value) => Ok(value), }; @@ -1654,17 +2159,136 @@ fn annotate_imported_value( fn runtime_value_kind(value: &RuntimeValue) -> &'static str { match value { - RuntimeValue::Concrete(ConcreteValue::String(_)) => "String", - RuntimeValue::Concrete(ConcreteValue::Int(_)) => "Int", - RuntimeValue::Concrete(ConcreteValue::Float(_)) => "Float", - RuntimeValue::Concrete(ConcreteValue::Bool(_)) => "Bool", - RuntimeValue::Concrete(ConcreteValue::Array(_)) => "Array", - RuntimeValue::Concrete(ConcreteValue::Object(_)) => "Object", - RuntimeValue::Concrete(ConcreteValue::Function(_)) => "Function", + RuntimeValue::Concrete(value) => concrete_value_kind(value), RuntimeValue::Abstract(_) => "abstract", } } +fn concrete_value_kind(value: &ConcreteValue) -> &'static str { + match value { + ConcreteValue::String(_) => "String", + ConcreteValue::Int(_) => "Int", + ConcreteValue::Float(_) => "Float", + ConcreteValue::Bool(_) => "Bool", + ConcreteValue::Array(_) => "Array", + ConcreteValue::Object(_) => "Object", + ConcreteValue::Function(_) => "Function", + } +} + +fn comparison_constraint_is_implied( + narrower: &[ConstraintEntry], + wider_op: CompareOp, + wider_value: &LiteralValue, +) -> bool { + let Some(wider_number) = literal_number(wider_value) else { + return false; + }; + match wider_op { + CompareOp::Gt | CompareOp::Gte => narrower.iter().any(|entry| { + let Constraint::Compare(narrower_op @ (CompareOp::Gt | CompareOp::Gte), value) = + &entry.constraint + else { + return false; + }; + let Some(narrower_number) = literal_number(value) else { + return false; + }; + lower_bound_implies( + narrower_number, + matches!(narrower_op, CompareOp::Gte), + wider_number, + matches!(wider_op, CompareOp::Gte), + ) + }), + CompareOp::Lt | CompareOp::Lte => narrower.iter().any(|entry| { + let Constraint::Compare(narrower_op @ (CompareOp::Lt | CompareOp::Lte), value) = + &entry.constraint + else { + return false; + }; + let Some(narrower_number) = literal_number(value) else { + return false; + }; + upper_bound_implies( + narrower_number, + matches!(narrower_op, CompareOp::Lte), + wider_number, + matches!(wider_op, CompareOp::Lte), + ) + }), + CompareOp::Eq => { + comparison_constraint_is_implied(narrower, CompareOp::Gte, wider_value) + && comparison_constraint_is_implied(narrower, CompareOp::Lte, wider_value) + } + } +} + +fn literal_number(value: &LiteralValue) -> Option { + match value { + LiteralValue::Int(value) => Some(*value as f64), + LiteralValue::Float(value) => Some(*value), + LiteralValue::String(_) | LiteralValue::Bool(_) => None, + } +} + +fn lower_bound_implies( + narrower: f64, + narrower_inclusive: bool, + wider: f64, + wider_inclusive: bool, +) -> bool { + narrower > wider || (narrower == wider && (!narrower_inclusive || wider_inclusive)) +} + +fn upper_bound_implies( + narrower: f64, + narrower_inclusive: bool, + wider: f64, + wider_inclusive: bool, +) -> bool { + narrower < wider || (narrower == wider && (!narrower_inclusive || wider_inclusive)) +} + +fn constraint_description(constraint: &Constraint) -> String { + match constraint { + Constraint::Type(primitive) => format!("type {primitive:?}"), + Constraint::ArrayItems(_) => String::from("an array element range"), + Constraint::MapValues(_) => String::from("a map value range"), + Constraint::Compare(op, value) => { + format!("numeric range {} {value:?}", compare_operator_text(*op)) + } + Constraint::Regex(pattern) => format!("regex /{pattern}/"), + Constraint::BuiltinPredicate(name) => format!("predicate `{name}`"), + } +} + +fn compare_operator_text(op: CompareOp) -> &'static str { + match op { + CompareOp::Gt => ">", + CompareOp::Gte => ">=", + CompareOp::Lt => "<", + CompareOp::Lte => "<=", + CompareOp::Eq => "==", + } +} + +fn with_source_label(diagnostic: Diagnostic, span: Span, message: impl Into) -> Diagnostic { + if span == Span::default() { + diagnostic + } else { + diagnostic.with_label(span, message) + } +} + +fn source_span_or(span: Span, fallback: Span) -> Span { + if span == Span::default() { + fallback + } else { + span + } +} + #[cfg(feature = "regex")] fn satisfies_regex(value: &RuntimeValue, pattern: &str, span: Span) -> Result<()> { let RuntimeValue::Concrete(ConcreteValue::String(value)) = value else { @@ -2159,6 +2783,15 @@ mod tests { }; assert_eq!(fields[0].value, Data::String(String::from("api"))); assert_eq!(fields[1].value, Data::Bool(true)); + + let parsed = + parse_source(r#"[...{ name = String; }] & [{ name = "api"; typo = true; }]"#).unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let error = engine.eval_root().unwrap_err(); + assert_eq!( + error.message, + "field `typo` is not present on the wider side of `as`" + ); } #[test] @@ -2173,6 +2806,180 @@ mod tests { ); } + #[test] + fn ascription_refines_present_fields_and_materializes_later() { + let data = eval_data( + r#" + { + host = "localhost"; + } as { + host = String; + port = Int default 8080; + } + "#, + ); + assert_eq!( + data, + Data::Object(vec![ + DataField { + name: String::from("host"), + value: Data::String(String::from("localhost")), + }, + DataField { + name: String::from("port"), + value: Data::Int(8080), + }, + ]) + ); + } + + #[test] + fn ascription_rejects_fields_outside_the_wider_object() { + let parsed = parse_source(r#"{ typo = 1; } as { name = String; }"#).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_eq!( + error.message, + "field `typo` is not present on the wider side of `as`" + ); + } + + #[test] + fn ascription_keeps_right_only_fields_abstract_without_forcing_defaults() { + let parsed = + parse_source(r#"{} as { name = String; delayed = Int default unresolved_default; }"#) + .unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let value = engine.eval_root().unwrap(); + let RuntimeValue::Concrete(ConcreteValue::Object(object)) = &value else { + panic!() + }; + assert_eq!(object.fields.len(), 2); + + let error = engine.materialize(&value).unwrap_err(); + assert_eq!(error.kind, DiagnosticKind::Materialize); + assert!(error.message.contains("unresolved abstract value")); + } + + #[test] + fn abstract_ascription_requires_and_preserves_the_narrower_range() { + let parsed = parse_source("Int & > 10 as Int & > 0").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let value = engine.eval_root().unwrap(); + let RuntimeValue::Abstract(value) = value else { + panic!() + }; + assert_eq!(value.constraints.len(), 2); + assert!(value.default.is_none()); + + let parsed = parse_source("Int as Int & > 0").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("(Int & > 0) as (Int default 1)").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let value = engine.eval_root().unwrap(); + let RuntimeValue::Abstract(value) = value else { + panic!() + }; + assert!(value.default.is_none()); + } + + #[test] + fn abstract_collection_ranges_can_be_proven_narrower() { + let parsed = parse_source("[...(Int & > 10)] as [...Int]").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + assert!(matches!( + engine.eval_root().unwrap(), + RuntimeValue::Abstract(_) + )); + + let parsed = parse_source("[...Int] as [...(Int & > 10)]").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + assert!(engine.eval_root().is_err()); + + let parsed = parse_source("{...(Int & > 10)} as {...Int}").unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + assert!(matches!( + engine.eval_root().unwrap(), + RuntimeValue::Abstract(_) + )); + } + + #[test] + fn constrained_parameters_use_as_range_refinement() { + let data = eval_data( + r#" + let + identity = (service: { + name = String; + enabled = Bool default true; + }) => service; + in identity({ name = "api"; }) + "#, + ); + let Data::Object(fields) = data else { panic!() }; + assert_eq!(fields[1].value, Data::Bool(true)); + + let parsed = parse_source( + r#"let accept = (value: { name = String; }) => value; in accept({ name = "api"; typo = true; })"#, + ) + .unwrap(); + let mut engine = Engine::from_parse(parsed.ast, parsed.root); + let error = engine.eval_root().unwrap_err(); + assert_eq!( + error.message, + "field `typo` is not present on the wider side of `as`" + ); + } + + #[test] + fn map_constraint_validates_arbitrary_keys_and_closed_values() { + let data = eval_data( + r#" + { + api = { port = 8080; }; + worker = { port = 9000; }; + } as {...{ + port = Int & > 0; + }} + "#, + ); + let Data::Object(fields) = data else { panic!() }; + assert_eq!(fields.len(), 2); + + let parsed = + parse_source(r#"{ api = { port = 8080; typo = true; }; } as {...{ port = 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_eq!( + error.message, + "field `typo` is not present on the wider side of `as`" + ); + } + + #[test] + fn map_constraint_composes_with_objects_and_accepts_empty_maps() { + assert_eq!( + eval_data("{...Int} & { first = 1; second = 2; }"), + Data::Object(vec![ + DataField { + name: String::from("first"), + value: Data::Int(1), + }, + DataField { + name: String::from("second"), + value: Data::Int(2), + }, + ]) + ); + assert_eq!(eval_data("{} as {...String}"), Data::Object(vec![])); + } + #[test] fn removed_array_primitive_reports_migration() { let parsed = parse_source("Array").unwrap(); @@ -2254,6 +3061,23 @@ mod tests { assert_eq!(fields[0].value, Data::Int(8000)); } + #[test] + fn object_composition_keeps_fields_present_on_only_one_side() { + assert_eq!( + eval_data("{ left = 1; } & { right = 2; }"), + Data::Object(vec![ + DataField { + name: String::from("left"), + value: Data::Int(1), + }, + DataField { + name: String::from("right"), + value: Data::Int(2), + }, + ]) + ); + } + #[test] fn detects_constraint_violation() { let parsed = parse_source("{ port = Int & > 443; } & { port = 80; }").unwrap(); @@ -2378,7 +3202,7 @@ mod tests { }; body = String; }; - post = Post & import "./post.md"; + post = import "./post.md" as Post; in { title = post.frontmatter.title; draft = post.frontmatter.draft; @@ -2416,7 +3240,7 @@ mod tests { }; body = String; }; - in Post & import "./post.md" + in import "./post.md" as Post "#, ) .unwrap(); @@ -2466,7 +3290,7 @@ mod tests { .add_root_source( "main.dcdl", "main.dcdl", - r#"{ items = [...String]; } & import "./navigation.json""#, + r#"import "./navigation.json" as { items = [...String]; }"#, ) .unwrap(); let error = engine.eval_module(module).unwrap_err(); @@ -2544,7 +3368,7 @@ mod tests { .add_root_source( "main", "main", - r#"Service & { name = "api"; port = 9443; }"#, + r#"{ name = "api"; port = 9443; } as Service"#, ) .unwrap(); let value = engine.eval_module(module).unwrap(); @@ -2555,6 +3379,59 @@ mod tests { assert_eq!(fields[2].value, Data::Bool(true)); } + #[test] + fn host_prelude_provides_map_schema() { + let mut engine = Engine::new(EmptyLoader); + engine + .bind_global( + "Services", + HostValue::map_of(HostValue::object([ + ("port", HostValue::int_type()), + ( + "enabled", + HostValue::bool_type().default_bool(true).unwrap(), + ), + ])), + ) + .unwrap(); + let module = engine + .add_root_source("main", "main", r#"{ api = { port = 8080; }; } as Services"#) + .unwrap(); + let value = engine.eval_module(module).unwrap(); + let data = engine.materialize(&value).unwrap(); + let Data::Object(services) = data else { + panic!() + }; + let Data::Object(api) = &services[0].value else { + panic!() + }; + assert_eq!(api[0].value, Data::Int(8080)); + assert_eq!(api[1].value, Data::Bool(true)); + } + + #[test] + fn host_schema_errors_point_to_the_dcdl_application() { + let mut engine = Engine::new(EmptyLoader); + engine + .bind_global( + "Service", + HostValue::object([("port", HostValue::int_type())]), + ) + .unwrap(); + let module = engine + .add_root_source("main", "main", r#"{ port = "not-an-int"; } as Service"#) + .unwrap(); + let error = engine.eval_module(module).unwrap_err(); + assert_eq!(error.message, "expected Int, found String"); + assert_ne!(error.span, Span::default()); + assert!( + error + .labels + .iter() + .all(|label| label.span != Span::default()) + ); + } + #[test] fn module_binding_shadows_host_prelude() { let mut engine = Engine::new(EmptyLoader); diff --git a/crates/decodal-core/src/lexer.rs b/crates/decodal-core/src/lexer.rs index 88d67ca..236b1ef 100644 --- a/crates/decodal-core/src/lexer.rs +++ b/crates/decodal-core/src/lexer.rs @@ -22,6 +22,7 @@ pub enum TokenKind { Match, Import, Default, + As, Underscore, LBrace, RBrace, @@ -406,6 +407,7 @@ impl<'a> Lexer<'a> { "match" => TokenKind::Match, "import" => TokenKind::Import, "default" => TokenKind::Default, + "as" => TokenKind::As, _ => TokenKind::Ident(String::from(text)), } } diff --git a/crates/decodal-core/src/parser.rs b/crates/decodal-core/src/parser.rs index 01b982e..5e795a7 100644 --- a/crates/decodal-core/src/parser.rs +++ b/crates/decodal-core/src/parser.rs @@ -245,6 +245,13 @@ impl Parser { }, span, ), + InfixKind::As => self.ast.push( + Expr::As { + narrower: lhs, + wider: rhs, + }, + span, + ), }; } @@ -319,6 +326,16 @@ impl Parser { } fn parse_object_after_lbrace(&mut self, start_span: Span) -> Result { + if self.consume_kind(&TokenKind::Ellipsis).is_some() { + let value = self.parse_expr(0)?; + self.expect_kind( + &TokenKind::RBrace, + "expected '}' after map value constraint", + )?; + let span = start_span.join(self.previous_span()); + return Ok(self.ast.push(Expr::MapConstraint { value }, span)); + } + let mut fields = Vec::new(); if self.consume_kind(&TokenKind::RBrace).is_some() { return Ok(self @@ -544,6 +561,7 @@ impl Parser { fn peek_infix(&self) -> Option<(InfixKind, u8, u8)> { match self.peek_kind() { + TokenKind::As => Some((InfixKind::As, 0, 1)), TokenKind::Default => Some((InfixKind::Default, 1, 2)), TokenKind::SlashSlash => Some((InfixKind::Patch, 3, 4)), TokenKind::Amp => Some((InfixKind::And, 5, 6)), @@ -652,6 +670,7 @@ impl Parser { #[derive(Debug, Clone, Copy)] enum InfixKind { + As, Add, Sub, Mul, @@ -720,4 +739,23 @@ mod tests { fn rejects_array_constraint_without_element_constraint() { assert!(parse_source("[...]").is_err()); } + + #[test] + fn parses_map_constraint() { + let parsed = parse_source("{...String}").unwrap(); + let Expr::MapConstraint { value } = parsed.ast.get(parsed.root).expr else { + panic!() + }; + assert!(matches!(parsed.ast.get(value).expr, Expr::Ident(_))); + } + + #[test] + fn parses_as_below_composition() { + let parsed = parse_source("value & override as Schema").unwrap(); + let Expr::As { narrower, wider } = parsed.ast.get(parsed.root).expr else { + panic!() + }; + assert!(matches!(parsed.ast.get(narrower).expr, Expr::Binary { .. })); + assert!(matches!(parsed.ast.get(wider).expr, Expr::Ident(_))); + } } diff --git a/crates/decodal-core/src/runtime.rs b/crates/decodal-core/src/runtime.rs index e721c1c..f8979cd 100644 --- a/crates/decodal-core/src/runtime.rs +++ b/crates/decodal-core/src/runtime.rs @@ -69,6 +69,7 @@ pub struct ConstraintEntry { pub enum Constraint { Type(PrimitiveType), ArrayItems(ThunkId), + MapValues(ThunkId), Compare(CompareOp, LiteralValue), Regex(String), BuiltinPredicate(String), diff --git a/crates/decodal-core/src/typed.rs b/crates/decodal-core/src/typed.rs index 38e9ce9..3637358 100644 --- a/crates/decodal-core/src/typed.rs +++ b/crates/decodal-core/src/typed.rs @@ -1,4 +1,4 @@ -use alloc::{format, string::String, vec::Vec}; +use alloc::{collections::BTreeMap, format, string::String, vec::Vec}; use crate::{Data, HostValue}; @@ -225,3 +225,96 @@ impl IntoHostValue for Vec { HostValue::array(self.into_iter().map(IntoHostValue::into_host_value)) } } + +impl DecodalSchema for BTreeMap { + fn decodal_schema() -> HostValue { + HostValue::map_of(T::decodal_schema()) + } +} + +impl DecodalDecode for BTreeMap { + fn decodal_decode(data: &Data) -> DecodeResult { + match data { + Data::Object(fields) => fields + .iter() + .map(|field| { + T::decodal_decode(&field.value) + .map(|value| (field.name.clone(), value)) + .map_err(|error| prefix_error(&field.name, error)) + }) + .collect(), + _ => Err(DecodeError::at_type("", "Object")), + } + } +} + +impl IntoHostValue for BTreeMap { + fn into_host_value(self) -> HostValue { + HostValue::object( + self.into_iter() + .map(|(name, value)| (name, value.into_host_value())), + ) + } +} + +#[cfg(feature = "std")] +impl DecodalSchema for std::collections::HashMap { + fn decodal_schema() -> HostValue { + HostValue::map_of(T::decodal_schema()) + } +} + +#[cfg(feature = "std")] +impl DecodalDecode for std::collections::HashMap { + fn decodal_decode(data: &Data) -> DecodeResult { + match data { + Data::Object(fields) => fields + .iter() + .map(|field| { + T::decodal_decode(&field.value) + .map(|value| (field.name.clone(), value)) + .map_err(|error| prefix_error(&field.name, error)) + }) + .collect(), + _ => Err(DecodeError::at_type("", "Object")), + } + } +} + +#[cfg(feature = "std")] +impl IntoHostValue for std::collections::HashMap { + fn into_host_value(self) -> HostValue { + let mut fields: Vec<_> = self + .into_iter() + .map(|(name, value)| (name, value.into_host_value())) + .collect(); + fields.sort_by(|left, right| left.0.cmp(&right.0)); + HostValue::object(fields) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::runtime::{Constraint, DataField, PrimitiveType}; + + #[test] + fn string_maps_expose_map_schemas_and_decode_objects() { + assert!(matches!( + BTreeMap::::decodal_schema(), + HostValue::MapConstraint { value, .. } + if matches!( + *value, + HostValue::Abstract { ref constraints, .. } + if constraints == &[Constraint::Type(PrimitiveType::Int)] + ) + )); + + let data = Data::Object(alloc::vec![DataField { + name: String::from("api"), + value: Data::Int(8080), + }]); + let decoded = BTreeMap::::decodal_decode(&data).unwrap(); + assert_eq!(decoded.get("api"), Some(&8080)); + } +} diff --git a/crates/decodal-language-service/src/completion.rs b/crates/decodal-language-service/src/completion.rs index 188e490..9c27e8c 100644 --- a/crates/decodal-language-service/src/completion.rs +++ b/crates/decodal-language-service/src/completion.rs @@ -222,6 +222,7 @@ fn builtin_items() -> Vec { ("match", CompletionKind::Keyword, "pattern matching", 5), ("import", CompletionKind::Keyword, "load a module", 5), ("default", CompletionKind::Keyword, "fallback value", 0), + ("as", CompletionKind::Keyword, "refine narrower as wider", 0), ("true", CompletionKind::Constant, "Bool", 0), ("false", CompletionKind::Constant, "Bool", 0), ("String", CompletionKind::Type, "string constraint", 5), @@ -276,6 +277,10 @@ fn fields_from_host_value(value: &HostValue) -> FieldTree { default: Some(value), .. } + | HostValue::MapConstraint { + default: Some(value), + .. + } | HostValue::Abstract { default: Some(value), .. diff --git a/crates/decodal-language-tools/src/lib.rs b/crates/decodal-language-tools/src/lib.rs index 0ac68e7..59dc44e 100644 --- a/crates/decodal-language-tools/src/lib.rs +++ b/crates/decodal-language-tools/src/lib.rs @@ -169,6 +169,11 @@ impl<'a> Formatter<'a> { self.write_expr(out, *item, indent, 0); out.push(']'); } + Expr::MapConstraint { value } => { + out.push_str("{..."); + self.write_expr(out, *value, indent, 0); + out.push('}'); + } Expr::Let { bindings, body } => self.write_let(out, node.span, bindings, *body, indent), Expr::Import(_) => { out.push_str("import "); @@ -219,6 +224,11 @@ impl<'a> Formatter<'a> { out.push_str(" default "); self.write_expr(out, *fallback, indent, precedence + 1); } + Expr::As { narrower, wider } => { + self.write_expr(out, *narrower, indent, precedence); + out.push_str(" as "); + self.write_expr(out, *wider, indent, precedence + 1); + } Expr::CompareConstraint { op, value } => { out.push_str(compare_operator(*op)); out.push(' '); @@ -461,6 +471,7 @@ impl<'a> Formatter<'a> { fn precedence(&self, id: ExprId) -> u8 { match &self.ast.get(id).expr { + Expr::As { .. } => 0, Expr::Default { .. } => 1, Expr::Binary { op, .. } => match op { BinaryOp::Patch => 3, @@ -508,7 +519,11 @@ impl<'a> Formatter<'a> { } Expr::Array(items) => items.iter().all(|item| self.is_inline_expr(*item)), Expr::ArrayConstraint { item } => self.is_inline_expr(*item), + Expr::MapConstraint { value } => self.is_inline_expr(*value), Expr::Parenthesized { expr } => self.is_inline_expr(*expr), + Expr::As { narrower, wider } => { + self.is_inline_expr(*narrower) && self.is_inline_expr(*wider) + } Expr::Object(_) | Expr::Let { .. } | Expr::Function { .. } | Expr::Match { .. } => { false } @@ -670,6 +685,18 @@ mod tests { ); } + #[test] + fn formats_map_constraints_and_range_ascription() { + let source = + "config={service={port=8080;};}as{service={port=Int;};};labels={a=1;b=2;}as{...Int};"; + let formatted = format_source(source).unwrap(); + assert_eq!( + formatted, + "config = {\n service = {\n port = 8080;\n };\n} as {\n service = {\n port = Int;\n };\n};\nlabels = {\n a = 1;\n b = 2;\n} as {...Int};\n" + ); + assert_eq!(format_source(&formatted).unwrap(), formatted); + } + #[test] fn formats_let_functions_and_precedence_from_the_canonical_ast() { let source = "value=let x=1+2*3;in(a:Int)=>{result=(x+a)*2;};"; @@ -743,6 +770,10 @@ mod tests { include_str!("../../../examples/import/schema.dcdl"), ), ("logical", include_str!("../../../examples/logical.dcdl")), + ( + "map-ascription", + include_str!("../../../examples/map-ascription.dcdl"), + ), ( "regex/main", include_str!("../../../examples/regex/main.dcdl"), diff --git a/crates/decodal-wasm/src/host_value.rs b/crates/decodal-wasm/src/host_value.rs index e30df7b..f9b90a2 100644 --- a/crates/decodal-wasm/src/host_value.rs +++ b/crates/decodal-wasm/src/host_value.rs @@ -84,6 +84,16 @@ fn object(fields: &Map) -> Result { default, }) } + "Map" => { + let value = fields + .get("value") + .ok_or_else(|| String::from("Map descriptor requires `value`"))?; + Ok(HostValue::MapConstraint { + value: Box::new(from_json(value)?), + constraints, + default, + }) + } "Abstract" => Ok(HostValue::Abstract { constraints, default, @@ -217,6 +227,23 @@ mod tests { ); } + #[test] + fn converts_map_schema_descriptors() { + let value = serde_json::json!({ + "$decodal": "Map", + "value": { "$decodal": "Bool" }, + "default": {}, + }); + assert_eq!( + from_json(&value).unwrap(), + HostValue::MapConstraint { + value: Box::new(HostValue::bool_type()), + constraints: Vec::new(), + default: Some(Box::new(HostValue::object([] as [(&str, HostValue); 0]))), + } + ); + } + #[test] fn rejects_null_values() { assert!( diff --git a/doc/manual/souce/design/composition-and-materialization.md b/doc/manual/souce/design/composition-and-materialization.md index 3e6aec5..2583c18 100644 --- a/doc/manual/souce/design/composition-and-materialization.md +++ b/doc/manual/souce/design/composition-and-materialization.md @@ -1,6 +1,6 @@ # Composition and Materialization -`&`、`//`、`default`、materialize は、runtime value の variant に基づいて処理する。 +`&`、`//`、`as`、`default`、materialize は、runtime value の variant に基づいて処理する。 ## `&` @@ -89,7 +89,24 @@ patch(a: RuntimeValue, b: RuntimeValue) -> RuntimeValue - 配列、scalar、function は右辺置換とする。 `//` は制約を保持するための演算子ではない。 -制約を満たす具体化には `&` を使う。 +対称な制約合成には `&` を使い、左辺が右辺より狭いことを確認しながら合成する場合は `as` を使う。 + +## `as` + +`as` は narrower と wider の向きを固定した範囲包含確認と合成である。 + +```text +apply_as(narrower: RuntimeValue, wider: RuntimeValue) + -> RuntimeValue | Diagnostic +``` + +abstract / abstract では、左辺 constraints が右辺 constraints を包含することを確認し、左辺を結果にする。 +concrete / abstract では、concrete value が右辺 constraints を満たすことを確認する。 + +object / object では右辺を field domain とする。左辺にしかない field は診断し、両側にある field は再帰的に `apply_as` し、右辺にしかない field は thunk を force せずそのまま結果へ残す。 +この扱いは default の有無に依存しない。default は包含判定の根拠でも `as` の補完値でもなく、後の materialize だけが選択する。 + +`ArrayItems(wider)` は concrete array の全要素を、`MapValues(wider)` は concrete object の全 field value を同じ関数で絞り込む。 ## materialize diff --git a/doc/manual/souce/design/embedding-api.md b/doc/manual/souce/design/embedding-api.md index 10e2452..f5abcc4 100644 --- a/doc/manual/souce/design/embedding-api.md +++ b/doc/manual/souce/design/embedding-api.md @@ -41,10 +41,10 @@ engine.bind_global( A user source can then refer to `Service` without importing it. ```dcdl -Service & { +{ name = "api"; port = 9443; -} +} as Service ``` ## HostValue @@ -60,6 +60,7 @@ HostValue = Bool Array(Vec) ArrayConstraint { item, constraints, default } + MapConstraint { value, constraints, default } Object(Vec) Abstract { constraints, default } ``` @@ -69,6 +70,9 @@ When a host value is bound, the engine internalizes it into `RuntimeValue` and a `HostValue::array_of(item)` builds an array constraint with a required element schema. There is no host API 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. + ## Abstract host objects A host-provided schema object is represented as a concrete object structure whose fields may contain abstract values. diff --git a/doc/manual/souce/design/execution-pipeline.md b/doc/manual/souce/design/execution-pipeline.md index 71378d6..8d3d1e3 100644 --- a/doc/manual/souce/design/execution-pipeline.md +++ b/doc/manual/souce/design/execution-pipeline.md @@ -16,7 +16,8 @@ demand-driven evaluation ├─ load imported module on demand ├─ evaluate expression ├─ compose `&` - └─ patch `//` + ├─ patch `//` + └─ validate `as` ↓ materialize ↓ @@ -105,9 +106,16 @@ eval(A // B): a = eval(A) b = eval(B) patch(a, b) + +eval(A as S): + narrower = eval(A) + wider = eval(S) + apply_as(narrower, wider) ``` -`&` は制約を保った合成を行い、`//` は右辺優先の deep patch を行う。 +`&` は制約を保った対称な合成を行い、`//` は右辺優先の deep patch を行う。 +`as` は左辺が右辺より狭いことを再帰的に確認する。左辺で絞られた部分は左辺を使い、右辺だけの部分は abstract のまま保持する。 +default は `as` では選択せず、materialize まで遅延する。 詳細は [Composition and Materialization](./composition-and-materialization.md) に置く。 ## resolver / binder @@ -140,7 +148,7 @@ resolver / binder を追加すると、以下を早期に診断しやすくな - import path の一部静的解決 - span 付き diagnostic の精度向上 -ただし、Decodal の制約検証は独立した type checking pass ではなく、`&` の合成時や materialize 時に行う。 +ただし、Decodal の制約検証は独立した type checking pass ではなく、`&` の合成時、`as` の適用時、materialize 時に行う。 ## materialize diff --git a/doc/manual/souce/design/features.md b/doc/manual/souce/design/features.md index c8d5c06..28dbcf9 100644 --- a/doc/manual/souce/design/features.md +++ b/doc/manual/souce/design/features.md @@ -10,6 +10,7 @@ Core に入れる機能は、基本的に deterministic な value transformation - arithmetic / logical / comparison operators - array concat - object / constraint composition +- asymmetric range refinement and homogeneous map constraints - default materialization - pure function evaluation - host supplied import evaluation diff --git a/doc/manual/souce/design/index.md b/doc/manual/souce/design/index.md index f6da3d6..388b18e 100644 --- a/doc/manual/souce/design/index.md +++ b/doc/manual/souce/design/index.md @@ -6,7 +6,7 @@ ## 方針 初期処理系は AST interpreter として実装する。 -bytecode VM や JIT ではなく、AST を demand-driven に評価することで、遅延評価、循環参照、`default`、`&`、`//` の意味論を小さく実装する。 +bytecode VM や JIT ではなく、AST を demand-driven に評価することで、遅延評価、循環参照、`default`、`&`、`//`、`as` の意味論を小さく実装する。 ## 構成 diff --git a/doc/manual/souce/design/runtime-model.md b/doc/manual/souce/design/runtime-model.md index 69d41d7..fa04888 100644 --- a/doc/manual/souce/design/runtime-model.md +++ b/doc/manual/souce/design/runtime-model.md @@ -124,6 +124,7 @@ constraint は concrete value とは別の型として扱う。 Constraint = Type(PrimitiveType) ArrayItems(ThunkId) + MapValues(ThunkId) Compare(Op, Literal) Regex(Pattern) BuiltinPredicate(Symbol) @@ -133,6 +134,9 @@ Constraint = `ArrayItems` は配列そのものの型と、すべての要素へ合成する schema thunk を表す。 配列用の primitive type は持たず、抽象配列には必ず要素制約が必要である。 +`MapValues` は object の key 集合を制限せず、すべての field value へ適用する schema thunk を表す。 +連想配列は materialize 後も `Data::Object` になり、別の data variant は持たない。 + 初期実装では、object の形は主に `Concrete(Object)` の field に `Abstract` を置くことで表現する。 object 全体にかかる constraint は必要になった時点で追加する。 diff --git a/doc/manual/souce/index.md b/doc/manual/souce/index.md index b4a1323..8902709 100644 --- a/doc/manual/souce/index.md +++ b/doc/manual/souce/index.md @@ -26,8 +26,9 @@ Decodal は Deferred Constraint Data Language、略称 DCDL のプロジェク 9. [Match](./language/expression/match.md) 10. [Import](./language/expression/import.md) 11. [Composition](./language/expression/composition.md) - 12. [Default](./language/expression/default.md) - 13. [String Interpolation](./language/expression/string-interpolation.md) + 12. [Range Refinement](./language/expression/ascription.md) + 13. [Default](./language/expression/default.md) + 14. [String Interpolation](./language/expression/string-interpolation.md) 4. [Constraints and Defaults](./language/constraints-and-defaults.md) 5. [Composition Operators](./language/operators.md) 6. [Functions](./language/functions.md) diff --git a/doc/manual/souce/language/constraints-and-defaults.md b/doc/manual/souce/language/constraints-and-defaults.md index 4ead231..15471ab 100644 --- a/doc/manual/souce/language/constraints-and-defaults.md +++ b/doc/manual/souce/language/constraints-and-defaults.md @@ -133,10 +133,25 @@ Names = [...String]; PositiveInts = [...(Int & > 0)]; ``` -複数の配列制約を `&` で合成した場合、各 concrete 要素へすべての要素制約を合成する。 -要素が object schema の場合は、その schema に含まれる default も各要素へ適用される。 +複数の配列制約を `&` で合成した場合、各 concrete 要素をすべての要素 range で絞り込む。 +要素が object range の場合、右辺にしかない field は default の有無にかかわらず abstract のまま各要素へ残る。 +左辺にしかない field は右辺の field domain 外なのでエラーになる。 要素制約のない `Array` primitive type は存在しない。 +## 連想配列制約 + +連想配列制約は `{...T}` と書き、object の任意の field value を `T` に対して絞り込む。 + +```dcdl +Services = {...{ + port = Int; + enabled = Bool default true; +}}; +``` + +key は schema で列挙せず、空 object も許容する。 +固定 object field と任意 key の value constraint を混在させる構文は現在サポートしない。 + ## default `default` は制約ではない。 diff --git a/doc/manual/souce/language/examples.md b/doc/manual/souce/language/examples.md index 8bd7f3c..d23cc7d 100644 --- a/doc/manual/souce/language/examples.md +++ b/doc/manual/souce/language/examples.md @@ -39,15 +39,32 @@ Services = [...{ port = Int default 8080; }]; -Services & [ +[ { name = "api"; }, { name = "worker"; port = 9000; }, -] +] as Services ``` 抽象配列には要素制約が必須である。 この例では、1 番目の要素の `port` は `8080` に materialize される。 +## 連想配列と範囲絞り込み + +```dcdl +Service = { + port = Int; + enabled = Bool default true; +}; + +services = { + api = { port = 8080; }; + worker = { port = 8081; enabled = false; }; +} as {...Service}; +``` + +`api` と `worker` は任意の key であり、それぞれの value は `Service` より狭い範囲へ絞り込まれる。 +`as` の結果では `api.enabled` は abstract のまま残り、最終的に結果全体を materialize した時点で default の `true` が使われる。 + ## 関数と制約 ```dcdl diff --git a/doc/manual/souce/language/expression/array.md b/doc/manual/souce/language/expression/array.md index d482f3a..8151808 100644 --- a/doc/manual/souce/language/expression/array.md +++ b/doc/manual/souce/language/expression/array.md @@ -30,8 +30,9 @@ Ports = [...(Int & >= 1 & <= 65535)]; [...String] & ["api", "worker"] ``` -要素制約は object schema にもできる。 -要素 schema の default は、配列へ制約を合成するときに各要素へ適用される。 +要素制約は object range にもできる。 +右辺だけにある default 付き field は、配列へ制約を合成した時点では abstract のまま各要素に残る。 +その配列を後から materialize した場合にだけ default が使われる。 ```dcdl Services = [...{ @@ -42,6 +43,9 @@ Services = [...{ Services & [{ name = "api"; }] ``` +配列制約を concrete array に適用すると、各要素は要素 range に対して `as` と同じ規則で絞り込まれる。 +object の要素 range では左辺にしかない field がエラーになり、右辺にしかない field は abstract のまま残る。 + 要素制約のない抽象配列型は提供しない。 旧来の `Array` primitive type は使用できず、`[...T]` の `T` は必須である。 `[String]` は配列制約ではなく、未解決の `String` 制約を 1 要素に持つ concrete array になる。 diff --git a/doc/manual/souce/language/expression/ascription.md b/doc/manual/souce/language/expression/ascription.md new file mode 100644 index 0000000..f8f3434 --- /dev/null +++ b/doc/manual/souce/language/expression/ascription.md @@ -0,0 +1,75 @@ +# Range Refinement + +`narrower as wider` は、左辺が右辺より具体的で狭い範囲であることを確認し、両者を非対称に合成する演算である。 + +```dcdl +Int & > 10 as Int & > 0 +``` + +この例は成功し、結果は左辺の狭い範囲 `Int & > 10` のままになる。逆向きの `Int as Int & > 0` は、左辺が右辺を満たすとは限らないため失敗する。 + +## Object + +object では、右辺を field domain として左辺の field を確認する。 + +- 左辺にしかない field は、右辺の domain 外なのでエラーになる。 +- 両側にある field は、左辺が右辺より狭いかを再帰的に確認し、左辺の狭い結果を使う。 +- 右辺にしかない field は、default の有無に関係なく未評価のまま結果へ残す。 +- 結果の field order は右辺の順序に従う。 + +```dcdl +partial = { + port = 8080; +} as { + host = String; + port = Int; + enabled = Bool default true; +}; +``` + +`partial.port` は `8080` に具体化される。`partial.host` と `partial.enabled` は右辺由来の abstract field のままであり、`as` は `enabled` の default を選択も force もしない。 + +その後 `partial` 全体を materialize すれば、通常の materialize 規則が適用される。この例では unresolved な `host` がエラーになり、`host` も具体化されていれば `enabled` の default がその時点で利用される。 + +## Default + +default は範囲包含の根拠ではない。両側に同じ field がある場合、結果には左辺を使うため、右辺の default を左辺へ注入しない。 + +```dcdl +Int & > 0 as (Int default 1) +``` + +結果は default のない `Int & > 0` である。一方、右辺だけに残る object field は field 全体を保持するため、その abstract value が元から持つ default も保持される。 + +## Map and array ranges + +`{...T}` は任意の object key を許可し、各 value が `T` より狭いことを確認する。 + +```dcdl +ports = { + http = 80; + https = 443; +} as {...(Int & >= 1 & <= 65535)}; +``` + +`[...T]` を右辺に使う場合も、すべての array element を `T` に対して絞り込む。 + +## Concrete right-hand ranges + +primitive constraint や合成 constraint は通常どおり値を検証する。 +右辺が concrete scalar または array literal の場合は、左辺も同じ値または同じ長さ・要素構造である必要がある。 +function は右辺の範囲として使用できない。 + +左辺は concrete value に限らない。処理系が包含を確認できる constraint 同士であれば abstract value も使用できる。primitive type、numeric bound、同一 regex / predicate、array/map の要素範囲は包含確認の対象になる。 + +関数 parameter の `name: range` も、引数が force された時点で `as` と同じ絞り込み規則を使う。 + +## Precedence + +`as` は `default` より低い、最も低い優先順位を持ち、左結合である。 + +```dcdl +narrow & overrides as Wider +``` + +これは `(narrow & overrides) as Wider` と解釈される。 diff --git a/doc/manual/souce/language/expression/composition.md b/doc/manual/souce/language/expression/composition.md index c8e9fc7..d04f8b2 100644 --- a/doc/manual/souce/language/expression/composition.md +++ b/doc/manual/souce/language/expression/composition.md @@ -11,6 +11,9 @@ Port = Int & >= 1 & <= 65535; Config = MyConfig & { port = 8000; }; ``` +object 同士では片側だけにある field も保持するため、`&` は方向を持たない。 +左辺が右辺より狭いことを確認し、右辺を field domain として合成したい場合は [`as`](./ascription.md) を使う。 + ## `//` `//` は右辺優先の構造的 patch を行う。 diff --git a/doc/manual/souce/language/expression/function-call.md b/doc/manual/souce/language/expression/function-call.md index ca3fcb2..686134a 100644 --- a/doc/manual/souce/language/expression/function-call.md +++ b/doc/manual/souce/language/expression/function-call.md @@ -10,6 +10,8 @@ increment(41) 引数は thunk として渡せる。 関数本体内で引数が参照されたときに評価する。 +parameter に range が指定されている場合、引数は `narrower as wider` と同じ規則で絞り込まれる。 +parameter 側だけにある field は abstract のまま残り、default はこの時点では選択されない。 関数呼び出し結果そのものはグローバルには memoize しない。 フィールドに束縛された呼び出し結果は、そのフィールド thunk の評価結果として memoize される。 diff --git a/doc/manual/souce/language/expression/index.md b/doc/manual/souce/language/expression/index.md index 9062a83..74f97f2 100644 --- a/doc/manual/souce/language/expression/index.md +++ b/doc/manual/souce/language/expression/index.md @@ -10,6 +10,7 @@ Expr ├─ identifier ├─ path reference ├─ object +├─ map constraint ├─ array ├─ array constraint ├─ function @@ -18,6 +19,7 @@ Expr ├─ match ├─ import ├─ composition +├─ range refinement (`as`) ├─ default └─ string interpolation ``` diff --git a/doc/manual/souce/language/expression/object.md b/doc/manual/souce/language/expression/object.md index c6d2aff..073c1f3 100644 --- a/doc/manual/souce/language/expression/object.md +++ b/doc/manual/souce/language/expression/object.md @@ -37,3 +37,30 @@ MyConfig = { }; } ``` + +## Map constraint + +連想配列の制約は、object の任意の field value に同じ schema を適用する。 + +```dcdl +Services = {...{ + port = Int; + enabled = Bool default true; +}}; +``` + +`{...T}` は key の集合を固定せず、すべての value が `T` を満たす object を表す。 +空 object も許容される。runtime と materialize 後の表現は通常の object と共通であり、別の map value variant は持たない。 + +```dcdl +services = { + api = { port = 8080; }; + worker = { port = 8081; enabled = false; }; +} as Services; +``` + +各 entry は `as` によって右辺の field domain 内へ絞り込まれるため、左辺に `port` や `enabled` 以外の field があればエラーになる。 +右辺にしかない field は default の有無にかかわらず abstract のまま残る。 +host から渡した object は識別子構文に収まらない文字列 key も保持できるが、DCDL source の object field name は通常の識別子に限られる。 + +固定 field と任意 key を一つの object schema に混在させる rest-field 構文は、現在サポートしない。 diff --git a/doc/manual/souce/language/functions.md b/doc/manual/souce/language/functions.md index 93788fb..e7f1694 100644 --- a/doc/manual/souce/language/functions.md +++ b/doc/manual/souce/language/functions.md @@ -43,6 +43,7 @@ in - 関数はレキシカルスコープを持つ。 - 関数は定義時の環境を参照として保持する。 - 引数は thunk として渡され、必要になるまで評価されない。 +- parameter range がある引数は、force 時に `as` と同じ範囲包含・絞り込み規則で合成される。 - 関数呼び出し結果そのものはグローバルには memoize しない。 - フィールドに束縛された関数呼び出し結果は、そのフィールド thunk の評価結果として memoize される。 - 再帰的な依存は thunk cycle として diagnostic になる。 diff --git a/doc/manual/souce/language/grammar.md b/doc/manual/souce/language/grammar.md index 656b478..8610f5a 100644 --- a/doc/manual/souce/language/grammar.md +++ b/doc/manual/souce/language/grammar.md @@ -35,8 +35,9 @@ module = { statement } ; statement = field_definition , [ ";" ] | expression , [ ";" ] ; -expression = default_expression ; +expression = as_expression ; +as_expression = default_expression , { "as" , default_expression } ; default_expression = patch_expression , [ "default" , default_expression ] ; patch_expression = compose_expression , { "//" , compose_expression } ; compose_expression = logical_or_expression , { "&" , logical_or_expression } ; @@ -56,6 +57,7 @@ path_suffix = "." , identifier ; primary_expression = literal | identifier | comparison_constraint + | map_constraint | object | array_constraint | array @@ -70,6 +72,7 @@ comparison_operator = "==" | "!=" | "<" | "<=" | ">" | ">=" ; comparison_constraint = ( "<" | "<=" | ">" | ">=" ) , expression ; object = "{" , [ field_definition , { ";" , field_definition } , [ ";" ] ] , "}" ; +map_constraint = "{" , "..." , expression , "}" ; field_definition = field_path , "=" , expression ; field_path = identifier , { "." , identifier } ; @@ -104,6 +107,7 @@ Precedence is highest first. 9. `&` 10. `//` 11. `default` +12. `as` Binary operators are left-associative except `default`, which is right-associative. diff --git a/doc/manual/souce/language/operators.md b/doc/manual/souce/language/operators.md index 5e296f2..d265bb7 100644 --- a/doc/manual/souce/language/operators.md +++ b/doc/manual/souce/language/operators.md @@ -30,6 +30,7 @@ | `&` | `lhs & rhs` | composition | value / constraint / object | constraint-preserving composition | | `//` | `lhs // rhs` | patch | object / value | right-biased structural patch | | `default` | `base default fallback` | default | abstract value | materialization fallback | +| `as` | `narrower as wider` | range refinement | value / constraint / structure | narrower result plus untouched right-only ranges | `concrete scalar` は `String`、`Bool`、`Int`、`Float` を指す。 @@ -48,6 +49,7 @@ 9. `&` 10. `//` 11. `default` +12. `as` 同じ優先順位の二項演算子は左結合である。 `default` は右結合である。 @@ -91,6 +93,7 @@ A & B - 両方が異なる具体値なら conflict になる。 - 両方が object なら、フィールドごとに合成する。 - 同じフィールドが両方にある場合、そのフィールド値を `&` で合成する。 +- 片方にしかないフィールドは、そのまま結果に保持する。 - 矛盾が発生した場合はエラーになる。 例: @@ -188,12 +191,44 @@ object field 全体を特別に置き換えるための `replace(...)` 構文や object 全体を別構造にしたい場合は、patch 対象より外側で値を作り直す。 -## `&` と `//` の使い分け +## `as`: range refinement -`&` は制約を満たす具体化に使う。 +`as` は左辺が右辺より具体的で狭い範囲であることを確認する、非対称な絞り込み演算子である。 ```dcdl -ValidConfig = MyConfig & { +Refined = { + port = 8000; +} as { + port = Int & >= 1 & <= 65535; + host = String; + enabled = Bool default true; +}; +``` + +`port` は左辺の `8000` に具体化される。 +右辺にしかない `host` と `enabled` は abstract のまま結果へ残る。default の有無は、右辺だけの field を保持するかどうかに影響しない。 +`as` 自体は default を選択せず、後から結果を materialize した場合だけ通常の default 規則が働く。 + +左辺にしかない object field は右辺の field domain 外なのでエラーになる。 +両側にある nested object、array constraint、map constraint は同じ規則で再帰的に絞り込む。 + +abstract range 同士も包含を確認できる。 + +```dcdl +Int & > 10 as Int & > 0 # 成功し、Int & > 10 を返す +Int as Int & > 0 # 失敗 +``` + +`&` は対称な合成であり、片方だけにある object field を保持する。 +したがって、左右に方向を持つ絞り込みを `&` で代用しない。 +詳細は [Range Refinement](./expression/ascription.md) を参照する。 + +## `&`、`//`、`as` の使い分け + +`&` は制約や部分構造を失わず、対称に合成する。 + +```dcdl +Combined = MyConfig & { port = 8000; }; ``` @@ -208,3 +243,9 @@ ModifiedSchema = MyConfig // { `//` は右辺優先の patch であり、左辺の制約を常に保持するとは限らない。 制約を保持したい場合は `&` を使う。 + +左辺が右辺より狭いことを検証しながら合成する場合は `as` を使う。 + +```dcdl +RefinedConfig = NarrowConfig as WideConfig; +``` diff --git a/doc/manual/souce/language/syntax.md b/doc/manual/souce/language/syntax.md index 261cb0b..fae321c 100644 --- a/doc/manual/souce/language/syntax.md +++ b/doc/manual/souce/language/syntax.md @@ -103,6 +103,7 @@ in match import default +as true false ``` @@ -119,9 +120,10 @@ false & 制約合成 // patch 合成 default fallback 指定 +as 左辺から右辺への範囲包含確認と絞り込み => 関数 . フィールド参照 / ドットパス定義 -... 配列の要素制約 +... 配列または連想配列の値制約 ``` 演算子の優先順位は [合成演算子](./operators.md) で定義する。 diff --git a/editors/lezer-decodal/decodal.grammar b/editors/lezer-decodal/decodal.grammar index 3a26e50..44ebb4e 100644 --- a/editors/lezer-decodal/decodal.grammar +++ b/editors/lezer-decodal/decodal.grammar @@ -5,7 +5,12 @@ Statement { Expression Semicolon? } -Expression { DefaultExpression } +Expression { AsExpression } + +AsExpression { + DefaultExpression | + AsExpression !as As DefaultExpression +} DefaultExpression { PatchExpression | @@ -70,6 +75,7 @@ PrimaryExpression { Literal | Identifier | ComparisonConstraint | + MapConstraint | Object | ArrayConstraint | Array | @@ -85,6 +91,7 @@ CompareOperator { EqualEqual | BangEqual | Lt | Lte | Gt | Gte } ComparisonConstraint { (Lt | Lte | Gt | Gte) Expression } Object { LBrace (FieldDefinition (Semicolon FieldDefinition)* Semicolon?)? RBrace } +MapConstraint { LBrace Ellipsis Expression RBrace } FieldDefinition { FieldPath Equal Expression } FieldPath { Identifier !fieldPath (Dot Identifier)* } @@ -104,8 +111,11 @@ Pattern { Underscore | Expression } ImportExpression { Import String } +As { @specialize } + @precedence { fieldPath @left, + as @left, default @right, patch @left, compose @left, diff --git a/editors/tree-sitter-decodal/corpus/basic.txt b/editors/tree-sitter-decodal/corpus/basic.txt index b616341..0b3fea9 100644 --- a/editors/tree-sitter-decodal/corpus/basic.txt +++ b/editors/tree-sitter-decodal/corpus/basic.txt @@ -182,3 +182,31 @@ Array constraints left: (identifier) right: (comparison_constraint value: (integer)))))))) + +================== +Map constraint and ascription +================== +{ + services = { + api = { port = 8080; }; + } as {...{ port = Int; }}; +} +--- + +(source_file + (object + (field_definition + path: (field_path (identifier)) + value: (as_expression + narrower: (object + (field_definition + path: (field_path (identifier)) + value: (object + (field_definition + path: (field_path (identifier)) + value: (literal (integer)))))) + wider: (map_constraint + value: (object + (field_definition + path: (field_path (identifier)) + value: (identifier)))))))) diff --git a/editors/tree-sitter-decodal/grammar.js b/editors/tree-sitter-decodal/grammar.js index 40b2836..cf4d2f8 100644 --- a/editors/tree-sitter-decodal/grammar.js +++ b/editors/tree-sitter-decodal/grammar.js @@ -2,6 +2,7 @@ // doc/manual/souce/language/grammar.md. const PREC = { + AS: 0, DEFAULT: 1, PATCH: 2, COMPOSE: 3, @@ -53,6 +54,7 @@ module.exports = grammar({ $.identifier, $.regex_literal, $.comparison_constraint, + $.map_constraint, $.object, $.array_constraint, $.array, @@ -66,6 +68,7 @@ module.exports = grammar({ $.unary_expression, $.binary_expression, $.default_expression, + $.as_expression, ), literal: $ => choice( @@ -100,6 +103,13 @@ module.exports = grammar({ '}', ), + map_constraint: $ => seq( + '{', + '...', + field('value', $._expression), + '}', + ), + field_definition: $ => seq( field('path', $.field_path), '=', @@ -125,12 +135,12 @@ module.exports = grammar({ ']', ), - let_expression: $ => seq( + let_expression: $ => prec.right(seq( 'let', repeat(seq($.field_definition, ';')), 'in', field('body', $._expression), - ), + )), function_expression: $ => prec.right(seq( '(', @@ -237,5 +247,11 @@ module.exports = grammar({ 'default', field('fallback', $._expression), )), + + as_expression: $ => prec.left(PREC.AS, seq( + field('narrower', $._expression), + 'as', + field('wider', $._expression), + )), }, }); diff --git a/editors/tree-sitter-decodal/queries/highlights.scm b/editors/tree-sitter-decodal/queries/highlights.scm index 92b4214..f796013 100644 --- a/editors/tree-sitter-decodal/queries/highlights.scm +++ b/editors/tree-sitter-decodal/queries/highlights.scm @@ -12,6 +12,7 @@ "match" "import" "default" + "as" ] @keyword [ diff --git a/editors/tree-sitter-decodal/src/grammar.json b/editors/tree-sitter-decodal/src/grammar.json index 39a10d7..f64eff8 100644 --- a/editors/tree-sitter-decodal/src/grammar.json +++ b/editors/tree-sitter-decodal/src/grammar.json @@ -91,6 +91,10 @@ "type": "SYMBOL", "name": "comparison_constraint" }, + { + "type": "SYMBOL", + "name": "map_constraint" + }, { "type": "SYMBOL", "name": "object" @@ -142,6 +146,10 @@ { "type": "SYMBOL", "name": "default_expression" + }, + { + "type": "SYMBOL", + "name": "as_expression" } ] }, @@ -319,6 +327,31 @@ } ] }, + "map_constraint": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "STRING", + "value": "..." + }, + { + "type": "FIELD", + "name": "value", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + }, + { + "type": "STRING", + "value": "}" + } + ] + }, "field_definition": { "type": "SEQ", "members": [ @@ -469,41 +502,45 @@ ] }, "let_expression": { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "let" - }, - { - "type": "REPEAT", - "content": { - "type": "SEQ", - "members": [ - { - "type": "SYMBOL", - "name": "field_definition" - }, - { - "type": "STRING", - "value": ";" - } - ] + "type": "PREC_RIGHT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "let" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "field_definition" + }, + { + "type": "STRING", + "value": ";" + } + ] + } + }, + { + "type": "STRING", + "value": "in" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "type": "SYMBOL", + "name": "_expression" + } } - }, - { - "type": "STRING", - "value": "in" - }, - { - "type": "FIELD", - "name": "body", - "content": { - "type": "SYMBOL", - "name": "_expression" - } - } - ] + ] + } }, "function_expression": { "type": "PREC_RIGHT", @@ -1298,6 +1335,35 @@ } ] } + }, + "as_expression": { + "type": "PREC_LEFT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "narrower", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + }, + { + "type": "STRING", + "value": "as" + }, + { + "type": "FIELD", + "name": "wider", + "content": { + "type": "SYMBOL", + "name": "_expression" + } + } + ] + } } }, "extras": [ diff --git a/editors/tree-sitter-decodal/src/node-types.json b/editors/tree-sitter-decodal/src/node-types.json index d5b074d..9cac035 100644 --- a/editors/tree-sitter-decodal/src/node-types.json +++ b/editors/tree-sitter-decodal/src/node-types.json @@ -15,6 +15,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -51,6 +55,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -94,6 +102,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -130,6 +142,180 @@ "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": "as_expression", + "named": true, + "fields": { + "narrower": { + "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 + } + ] + }, + "wider": { + "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 @@ -174,6 +360,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -210,6 +400,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -314,6 +508,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -350,6 +548,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -399,6 +601,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -435,6 +641,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -474,6 +684,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -510,6 +724,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -575,6 +793,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -611,6 +833,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -655,6 +881,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -691,6 +921,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -729,6 +963,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -765,6 +1003,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -819,6 +1061,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -855,6 +1101,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -914,6 +1164,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -950,6 +1204,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1020,6 +1278,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1056,6 +1318,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1122,10 +1388,10 @@ } }, { - "type": "match_arm", + "type": "map_constraint", "named": true, "fields": { - "body": { + "value": { "multiple": false, "required": true, "types": [ @@ -1137,6 +1403,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1173,6 +1443,98 @@ "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": "match_arm", + "named": true, + "fields": { + "body": { + "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 @@ -1215,6 +1577,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1251,6 +1617,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1295,6 +1665,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1331,6 +1705,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1400,6 +1778,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1436,6 +1818,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1490,6 +1876,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1526,6 +1916,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1579,6 +1973,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1615,6 +2013,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1659,6 +2061,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1699,6 +2105,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1742,6 +2152,10 @@ "type": "array_constraint", "named": true }, + { + "type": "as_expression", + "named": true + }, { "type": "binary_expression", "named": true @@ -1778,6 +2192,10 @@ "type": "literal", "named": true }, + { + "type": "map_constraint", + "named": true + }, { "type": "match_expression", "named": true @@ -1928,6 +2346,10 @@ "type": "_", "named": false }, + { + "type": "as", + "named": false + }, { "type": "comment", "named": true diff --git a/editors/tree-sitter-decodal/src/parser.c b/editors/tree-sitter-decodal/src/parser.c index 4014460..9a790ff 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 235 -#define LARGE_STATE_COUNT 25 -#define SYMBOL_COUNT 74 +#define STATE_COUNT 245 +#define LARGE_STATE_COUNT 72 +#define SYMBOL_COUNT 77 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 44 +#define TOKEN_COUNT 45 #define EXTERNAL_TOKEN_COUNT 0 -#define FIELD_COUNT 18 +#define FIELD_COUNT 20 #define MAX_ALIAS_SEQUENCE_LENGTH 7 -#define PRODUCTION_ID_COUNT 19 +#define PRODUCTION_ID_COUNT 21 enum ts_symbol_identifiers { sym_identifier = 1, @@ -27,12 +27,12 @@ enum ts_symbol_identifiers { sym_regex_literal = 9, anon_sym_LBRACE = 10, anon_sym_RBRACE = 11, - anon_sym_EQ = 12, - anon_sym_DOT = 13, - anon_sym_LBRACK = 14, - anon_sym_COMMA = 15, - anon_sym_RBRACK = 16, - anon_sym_DOT_DOT_DOT = 17, + anon_sym_DOT_DOT_DOT = 12, + anon_sym_EQ = 13, + anon_sym_DOT = 14, + anon_sym_LBRACK = 15, + anon_sym_COMMA = 16, + anon_sym_RBRACK = 17, anon_sym_let = 18, anon_sym_in = 19, anon_sym_LPAREN = 20, @@ -59,36 +59,39 @@ enum ts_symbol_identifiers { anon_sym_AMP = 41, anon_sym_SLASH_SLASH = 42, anon_sym_default = 43, - sym_source_file = 44, - sym__statement = 45, - sym__expression = 46, - sym_literal = 47, - sym_boolean = 48, - sym_object = 49, - sym_field_definition = 50, - sym_field_path = 51, - sym_array = 52, - sym_array_constraint = 53, - sym_let_expression = 54, - sym_function_expression = 55, - sym_parameter = 56, - sym_match_expression = 57, - sym_match_arm = 58, - sym_import_expression = 59, - sym_parenthesized_expression = 60, - sym_call_expression = 61, - sym_path_expression = 62, - sym_comparison_constraint = 63, - sym_unary_expression = 64, - sym_binary_expression = 65, - sym_default_expression = 66, - aux_sym_source_file_repeat1 = 67, - aux_sym_object_repeat1 = 68, - aux_sym_field_path_repeat1 = 69, - aux_sym_array_repeat1 = 70, - aux_sym_let_expression_repeat1 = 71, - aux_sym_function_expression_repeat1 = 72, - aux_sym_match_expression_repeat1 = 73, + anon_sym_as = 44, + sym_source_file = 45, + sym__statement = 46, + sym__expression = 47, + 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, }; static const char * const ts_symbol_names[] = { @@ -104,12 +107,12 @@ static const char * const ts_symbol_names[] = { [sym_regex_literal] = "regex_literal", [anon_sym_LBRACE] = "{", [anon_sym_RBRACE] = "}", + [anon_sym_DOT_DOT_DOT] = "...", [anon_sym_EQ] = "=", [anon_sym_DOT] = ".", [anon_sym_LBRACK] = "[", [anon_sym_COMMA] = ",", [anon_sym_RBRACK] = "]", - [anon_sym_DOT_DOT_DOT] = "...", [anon_sym_let] = "let", [anon_sym_in] = "in", [anon_sym_LPAREN] = "(", @@ -136,12 +139,14 @@ static const char * const ts_symbol_names[] = { [anon_sym_AMP] = "&", [anon_sym_SLASH_SLASH] = "//", [anon_sym_default] = "default", + [anon_sym_as] = "as", [sym_source_file] = "source_file", [sym__statement] = "_statement", [sym__expression] = "_expression", [sym_literal] = "literal", [sym_boolean] = "boolean", [sym_object] = "object", + [sym_map_constraint] = "map_constraint", [sym_field_definition] = "field_definition", [sym_field_path] = "field_path", [sym_array] = "array", @@ -159,6 +164,7 @@ static const char * const ts_symbol_names[] = { [sym_unary_expression] = "unary_expression", [sym_binary_expression] = "binary_expression", [sym_default_expression] = "default_expression", + [sym_as_expression] = "as_expression", [aux_sym_source_file_repeat1] = "source_file_repeat1", [aux_sym_object_repeat1] = "object_repeat1", [aux_sym_field_path_repeat1] = "field_path_repeat1", @@ -181,12 +187,12 @@ static const TSSymbol ts_symbol_map[] = { [sym_regex_literal] = sym_regex_literal, [anon_sym_LBRACE] = anon_sym_LBRACE, [anon_sym_RBRACE] = anon_sym_RBRACE, + [anon_sym_DOT_DOT_DOT] = anon_sym_DOT_DOT_DOT, [anon_sym_EQ] = anon_sym_EQ, [anon_sym_DOT] = anon_sym_DOT, [anon_sym_LBRACK] = anon_sym_LBRACK, [anon_sym_COMMA] = anon_sym_COMMA, [anon_sym_RBRACK] = anon_sym_RBRACK, - [anon_sym_DOT_DOT_DOT] = anon_sym_DOT_DOT_DOT, [anon_sym_let] = anon_sym_let, [anon_sym_in] = anon_sym_in, [anon_sym_LPAREN] = anon_sym_LPAREN, @@ -213,12 +219,14 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_AMP] = anon_sym_AMP, [anon_sym_SLASH_SLASH] = anon_sym_SLASH_SLASH, [anon_sym_default] = anon_sym_default, + [anon_sym_as] = anon_sym_as, [sym_source_file] = sym_source_file, [sym__statement] = sym__statement, [sym__expression] = sym__expression, [sym_literal] = sym_literal, [sym_boolean] = sym_boolean, [sym_object] = sym_object, + [sym_map_constraint] = sym_map_constraint, [sym_field_definition] = sym_field_definition, [sym_field_path] = sym_field_path, [sym_array] = sym_array, @@ -236,6 +244,7 @@ static const TSSymbol ts_symbol_map[] = { [sym_unary_expression] = sym_unary_expression, [sym_binary_expression] = sym_binary_expression, [sym_default_expression] = sym_default_expression, + [sym_as_expression] = sym_as_expression, [aux_sym_source_file_repeat1] = aux_sym_source_file_repeat1, [aux_sym_object_repeat1] = aux_sym_object_repeat1, [aux_sym_field_path_repeat1] = aux_sym_field_path_repeat1, @@ -294,6 +303,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_DOT_DOT_DOT] = { + .visible = true, + .named = false, + }, [anon_sym_EQ] = { .visible = true, .named = false, @@ -314,10 +327,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, - [anon_sym_DOT_DOT_DOT] = { - .visible = true, - .named = false, - }, [anon_sym_let] = { .visible = true, .named = false, @@ -422,6 +431,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_as] = { + .visible = true, + .named = false, + }, [sym_source_file] = { .visible = true, .named = true, @@ -446,6 +459,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_map_constraint] = { + .visible = true, + .named = true, + }, [sym_field_definition] = { .visible = true, .named = true, @@ -514,6 +531,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_as_expression] = { + .visible = true, + .named = true, + }, [aux_sym_source_file_repeat1] = { .visible = false, .named = false, @@ -554,15 +575,17 @@ enum ts_field_identifiers { field_function = 7, field_left = 8, field_name = 9, - field_object = 10, - field_operand = 11, - field_operator = 12, - field_path = 13, - field_pattern = 14, - field_right = 15, - field_scrutinee = 16, - field_specifier = 17, - field_value = 18, + field_narrower = 10, + field_object = 11, + field_operand = 12, + field_operator = 13, + field_path = 14, + field_pattern = 15, + field_right = 16, + field_scrutinee = 17, + field_specifier = 18, + field_value = 19, + field_wider = 20, }; static const char * const ts_field_names[] = { @@ -576,6 +599,7 @@ static const char * const ts_field_names[] = { [field_function] = "function", [field_left] = "left", [field_name] = "name", + [field_narrower] = "narrower", [field_object] = "object", [field_operand] = "operand", [field_operator] = "operator", @@ -585,6 +609,7 @@ static const char * const ts_field_names[] = { [field_scrutinee] = "scrutinee", [field_specifier] = "specifier", [field_value] = "value", + [field_wider] = "wider", }; static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { @@ -598,14 +623,16 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [8] = {.index = 10, .length = 3}, [9] = {.index = 13, .length = 2}, [10] = {.index = 15, .length = 2}, - [11] = {.index = 17, .length = 1}, - [12] = {.index = 18, .length = 1}, - [13] = {.index = 19, .length = 2}, + [11] = {.index = 17, .length = 2}, + [12] = {.index = 19, .length = 1}, + [13] = {.index = 20, .length = 1}, [14] = {.index = 21, .length = 1}, - [15] = {.index = 22, .length = 1}, - [16] = {.index = 23, .length = 1}, - [17] = {.index = 24, .length = 2}, + [15] = {.index = 22, .length = 2}, + [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}, }; static const TSFieldMapEntry ts_field_map_entries[] = { @@ -634,25 +661,30 @@ static const TSFieldMapEntry ts_field_map_entries[] = { {field_base, 0}, {field_fallback, 2}, [15] = + {field_narrower, 0}, + {field_wider, 2}, + [17] = {field_path, 0}, {field_value, 2}, - [17] = - {field_element, 2}, - [18] = - {field_body, 3}, [19] = + {field_value, 2}, + [20] = + {field_element, 2}, + [21] = + {field_body, 3}, + [22] = {field_constraint, 2}, {field_name, 0}, - [21] = - {field_scrutinee, 1}, - [22] = - {field_body, 4}, - [23] = - {field_body, 5}, [24] = + {field_scrutinee, 1}, + [25] = + {field_body, 4}, + [26] = + {field_body, 5}, + [27] = {field_body, 2}, {field_pattern, 0}, - [26] = + [29] = {field_body, 6}, }; @@ -672,71 +704,71 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [4] = 4, [5] = 5, [6] = 4, - [7] = 7, - [8] = 7, - [9] = 5, + [7] = 5, + [8] = 8, + [9] = 8, [10] = 10, [11] = 11, [12] = 12, [13] = 11, - [14] = 12, + [14] = 10, [15] = 15, - [16] = 16, + [16] = 15, [17] = 17, - [18] = 15, + [18] = 18, [19] = 19, - [20] = 16, + [20] = 17, [21] = 21, [22] = 19, [23] = 21, - [24] = 17, + [24] = 18, [25] = 25, [26] = 26, [27] = 27, [28] = 28, [29] = 29, [30] = 30, - [31] = 26, - [32] = 32, + [31] = 31, + [32] = 26, [33] = 33, - [34] = 34, + [34] = 28, [35] = 35, [36] = 36, - [37] = 37, + [37] = 35, [38] = 38, - [39] = 39, - [40] = 37, - [41] = 36, - [42] = 35, - [43] = 25, - [44] = 33, - [45] = 32, - [46] = 38, - [47] = 30, - [48] = 29, - [49] = 28, + [39] = 33, + [40] = 40, + [41] = 41, + [42] = 42, + [43] = 43, + [44] = 44, + [45] = 45, + [46] = 25, + [47] = 47, + [48] = 48, + [49] = 49, [50] = 50, [51] = 51, - [52] = 52, - [53] = 53, - [54] = 54, - [55] = 55, - [56] = 56, - [57] = 55, - [58] = 51, - [59] = 59, - [60] = 52, - [61] = 54, - [62] = 27, - [63] = 56, - [64] = 64, - [65] = 50, - [66] = 39, - [67] = 53, - [68] = 68, + [52] = 41, + [53] = 51, + [54] = 50, + [55] = 49, + [56] = 48, + [57] = 30, + [58] = 47, + [59] = 38, + [60] = 29, + [61] = 61, + [62] = 45, + [63] = 61, + [64] = 44, + [65] = 40, + [66] = 43, + [67] = 67, + [68] = 36, [69] = 69, - [70] = 70, - [71] = 71, + [70] = 42, + [71] = 69, [72] = 72, [73] = 73, [74] = 74, @@ -776,130 +808,140 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [108] = 108, [109] = 109, [110] = 110, - [111] = 93, - [112] = 88, - [113] = 110, - [114] = 70, - [115] = 82, - [116] = 106, - [117] = 107, - [118] = 81, - [119] = 69, - [120] = 101, - [121] = 104, - [122] = 99, - [123] = 103, - [124] = 100, - [125] = 98, - [126] = 80, - [127] = 78, - [128] = 77, - [129] = 96, - [130] = 95, - [131] = 90, - [132] = 97, - [133] = 73, - [134] = 94, - [135] = 83, - [136] = 105, - [137] = 71, - [138] = 74, - [139] = 109, - [140] = 92, - [141] = 108, - [142] = 87, - [143] = 75, - [144] = 76, - [145] = 79, - [146] = 86, - [147] = 102, - [148] = 91, - [149] = 84, - [150] = 85, - [151] = 151, - [152] = 151, - [153] = 153, - [154] = 154, - [155] = 155, - [156] = 154, - [157] = 157, - [158] = 158, + [111] = 111, + [112] = 112, + [113] = 113, + [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, + [151] = 78, + [152] = 77, + [153] = 75, + [154] = 74, + [155] = 95, + [156] = 107, + [157] = 76, + [158] = 97, [159] = 159, - [160] = 89, + [160] = 160, [161] = 161, - [162] = 162, - [163] = 158, + [162] = 159, + [163] = 161, [164] = 164, [165] = 165, - [166] = 164, + [166] = 166, [167] = 167, - [168] = 167, - [169] = 169, - [170] = 170, + [168] = 168, + [169] = 87, + [170] = 168, [171] = 171, - [172] = 170, - [173] = 171, - [174] = 174, + [172] = 172, + [173] = 173, + [174] = 172, [175] = 175, - [176] = 174, - [177] = 175, + [176] = 173, + [177] = 171, [178] = 178, - [179] = 178, - [180] = 180, + [179] = 179, + [180] = 179, [181] = 181, [182] = 182, - [183] = 183, + [183] = 181, [184] = 184, - [185] = 185, + [185] = 184, [186] = 186, [187] = 187, [188] = 188, - [189] = 183, - [190] = 190, + [189] = 187, + [190] = 186, [191] = 191, [192] = 192, - [193] = 188, + [193] = 193, [194] = 194, - [195] = 181, - [196] = 196, - [197] = 185, - [198] = 186, + [195] = 195, + [196] = 193, + [197] = 197, + [198] = 198, [199] = 199, - [200] = 190, + [200] = 200, [201] = 201, [202] = 202, - [203] = 202, + [203] = 203, [204] = 204, - [205] = 191, - [206] = 182, + [205] = 205, + [206] = 205, [207] = 194, [208] = 208, - [209] = 209, + [209] = 200, [210] = 210, - [211] = 211, - [212] = 212, + [211] = 201, + [212] = 208, [213] = 213, [214] = 214, - [215] = 215, - [216] = 216, - [217] = 217, - [218] = 218, + [215] = 198, + [216] = 197, + [217] = 203, + [218] = 213, [219] = 219, - [220] = 219, + [220] = 220, [221] = 221, [222] = 222, [223] = 223, [224] = 224, [225] = 225, - [226] = 215, - [227] = 227, - [228] = 217, - [229] = 216, - [230] = 218, + [226] = 226, + [227] = 226, + [228] = 228, + [229] = 229, + [230] = 230, [231] = 231, - [232] = 222, - [233] = 224, - [234] = 223, + [232] = 232, + [233] = 233, + [234] = 234, + [235] = 233, + [236] = 236, + [237] = 237, + [238] = 238, + [239] = 238, + [240] = 228, + [241] = 229, + [242] = 225, + [243] = 236, + [244] = 232, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -917,17 +959,17 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ')', 34, '*', 51, '+', 50, - ',', 30, + ',', 31, '-', 42, - '.', 28, + '.', 29, '/', 53, ':', 36, ';', 17, '<', 40, - '=', 26, + '=', 27, '>', 38, - '[', 29, - ']', 31, + '[', 30, + ']', 32, '_', 37, '{', 24, '|', 11, @@ -954,9 +996,10 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '<', 40, '=', 9, '>', 38, - '[', 29, - ']', 31, + '[', 30, + ']', 32, '{', 24, + '}', 25, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || @@ -976,16 +1019,16 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ')', 34, '*', 51, '+', 50, - ',', 30, + ',', 31, '-', 42, - '.', 27, + '.', 28, '/', 52, ':', 36, ';', 17, '<', 40, '=', 8, '>', 38, - ']', 31, + ']', 32, '{', 24, '|', 11, '}', 25, @@ -1008,7 +1051,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == '.') ADVANCE(5); END_STATE(); case 5: - if (lookahead == '.') ADVANCE(32); + if (lookahead == '.') ADVANCE(26); END_STATE(); case 6: if (lookahead == '/') ADVANCE(23); @@ -1056,13 +1099,13 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { '*', 51, '+', 50, '-', 42, - '.', 27, + '.', 28, '/', 53, ';', 17, '<', 40, - '=', 26, + '=', 27, '>', 38, - '[', 29, + '[', 30, '{', 24, '|', 11, ); @@ -1115,27 +1158,27 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ACCEPT_TOKEN(anon_sym_RBRACE); END_STATE(); case 26: + ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + END_STATE(); + case 27: ACCEPT_TOKEN(anon_sym_EQ); if (lookahead == '=') ADVANCE(47); END_STATE(); - case 27: + case 28: ACCEPT_TOKEN(anon_sym_DOT); END_STATE(); - case 28: + case 29: ACCEPT_TOKEN(anon_sym_DOT); if (lookahead == '.') ADVANCE(5); END_STATE(); - case 29: + case 30: ACCEPT_TOKEN(anon_sym_LBRACK); END_STATE(); - case 30: + case 31: ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); - case 31: - ACCEPT_TOKEN(anon_sym_RBRACK); - END_STATE(); case 32: - ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + ACCEPT_TOKEN(anon_sym_RBRACK); END_STATE(); case 33: ACCEPT_TOKEN(anon_sym_LPAREN); @@ -1226,12 +1269,13 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (lookahead == 'd') ADVANCE(1); - if (lookahead == 'f') ADVANCE(2); - if (lookahead == 'i') ADVANCE(3); - if (lookahead == 'l') ADVANCE(4); - if (lookahead == 'm') ADVANCE(5); - if (lookahead == 't') ADVANCE(6); + if (lookahead == 'a') ADVANCE(1); + if (lookahead == 'd') ADVANCE(2); + if (lookahead == 'f') ADVANCE(3); + if (lookahead == 'i') ADVANCE(4); + if (lookahead == 'l') ADVANCE(5); + if (lookahead == 'm') ADVANCE(6); + if (lookahead == 't') ADVANCE(7); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || @@ -1239,97 +1283,103 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { lookahead == 0xfeff) SKIP(0); END_STATE(); case 1: - if (lookahead == 'e') ADVANCE(7); + if (lookahead == 's') ADVANCE(8); END_STATE(); case 2: - if (lookahead == 'a') ADVANCE(8); + if (lookahead == 'e') ADVANCE(9); END_STATE(); case 3: - if (lookahead == 'm') ADVANCE(9); - if (lookahead == 'n') ADVANCE(10); + if (lookahead == 'a') ADVANCE(10); END_STATE(); case 4: - if (lookahead == 'e') ADVANCE(11); + if (lookahead == 'm') ADVANCE(11); + if (lookahead == 'n') ADVANCE(12); END_STATE(); case 5: - if (lookahead == 'a') ADVANCE(12); + if (lookahead == 'e') ADVANCE(13); END_STATE(); case 6: - if (lookahead == 'r') ADVANCE(13); + if (lookahead == 'a') ADVANCE(14); END_STATE(); case 7: - if (lookahead == 'f') ADVANCE(14); + if (lookahead == 'r') ADVANCE(15); END_STATE(); case 8: - if (lookahead == 'l') ADVANCE(15); + ACCEPT_TOKEN(anon_sym_as); END_STATE(); case 9: - if (lookahead == 'p') ADVANCE(16); + if (lookahead == 'f') ADVANCE(16); END_STATE(); case 10: - ACCEPT_TOKEN(anon_sym_in); + if (lookahead == 'l') ADVANCE(17); END_STATE(); case 11: - if (lookahead == 't') ADVANCE(17); + if (lookahead == 'p') ADVANCE(18); END_STATE(); case 12: - if (lookahead == 't') ADVANCE(18); + ACCEPT_TOKEN(anon_sym_in); END_STATE(); case 13: - if (lookahead == 'u') ADVANCE(19); + if (lookahead == 't') ADVANCE(19); END_STATE(); case 14: - if (lookahead == 'a') ADVANCE(20); + if (lookahead == 't') ADVANCE(20); END_STATE(); case 15: - if (lookahead == 's') ADVANCE(21); + if (lookahead == 'u') ADVANCE(21); END_STATE(); case 16: - if (lookahead == 'o') ADVANCE(22); + if (lookahead == 'a') ADVANCE(22); END_STATE(); case 17: - ACCEPT_TOKEN(anon_sym_let); + if (lookahead == 's') ADVANCE(23); END_STATE(); case 18: - if (lookahead == 'c') ADVANCE(23); + if (lookahead == 'o') ADVANCE(24); END_STATE(); case 19: - if (lookahead == 'e') ADVANCE(24); + ACCEPT_TOKEN(anon_sym_let); END_STATE(); case 20: - if (lookahead == 'u') ADVANCE(25); + if (lookahead == 'c') ADVANCE(25); END_STATE(); case 21: if (lookahead == 'e') ADVANCE(26); END_STATE(); case 22: - if (lookahead == 'r') ADVANCE(27); + if (lookahead == 'u') ADVANCE(27); END_STATE(); case 23: - if (lookahead == 'h') ADVANCE(28); + if (lookahead == 'e') ADVANCE(28); END_STATE(); case 24: - ACCEPT_TOKEN(anon_sym_true); + if (lookahead == 'r') ADVANCE(29); END_STATE(); case 25: - if (lookahead == 'l') ADVANCE(29); + if (lookahead == 'h') ADVANCE(30); END_STATE(); case 26: - ACCEPT_TOKEN(anon_sym_false); + ACCEPT_TOKEN(anon_sym_true); END_STATE(); case 27: - if (lookahead == 't') ADVANCE(30); + if (lookahead == 'l') ADVANCE(31); END_STATE(); case 28: - ACCEPT_TOKEN(anon_sym_match); + ACCEPT_TOKEN(anon_sym_false); END_STATE(); case 29: - if (lookahead == 't') ADVANCE(31); + if (lookahead == 't') ADVANCE(32); END_STATE(); case 30: - ACCEPT_TOKEN(anon_sym_import); + ACCEPT_TOKEN(anon_sym_match); END_STATE(); case 31: + if (lookahead == 't') ADVANCE(33); + END_STATE(); + case 32: + ACCEPT_TOKEN(anon_sym_import); + END_STATE(); + case 33: ACCEPT_TOKEN(anon_sym_default); END_STATE(); default: @@ -1348,9 +1398,9 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [7] = {.lex_state = 0}, [8] = {.lex_state = 0}, [9] = {.lex_state = 0}, - [10] = {.lex_state = 0}, + [10] = {.lex_state = 1}, [11] = {.lex_state = 0}, - [12] = {.lex_state = 1}, + [12] = {.lex_state = 0}, [13] = {.lex_state = 0}, [14] = {.lex_state = 1}, [15] = {.lex_state = 0}, @@ -1406,10 +1456,10 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [65] = {.lex_state = 0}, [66] = {.lex_state = 0}, [67] = {.lex_state = 0}, - [68] = {.lex_state = 15}, - [69] = {.lex_state = 15}, - [70] = {.lex_state = 15}, - [71] = {.lex_state = 15}, + [68] = {.lex_state = 0}, + [69] = {.lex_state = 0}, + [70] = {.lex_state = 0}, + [71] = {.lex_state = 0}, [72] = {.lex_state = 15}, [73] = {.lex_state = 15}, [74] = {.lex_state = 15}, @@ -1449,12 +1499,12 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [108] = {.lex_state = 15}, [109] = {.lex_state = 15}, [110] = {.lex_state = 15}, - [111] = {.lex_state = 2}, - [112] = {.lex_state = 2}, - [113] = {.lex_state = 2}, - [114] = {.lex_state = 2}, - [115] = {.lex_state = 2}, - [116] = {.lex_state = 2}, + [111] = {.lex_state = 15}, + [112] = {.lex_state = 15}, + [113] = {.lex_state = 15}, + [114] = {.lex_state = 15}, + [115] = {.lex_state = 15}, + [116] = {.lex_state = 15}, [117] = {.lex_state = 2}, [118] = {.lex_state = 2}, [119] = {.lex_state = 2}, @@ -1495,9 +1545,9 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [154] = {.lex_state = 2}, [155] = {.lex_state = 2}, [156] = {.lex_state = 2}, - [157] = {.lex_state = 0}, + [157] = {.lex_state = 2}, [158] = {.lex_state = 2}, - [159] = {.lex_state = 0}, + [159] = {.lex_state = 2}, [160] = {.lex_state = 2}, [161] = {.lex_state = 2}, [162] = {.lex_state = 2}, @@ -1505,32 +1555,32 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [164] = {.lex_state = 2}, [165] = {.lex_state = 2}, [166] = {.lex_state = 2}, - [167] = {.lex_state = 2}, + [167] = {.lex_state = 0}, [168] = {.lex_state = 2}, - [169] = {.lex_state = 0}, - [170] = {.lex_state = 0}, - [171] = {.lex_state = 0}, - [172] = {.lex_state = 0}, - [173] = {.lex_state = 0}, - [174] = {.lex_state = 0}, + [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}, - [176] = {.lex_state = 0}, - [177] = {.lex_state = 0}, - [178] = {.lex_state = 0}, + [176] = {.lex_state = 2}, + [177] = {.lex_state = 2}, + [178] = {.lex_state = 2}, [179] = {.lex_state = 0}, [180] = {.lex_state = 0}, [181] = {.lex_state = 0}, [182] = {.lex_state = 0}, [183] = {.lex_state = 0}, - [184] = {.lex_state = 0}, - [185] = {.lex_state = 0}, + [184] = {.lex_state = 1}, + [185] = {.lex_state = 1}, [186] = {.lex_state = 0}, [187] = {.lex_state = 0}, [188] = {.lex_state = 0}, [189] = {.lex_state = 0}, [190] = {.lex_state = 0}, [191] = {.lex_state = 0}, - [192] = {.lex_state = 0}, + [192] = {.lex_state = 15}, [193] = {.lex_state = 0}, [194] = {.lex_state = 0}, [195] = {.lex_state = 0}, @@ -1539,14 +1589,14 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [198] = {.lex_state = 0}, [199] = {.lex_state = 0}, [200] = {.lex_state = 0}, - [201] = {.lex_state = 15}, - [202] = {.lex_state = 0}, + [201] = {.lex_state = 0}, + [202] = {.lex_state = 15}, [203] = {.lex_state = 0}, - [204] = {.lex_state = 15}, + [204] = {.lex_state = 0}, [205] = {.lex_state = 0}, [206] = {.lex_state = 0}, [207] = {.lex_state = 0}, - [208] = {.lex_state = 15}, + [208] = {.lex_state = 0}, [209] = {.lex_state = 0}, [210] = {.lex_state = 15}, [211] = {.lex_state = 0}, @@ -1556,23 +1606,33 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [215] = {.lex_state = 0}, [216] = {.lex_state = 0}, [217] = {.lex_state = 0}, - [218] = {.lex_state = 1}, - [219] = {.lex_state = 1}, - [220] = {.lex_state = 1}, + [218] = {.lex_state = 0}, + [219] = {.lex_state = 0}, + [220] = {.lex_state = 15}, [221] = {.lex_state = 0}, - [222] = {.lex_state = 1}, - [223] = {.lex_state = 1}, + [222] = {.lex_state = 0}, + [223] = {.lex_state = 0}, [224] = {.lex_state = 0}, - [225] = {.lex_state = 0}, + [225] = {.lex_state = 1}, [226] = {.lex_state = 0}, [227] = {.lex_state = 0}, - [228] = {.lex_state = 0}, - [229] = {.lex_state = 0}, - [230] = {.lex_state = 1}, + [228] = {.lex_state = 1}, + [229] = {.lex_state = 1}, + [230] = {.lex_state = 0}, [231] = {.lex_state = 0}, [232] = {.lex_state = 1}, [233] = {.lex_state = 0}, - [234] = {.lex_state = 1}, + [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}, + [244] = {.lex_state = 1}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -1589,12 +1649,12 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_regex_literal] = ACTIONS(1), [anon_sym_LBRACE] = ACTIONS(1), [anon_sym_RBRACE] = ACTIONS(1), + [anon_sym_DOT_DOT_DOT] = ACTIONS(1), [anon_sym_EQ] = ACTIONS(1), [anon_sym_DOT] = ACTIONS(1), [anon_sym_LBRACK] = ACTIONS(1), [anon_sym_COMMA] = ACTIONS(1), [anon_sym_RBRACK] = ACTIONS(1), - [anon_sym_DOT_DOT_DOT] = ACTIONS(1), [anon_sym_let] = ACTIONS(1), [anon_sym_in] = ACTIONS(1), [anon_sym_LPAREN] = ACTIONS(1), @@ -1620,29 +1680,32 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_AMP] = ACTIONS(1), [anon_sym_SLASH_SLASH] = ACTIONS(1), [anon_sym_default] = ACTIONS(1), + [anon_sym_as] = ACTIONS(1), }, [1] = { - [sym_source_file] = STATE(225), + [sym_source_file] = STATE(237), [sym__statement] = STATE(2), - [sym__expression] = STATE(72), - [sym_literal] = STATE(72), - [sym_boolean] = STATE(71), - [sym_object] = STATE(72), - [sym_field_definition] = STATE(157), - [sym_field_path] = STATE(217), - [sym_array] = STATE(72), - [sym_array_constraint] = STATE(72), - [sym_let_expression] = STATE(72), - [sym_function_expression] = STATE(72), - [sym_match_expression] = STATE(72), - [sym_import_expression] = STATE(72), - [sym_parenthesized_expression] = STATE(72), - [sym_call_expression] = STATE(72), - [sym_path_expression] = STATE(72), - [sym_comparison_constraint] = STATE(72), - [sym_unary_expression] = STATE(72), - [sym_binary_expression] = STATE(72), - [sym_default_expression] = STATE(72), + [sym__expression] = STATE(116), + [sym_literal] = STATE(116), + [sym_boolean] = STATE(112), + [sym_object] = STATE(116), + [sym_map_constraint] = STATE(116), + [sym_field_definition] = STATE(167), + [sym_field_path] = STATE(235), + [sym_array] = STATE(116), + [sym_array_constraint] = STATE(116), + [sym_let_expression] = STATE(116), + [sym_function_expression] = STATE(116), + [sym_match_expression] = STATE(116), + [sym_import_expression] = STATE(116), + [sym_parenthesized_expression] = STATE(116), + [sym_call_expression] = STATE(116), + [sym_path_expression] = STATE(116), + [sym_comparison_constraint] = STATE(116), + [sym_unary_expression] = STATE(116), + [sym_binary_expression] = STATE(116), + [sym_default_expression] = STATE(116), + [sym_as_expression] = STATE(116), [aux_sym_source_file_repeat1] = STATE(2), [ts_builtin_sym_end] = ACTIONS(5), [sym_identifier] = ACTIONS(7), @@ -1668,25 +1731,27 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [2] = { [sym__statement] = STATE(3), - [sym__expression] = STATE(72), - [sym_literal] = STATE(72), - [sym_boolean] = STATE(71), - [sym_object] = STATE(72), - [sym_field_definition] = STATE(157), - [sym_field_path] = STATE(217), - [sym_array] = STATE(72), - [sym_array_constraint] = STATE(72), - [sym_let_expression] = STATE(72), - [sym_function_expression] = STATE(72), - [sym_match_expression] = STATE(72), - [sym_import_expression] = STATE(72), - [sym_parenthesized_expression] = STATE(72), - [sym_call_expression] = STATE(72), - [sym_path_expression] = STATE(72), - [sym_comparison_constraint] = STATE(72), - [sym_unary_expression] = STATE(72), - [sym_binary_expression] = STATE(72), - [sym_default_expression] = STATE(72), + [sym__expression] = STATE(116), + [sym_literal] = STATE(116), + [sym_boolean] = STATE(112), + [sym_object] = STATE(116), + [sym_map_constraint] = STATE(116), + [sym_field_definition] = STATE(167), + [sym_field_path] = STATE(235), + [sym_array] = STATE(116), + [sym_array_constraint] = STATE(116), + [sym_let_expression] = STATE(116), + [sym_function_expression] = STATE(116), + [sym_match_expression] = STATE(116), + [sym_import_expression] = STATE(116), + [sym_parenthesized_expression] = STATE(116), + [sym_call_expression] = STATE(116), + [sym_path_expression] = STATE(116), + [sym_comparison_constraint] = STATE(116), + [sym_unary_expression] = STATE(116), + [sym_binary_expression] = STATE(116), + [sym_default_expression] = STATE(116), + [sym_as_expression] = STATE(116), [aux_sym_source_file_repeat1] = STATE(3), [ts_builtin_sym_end] = ACTIONS(35), [sym_identifier] = ACTIONS(7), @@ -1712,25 +1777,27 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [3] = { [sym__statement] = STATE(3), - [sym__expression] = STATE(72), - [sym_literal] = STATE(72), - [sym_boolean] = STATE(71), - [sym_object] = STATE(72), - [sym_field_definition] = STATE(157), - [sym_field_path] = STATE(217), - [sym_array] = STATE(72), - [sym_array_constraint] = STATE(72), - [sym_let_expression] = STATE(72), - [sym_function_expression] = STATE(72), - [sym_match_expression] = STATE(72), - [sym_import_expression] = STATE(72), - [sym_parenthesized_expression] = STATE(72), - [sym_call_expression] = STATE(72), - [sym_path_expression] = STATE(72), - [sym_comparison_constraint] = STATE(72), - [sym_unary_expression] = STATE(72), - [sym_binary_expression] = STATE(72), - [sym_default_expression] = STATE(72), + [sym__expression] = STATE(116), + [sym_literal] = STATE(116), + [sym_boolean] = STATE(112), + [sym_object] = STATE(116), + [sym_map_constraint] = STATE(116), + [sym_field_definition] = STATE(167), + [sym_field_path] = STATE(235), + [sym_array] = STATE(116), + [sym_array_constraint] = STATE(116), + [sym_let_expression] = STATE(116), + [sym_function_expression] = STATE(116), + [sym_match_expression] = STATE(116), + [sym_import_expression] = STATE(116), + [sym_parenthesized_expression] = STATE(116), + [sym_call_expression] = STATE(116), + [sym_path_expression] = STATE(116), + [sym_comparison_constraint] = STATE(116), + [sym_unary_expression] = STATE(116), + [sym_binary_expression] = STATE(116), + [sym_default_expression] = STATE(116), + [sym_as_expression] = STATE(116), [aux_sym_source_file_repeat1] = STATE(3), [ts_builtin_sym_end] = ACTIONS(37), [sym_identifier] = ACTIONS(39), @@ -1755,24 +1822,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(78), }, [4] = { - [sym__expression] = STATE(165), - [sym_literal] = STATE(165), - [sym_boolean] = STATE(137), - [sym_object] = 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_match_arm] = STATE(213), - [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__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_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1797,24 +1866,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [5] = { - [sym__expression] = STATE(165), - [sym_literal] = STATE(165), - [sym_boolean] = STATE(137), - [sym_object] = 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_match_arm] = STATE(186), - [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__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_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1839,24 +1910,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [6] = { - [sym__expression] = STATE(165), - [sym_literal] = STATE(165), - [sym_boolean] = STATE(137), - [sym_object] = 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_match_arm] = STATE(213), - [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__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_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1881,24 +1954,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [7] = { - [sym__expression] = STATE(165), - [sym_literal] = STATE(165), - [sym_boolean] = STATE(137), - [sym_object] = 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_match_arm] = STATE(213), - [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__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_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1923,24 +1998,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [8] = { - [sym__expression] = STATE(165), - [sym_literal] = STATE(165), - [sym_boolean] = STATE(137), - [sym_object] = 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_match_arm] = STATE(213), - [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__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_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -1965,24 +2042,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [9] = { - [sym__expression] = STATE(165), - [sym_literal] = STATE(165), - [sym_boolean] = STATE(137), - [sym_object] = 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_match_arm] = STATE(198), - [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__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_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2007,24 +2086,112 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [10] = { - [sym__expression] = STATE(165), - [sym_literal] = STATE(165), - [sym_boolean] = STATE(137), - [sym_object] = 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_match_arm] = STATE(213), - [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__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_identifier] = ACTIONS(123), + [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(125), + [anon_sym_LBRACE] = ACTIONS(91), + [anon_sym_DOT_DOT_DOT] = ACTIONS(127), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_RBRACK] = ACTIONS(129), + [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), + }, + [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_identifier] = ACTIONS(131), + [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(133), + [anon_sym_LBRACE] = ACTIONS(91), + [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_let] = ACTIONS(97), + [anon_sym_LPAREN] = ACTIONS(99), + [anon_sym_RPAREN] = ACTIONS(135), + [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), + }, + [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_identifier] = ACTIONS(81), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2047,108 +2214,28 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(111), [anon_sym_BANG] = ACTIONS(111), }, - [11] = { - [sym__expression] = STATE(166), - [sym_literal] = STATE(166), - [sym_boolean] = STATE(137), - [sym_object] = STATE(166), - [sym_array] = STATE(166), - [sym_array_constraint] = STATE(166), - [sym_let_expression] = STATE(166), - [sym_function_expression] = STATE(166), - [sym_parameter] = STATE(191), - [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_identifier] = ACTIONS(123), - [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(125), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_let] = ACTIONS(97), - [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_RPAREN] = ACTIONS(127), - [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), - }, - [12] = { - [sym__expression] = STATE(156), - [sym_literal] = STATE(156), - [sym_boolean] = STATE(137), - [sym_object] = 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_identifier] = ACTIONS(129), - [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(131), - [anon_sym_LBRACE] = ACTIONS(91), - [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_RBRACK] = ACTIONS(133), - [anon_sym_DOT_DOT_DOT] = ACTIONS(135), - [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), - }, [13] = { - [sym__expression] = STATE(164), - [sym_literal] = STATE(164), - [sym_boolean] = STATE(137), - [sym_object] = STATE(164), - [sym_array] = STATE(164), - [sym_array_constraint] = STATE(164), - [sym_let_expression] = STATE(164), - [sym_function_expression] = STATE(164), + [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(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_identifier] = ACTIONS(123), + [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_identifier] = ACTIONS(131), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), [anon_sym_false] = ACTIONS(83), @@ -2171,23 +2258,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [14] = { - [sym__expression] = STATE(154), - [sym_literal] = STATE(154), - [sym_boolean] = STATE(137), - [sym_object] = STATE(154), - [sym_array] = STATE(154), - [sym_array_constraint] = STATE(154), - [sym_let_expression] = STATE(154), - [sym_function_expression] = STATE(154), - [sym_match_expression] = STATE(154), - [sym_import_expression] = STATE(154), - [sym_parenthesized_expression] = STATE(154), - [sym_call_expression] = STATE(154), - [sym_path_expression] = STATE(154), - [sym_comparison_constraint] = STATE(154), - [sym_unary_expression] = STATE(154), - [sym_binary_expression] = STATE(154), - [sym_default_expression] = STATE(154), + [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_identifier] = ACTIONS(141), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2197,9 +2286,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_float] = ACTIONS(85), [sym_regex_literal] = ACTIONS(143), [anon_sym_LBRACE] = ACTIONS(91), + [anon_sym_DOT_DOT_DOT] = ACTIONS(145), [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_RBRACK] = ACTIONS(145), - [anon_sym_DOT_DOT_DOT] = ACTIONS(147), + [anon_sym_RBRACK] = ACTIONS(147), [anon_sym_let] = ACTIONS(97), [anon_sym_LPAREN] = ACTIONS(99), [anon_sym_match] = ACTIONS(101), @@ -2212,23 +2301,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [15] = { - [sym__expression] = STATE(155), - [sym_literal] = STATE(155), - [sym_boolean] = STATE(137), - [sym_object] = STATE(155), - [sym_array] = STATE(155), - [sym_array_constraint] = STATE(155), - [sym_let_expression] = STATE(155), - [sym_function_expression] = STATE(155), - [sym_match_expression] = STATE(155), - [sym_import_expression] = STATE(155), - [sym_parenthesized_expression] = STATE(155), - [sym_call_expression] = STATE(155), - [sym_path_expression] = STATE(155), - [sym_comparison_constraint] = STATE(155), - [sym_unary_expression] = STATE(155), - [sym_binary_expression] = STATE(155), - [sym_default_expression] = STATE(155), + [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), @@ -2252,23 +2343,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [16] = { - [sym__expression] = STATE(155), - [sym_literal] = STATE(155), - [sym_boolean] = STATE(137), - [sym_object] = STATE(155), - [sym_array] = STATE(155), - [sym_array_constraint] = STATE(155), - [sym_let_expression] = STATE(155), - [sym_function_expression] = STATE(155), - [sym_match_expression] = STATE(155), - [sym_import_expression] = STATE(155), - [sym_parenthesized_expression] = STATE(155), - [sym_call_expression] = STATE(155), - [sym_path_expression] = STATE(155), - [sym_comparison_constraint] = STATE(155), - [sym_unary_expression] = STATE(155), - [sym_binary_expression] = STATE(155), - [sym_default_expression] = STATE(155), + [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), @@ -2279,9 +2372,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_regex_literal] = ACTIONS(151), [anon_sym_LBRACE] = ACTIONS(91), [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_RBRACK] = ACTIONS(155), [anon_sym_let] = ACTIONS(97), [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_RPAREN] = ACTIONS(155), [anon_sym_match] = ACTIONS(101), [anon_sym_import] = ACTIONS(105), [anon_sym_GT] = ACTIONS(107), @@ -2292,23 +2385,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [17] = { - [sym__expression] = STATE(155), - [sym_literal] = STATE(155), - [sym_boolean] = STATE(137), - [sym_object] = STATE(155), - [sym_array] = STATE(155), - [sym_array_constraint] = STATE(155), - [sym_let_expression] = STATE(155), - [sym_function_expression] = STATE(155), - [sym_match_expression] = STATE(155), - [sym_import_expression] = STATE(155), - [sym_parenthesized_expression] = STATE(155), - [sym_call_expression] = STATE(155), - [sym_path_expression] = STATE(155), - [sym_comparison_constraint] = STATE(155), - [sym_unary_expression] = STATE(155), - [sym_binary_expression] = STATE(155), - [sym_default_expression] = STATE(155), + [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), @@ -2319,9 +2414,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_regex_literal] = ACTIONS(151), [anon_sym_LBRACE] = ACTIONS(91), [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_RBRACK] = ACTIONS(157), [anon_sym_let] = ACTIONS(97), [anon_sym_LPAREN] = ACTIONS(99), + [anon_sym_RPAREN] = ACTIONS(157), [anon_sym_match] = ACTIONS(101), [anon_sym_import] = ACTIONS(105), [anon_sym_GT] = ACTIONS(107), @@ -2332,23 +2427,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [18] = { - [sym__expression] = STATE(155), - [sym_literal] = STATE(155), - [sym_boolean] = STATE(137), - [sym_object] = STATE(155), - [sym_array] = STATE(155), - [sym_array_constraint] = STATE(155), - [sym_let_expression] = STATE(155), - [sym_function_expression] = STATE(155), - [sym_match_expression] = STATE(155), - [sym_import_expression] = STATE(155), - [sym_parenthesized_expression] = STATE(155), - [sym_call_expression] = STATE(155), - [sym_path_expression] = STATE(155), - [sym_comparison_constraint] = STATE(155), - [sym_unary_expression] = STATE(155), - [sym_binary_expression] = STATE(155), - [sym_default_expression] = STATE(155), + [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), @@ -2359,9 +2456,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_regex_literal] = ACTIONS(151), [anon_sym_LBRACE] = ACTIONS(91), [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_RBRACK] = ACTIONS(159), [anon_sym_let] = ACTIONS(97), [anon_sym_LPAREN] = ACTIONS(99), + [anon_sym_RPAREN] = ACTIONS(159), [anon_sym_match] = ACTIONS(101), [anon_sym_import] = ACTIONS(105), [anon_sym_GT] = ACTIONS(107), @@ -2372,23 +2469,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [19] = { - [sym__expression] = STATE(152), - [sym_literal] = STATE(152), - [sym_boolean] = STATE(137), - [sym_object] = 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__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_identifier] = ACTIONS(161), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2412,23 +2511,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [20] = { - [sym__expression] = STATE(155), - [sym_literal] = STATE(155), - [sym_boolean] = STATE(137), - [sym_object] = STATE(155), - [sym_array] = STATE(155), - [sym_array_constraint] = STATE(155), - [sym_let_expression] = STATE(155), - [sym_function_expression] = STATE(155), - [sym_match_expression] = STATE(155), - [sym_import_expression] = STATE(155), - [sym_parenthesized_expression] = STATE(155), - [sym_call_expression] = STATE(155), - [sym_path_expression] = STATE(155), - [sym_comparison_constraint] = STATE(155), - [sym_unary_expression] = STATE(155), - [sym_binary_expression] = STATE(155), - [sym_default_expression] = STATE(155), + [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), @@ -2452,23 +2553,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [21] = { - [sym__expression] = STATE(155), - [sym_literal] = STATE(155), - [sym_boolean] = STATE(137), - [sym_object] = STATE(155), - [sym_array] = STATE(155), - [sym_array_constraint] = STATE(155), - [sym_let_expression] = STATE(155), - [sym_function_expression] = STATE(155), - [sym_match_expression] = STATE(155), - [sym_import_expression] = STATE(155), - [sym_parenthesized_expression] = STATE(155), - [sym_call_expression] = STATE(155), - [sym_path_expression] = STATE(155), - [sym_comparison_constraint] = STATE(155), - [sym_unary_expression] = STATE(155), - [sym_binary_expression] = STATE(155), - [sym_default_expression] = STATE(155), + [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), @@ -2479,9 +2582,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_regex_literal] = ACTIONS(151), [anon_sym_LBRACE] = ACTIONS(91), [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_RBRACK] = ACTIONS(169), [anon_sym_let] = ACTIONS(97), [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_RPAREN] = ACTIONS(169), [anon_sym_match] = ACTIONS(101), [anon_sym_import] = ACTIONS(105), [anon_sym_GT] = ACTIONS(107), @@ -2492,23 +2595,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [22] = { - [sym__expression] = STATE(151), - [sym_literal] = STATE(151), - [sym_boolean] = STATE(137), - [sym_object] = 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__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_identifier] = ACTIONS(171), [sym_comment] = ACTIONS(3), [anon_sym_true] = ACTIONS(83), @@ -2532,23 +2637,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [23] = { - [sym__expression] = STATE(155), - [sym_literal] = STATE(155), - [sym_boolean] = STATE(137), - [sym_object] = STATE(155), - [sym_array] = STATE(155), - [sym_array_constraint] = STATE(155), - [sym_let_expression] = STATE(155), - [sym_function_expression] = STATE(155), - [sym_match_expression] = STATE(155), - [sym_import_expression] = STATE(155), - [sym_parenthesized_expression] = STATE(155), - [sym_call_expression] = STATE(155), - [sym_path_expression] = STATE(155), - [sym_comparison_constraint] = STATE(155), - [sym_unary_expression] = STATE(155), - [sym_binary_expression] = STATE(155), - [sym_default_expression] = STATE(155), + [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), @@ -2559,9 +2666,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_regex_literal] = ACTIONS(151), [anon_sym_LBRACE] = ACTIONS(91), [anon_sym_LBRACK] = ACTIONS(95), + [anon_sym_RBRACK] = ACTIONS(177), [anon_sym_let] = ACTIONS(97), [anon_sym_LPAREN] = ACTIONS(99), - [anon_sym_RPAREN] = ACTIONS(177), [anon_sym_match] = ACTIONS(101), [anon_sym_import] = ACTIONS(105), [anon_sym_GT] = ACTIONS(107), @@ -2572,23 +2679,25 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BANG] = ACTIONS(111), }, [24] = { - [sym__expression] = STATE(155), - [sym_literal] = STATE(155), - [sym_boolean] = STATE(137), - [sym_object] = STATE(155), - [sym_array] = STATE(155), - [sym_array_constraint] = STATE(155), - [sym_let_expression] = STATE(155), - [sym_function_expression] = STATE(155), - [sym_match_expression] = STATE(155), - [sym_import_expression] = STATE(155), - [sym_parenthesized_expression] = STATE(155), - [sym_call_expression] = STATE(155), - [sym_path_expression] = STATE(155), - [sym_comparison_constraint] = STATE(155), - [sym_unary_expression] = STATE(155), - [sym_binary_expression] = STATE(155), - [sym_default_expression] = STATE(155), + [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), @@ -2599,7 +2708,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_regex_literal] = ACTIONS(151), [anon_sym_LBRACE] = ACTIONS(91), [anon_sym_LBRACK] = ACTIONS(95), - [anon_sym_RBRACK] = ACTIONS(179), + [anon_sym_let] = ACTIONS(97), + [anon_sym_LPAREN] = ACTIONS(99), + [anon_sym_RPAREN] = ACTIONS(179), + [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), + }, + [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), @@ -2611,2461 +2761,1905 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [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] = 17, + [0] = 6, 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(181), 1, - sym_identifier, - ACTIONS(183), 1, - sym_regex_literal, - STATE(137), 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(135), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [72] = 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(185), 1, - sym_identifier, - ACTIONS(187), 1, - sym_regex_literal, - STATE(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [144] = 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(189), 1, - sym_identifier, - ACTIONS(191), 1, - sym_regex_literal, - STATE(137), 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(122), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [216] = 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(137), 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(160), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [288] = 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(137), 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(112), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [360] = 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(137), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [432] = 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(205), 1, - sym_identifier, - ACTIONS(207), 1, - sym_regex_literal, - STATE(137), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [504] = 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(137), 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(150), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [576] = 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(137), 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(149), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [648] = 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(137), 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(155), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [720] = 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(137), 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(115), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [792] = 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(137), 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(118), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [864] = 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(225), 1, - sym_identifier, - ACTIONS(227), 1, - sym_regex_literal, - STATE(137), 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(126), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [936] = 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(137), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1008] = 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(233), 1, - sym_identifier, - ACTIONS(235), 1, - sym_regex_literal, - STATE(137), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1080] = 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(237), 1, - sym_identifier, - ACTIONS(239), 1, - sym_regex_literal, - STATE(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1152] = 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(241), 1, - sym_identifier, - ACTIONS(243), 1, - sym_regex_literal, - STATE(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1224] = 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(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1296] = 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(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1368] = 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(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1440] = 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(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1512] = 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(71), 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(74), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1584] = 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(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1656] = 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(71), 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(88), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1728] = 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(71), 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(89), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1800] = 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(277), 1, - sym_identifier, - ACTIONS(279), 1, - sym_regex_literal, - STATE(137), 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(120), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1872] = 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(281), 1, - sym_identifier, - ACTIONS(283), 1, - sym_regex_literal, - STATE(137), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [1944] = 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(285), 1, - sym_identifier, - ACTIONS(287), 1, - sym_regex_literal, - STATE(137), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2016] = 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(137), 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(163), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2088] = 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(137), 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(119), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2160] = 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(297), 1, - sym_identifier, - ACTIONS(299), 1, - sym_regex_literal, - STATE(71), 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(94), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2232] = 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(137), 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(124), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2304] = 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(137), 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(134), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2376] = 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(309), 1, - sym_identifier, - ACTIONS(311), 1, - sym_regex_literal, - STATE(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2448] = 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(137), 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(162), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2520] = 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(317), 1, - sym_identifier, - ACTIONS(319), 1, - sym_regex_literal, - STATE(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2592] = 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(321), 1, - sym_identifier, - ACTIONS(323), 1, - sym_regex_literal, - STATE(71), 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(69), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2664] = 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(325), 1, - sym_identifier, - ACTIONS(327), 1, - sym_regex_literal, - STATE(71), 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(99), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2736] = 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(329), 1, - sym_identifier, - ACTIONS(331), 1, - sym_regex_literal, - STATE(71), 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(100), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2808] = 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(137), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2880] = 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(71), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [2952] = 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(137), 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(167), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [3024] = 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(137), 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), 16, - sym__expression, - sym_literal, - sym_object, - 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, - [3096] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(353), 1, - anon_sym_EQ, - ACTIONS(355), 1, - anon_sym_DOT, - STATE(208), 1, - aux_sym_field_path_repeat1, - ACTIONS(351), 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_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(349), 18, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - 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, - [3145] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, ACTIONS(369), 1, - anon_sym_DASH, + anon_sym_EQ, ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(385), 1, - anon_sym_SLASH_SLASH, - ACTIONS(387), 1, - anon_sym_default, - ACTIONS(365), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(367), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(357), 7, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - ACTIONS(359), 8, + anon_sym_DOT, + STATE(192), 1, + aux_sym_field_path_repeat1, + ACTIONS(367), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -5073,10 +4667,246 @@ 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, - [3214] = 3, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(365), 18, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + 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, + [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, + ACTIONS(3), 1, + sym_comment, + ACTIONS(379), 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(377), 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, + [134] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(383), 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(381), 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, + [176] = 3, + 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, + 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, + 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, @@ -5089,19 +4919,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LT, anon_sym_BANG, anon_sym_PLUS, - anon_sym_SLASH, anon_sym_AMP, anon_sym_default, - ACTIONS(389), 19, + 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_DOT, anon_sym_LBRACK, - anon_sym_LPAREN, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_DASH, @@ -5110,91 +4938,45 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_EQ_EQ, anon_sym_BANG_EQ, anon_sym_PLUS_PLUS, - anon_sym_STAR, anon_sym_SLASH_SLASH, - [3255] = 3, + [324] = 13, ACTIONS(3), 1, sym_comment, - ACTIONS(395), 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_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(393), 19, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, + ACTIONS(393), 1, anon_sym_DOT, - anon_sym_LBRACK, + ACTIONS(395), 1, anon_sym_LPAREN, - anon_sym_GT_EQ, - anon_sym_LT_EQ, + ACTIONS(397), 1, anon_sym_DASH, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, + ACTIONS(399), 1, anon_sym_PLUS_PLUS, - anon_sym_STAR, - anon_sym_SLASH_SLASH, - [3296] = 18, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(385), 1, - anon_sym_SLASH_SLASH, - ACTIONS(387), 1, - anon_sym_default, ACTIONS(401), 1, - anon_sym_SEMI, - ACTIONS(365), 2, + anon_sym_PLUS, + ACTIONS(403), 1, + anon_sym_STAR, + ACTIONS(405), 1, + anon_sym_SLASH, + ACTIONS(411), 1, + anon_sym_AMP_AMP, + ACTIONS(407), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(367), 4, + ACTIONS(409), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(397), 6, + ACTIONS(389), 9, ts_builtin_sym_end, + anon_sym_SEMI, sym_string, sym_float, sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, - ACTIONS(399), 8, + anon_sym_PIPE_PIPE, + anon_sym_SLASH_SLASH, + ACTIONS(391), 11, anon_sym_true, anon_sym_false, sym_integer, @@ -5203,10 +4985,73 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - [3367] = 3, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + [386] = 12, ACTIONS(3), 1, sym_comment, - ACTIONS(405), 14, + 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, @@ -5217,86 +5062,33 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_GT, anon_sym_LT, anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, anon_sym_AMP, anon_sym_default, - ACTIONS(403), 19, + 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_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, - [3408] = 17, + [500] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(361), 1, + ACTIONS(393), 1, anon_sym_DOT, - ACTIONS(363), 1, + ACTIONS(395), 1, anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(385), 1, - anon_sym_SLASH_SLASH, - ACTIONS(387), 1, - anon_sym_default, - ACTIONS(365), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(367), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(407), 7, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - ACTIONS(409), 8, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_BANG, - [3477] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(413), 14, + ACTIONS(391), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -5311,49 +5103,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, - ACTIONS(411), 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, - [3518] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(417), 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_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(415), 17, + anon_sym_as, + ACTIONS(389), 17, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5371,105 +5122,36 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [3563] = 3, + [546] = 14, ACTIONS(3), 1, sym_comment, - ACTIONS(421), 14, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, + 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, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(419), 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, + ACTIONS(409), 4, 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, - [3604] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(425), 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_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(423), 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, - [3645] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(429), 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_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(427), 17, + ACTIONS(389), 8, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5477,141 +5159,8 @@ 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, - [3690] = 10, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(433), 12, - 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, - ACTIONS(431), 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, - [3745] = 7, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(433), 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_PLUS, - anon_sym_AMP, - anon_sym_default, - ACTIONS(431), 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, - [3794] = 13, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(365), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(367), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(431), 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(433), 10, + ACTIONS(391), 11, anon_sym_true, anon_sym_false, sym_integer, @@ -5622,32 +5171,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_BANG, anon_sym_AMP, anon_sym_default, - [3855] = 12, + anon_sym_as, + [610] = 15, ACTIONS(3), 1, sym_comment, - ACTIONS(361), 1, + ACTIONS(393), 1, anon_sym_DOT, - ACTIONS(363), 1, + ACTIONS(395), 1, anon_sym_LPAREN, - ACTIONS(369), 1, + ACTIONS(397), 1, anon_sym_DASH, - ACTIONS(375), 1, + ACTIONS(399), 1, anon_sym_PLUS_PLUS, - ACTIONS(377), 1, + ACTIONS(401), 1, anon_sym_PLUS, - ACTIONS(379), 1, + ACTIONS(403), 1, anon_sym_STAR, - ACTIONS(381), 1, + ACTIONS(405), 1, anon_sym_SLASH, - ACTIONS(365), 2, + 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_GT, anon_sym_LT, - ACTIONS(367), 4, + ACTIONS(409), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(431), 10, + ACTIONS(389), 8, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5655,10 +5211,8 @@ static const uint16_t ts_small_parse_table[] = { sym_regex_literal, anon_sym_LBRACE, anon_sym_LBRACK, - anon_sym_PIPE_PIPE, - anon_sym_AMP_AMP, anon_sym_SLASH_SLASH, - ACTIONS(433), 10, + ACTIONS(391), 10, anon_sym_true, anon_sym_false, sym_integer, @@ -5667,37 +5221,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - anon_sym_AMP, anon_sym_default, - [3914] = 9, + anon_sym_as, + [676] = 17, ACTIONS(3), 1, sym_comment, - ACTIONS(361), 1, + ACTIONS(393), 1, anon_sym_DOT, - ACTIONS(363), 1, + ACTIONS(395), 1, anon_sym_LPAREN, - ACTIONS(369), 1, + ACTIONS(397), 1, anon_sym_DASH, - ACTIONS(377), 1, + ACTIONS(399), 1, + anon_sym_PLUS_PLUS, + ACTIONS(401), 1, anon_sym_PLUS, - ACTIONS(379), 1, + ACTIONS(403), 1, anon_sym_STAR, - ACTIONS(381), 1, + ACTIONS(405), 1, anon_sym_SLASH, - ACTIONS(433), 12, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, + 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, - anon_sym_BANG, - anon_sym_AMP, - anon_sym_default, - ACTIONS(431), 15, + ACTIONS(409), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(417), 7, ts_builtin_sym_end, anon_sym_SEMI, sym_string, @@ -5705,22 +5266,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_PIPE_PIPE, - anon_sym_AMP_AMP, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_PLUS_PLUS, - anon_sym_SLASH_SLASH, - [3967] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(433), 14, + ACTIONS(419), 9, anon_sym_true, anon_sym_false, sym_integer, @@ -5728,14 +5274,44 @@ static const uint16_t ts_small_parse_table[] = { 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, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(431), 17, + 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, @@ -5743,55 +5319,62 @@ 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, - [4012] = 14, + ACTIONS(427), 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, + [816] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(361), 1, + ACTIONS(393), 1, anon_sym_DOT, - ACTIONS(363), 1, + ACTIONS(395), 1, anon_sym_LPAREN, - ACTIONS(369), 1, + ACTIONS(397), 1, anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, + ACTIONS(399), 1, anon_sym_PLUS_PLUS, - ACTIONS(377), 1, + ACTIONS(401), 1, anon_sym_PLUS, - ACTIONS(379), 1, + ACTIONS(403), 1, anon_sym_STAR, - ACTIONS(381), 1, + ACTIONS(405), 1, anon_sym_SLASH, - ACTIONS(365), 2, + 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(367), 4, + ACTIONS(409), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, + ACTIONS(429), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, ACTIONS(431), 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(433), 10, anon_sym_true, anon_sym_false, sym_integer, @@ -5800,49 +5383,49 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - anon_sym_AMP, - anon_sym_default, - [4075] = 15, + [888] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(365), 2, + ACTIONS(437), 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, - ACTIONS(367), 4, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(435), 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, - ACTIONS(431), 8, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, + anon_sym_PLUS_PLUS, + anon_sym_STAR, anon_sym_SLASH_SLASH, - ACTIONS(433), 9, + [930] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(441), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -5850,116 +5433,38 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_let, anon_sym_match, anon_sym_import, - anon_sym_BANG, - anon_sym_default, - [4140] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(385), 1, - anon_sym_SLASH_SLASH, - ACTIONS(387), 1, - anon_sym_default, - ACTIONS(365), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(367), 4, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(439), 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_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(435), 7, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - ACTIONS(437), 8, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_BANG, - [4209] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(369), 1, anon_sym_DASH, - ACTIONS(371), 1, anon_sym_PIPE_PIPE, - ACTIONS(373), 1, anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(385), 1, - anon_sym_SLASH_SLASH, - ACTIONS(387), 1, - anon_sym_default, - ACTIONS(365), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(367), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(439), 7, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - ACTIONS(441), 8, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_BANG, - [4278] = 3, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + [972] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(445), 14, + ACTIONS(445), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -5974,6 +5479,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(443), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -5994,10 +5500,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [4319] = 3, + [1014] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(449), 14, + ACTIONS(449), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6012,6 +5518,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(447), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6032,48 +5539,64 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [4360] = 3, + [1056] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(453), 14, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, + 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, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(451), 19, + ACTIONS(409), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(451), 7, 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, - [4401] = 3, + ACTIONS(453), 8, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + [1128] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(457), 14, + ACTIONS(457), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6088,6 +5611,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(455), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6108,62 +5632,49 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [4442] = 17, + [1170] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(385), 1, - anon_sym_SLASH_SLASH, - ACTIONS(387), 1, - anon_sym_default, - ACTIONS(365), 2, + ACTIONS(461), 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, - ACTIONS(367), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(459), 7, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(459), 19, ts_builtin_sym_end, anon_sym_SEMI, sym_string, sym_float, sym_regex_literal, anon_sym_LBRACE, + anon_sym_DOT, anon_sym_LBRACK, - ACTIONS(461), 8, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, - anon_sym_BANG, - [4511] = 3, + 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, + [1212] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(465), 14, + ACTIONS(465), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6178,6 +5689,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(463), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6198,10 +5710,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [4552] = 3, + [1254] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(469), 14, + ACTIONS(469), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6216,6 +5728,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(467), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6236,10 +5749,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [4593] = 3, + [1296] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(473), 14, + ACTIONS(473), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6254,6 +5767,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(471), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6274,10 +5788,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [4634] = 3, + [1338] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(477), 14, + ACTIONS(477), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6292,6 +5806,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(475), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6312,37 +5827,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [4675] = 17, + [1380] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(361), 1, + ACTIONS(393), 1, anon_sym_DOT, - ACTIONS(363), 1, + ACTIONS(395), 1, anon_sym_LPAREN, - ACTIONS(369), 1, + ACTIONS(397), 1, anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, + ACTIONS(399), 1, anon_sym_PLUS_PLUS, - ACTIONS(377), 1, + ACTIONS(401), 1, anon_sym_PLUS, - ACTIONS(379), 1, + ACTIONS(403), 1, anon_sym_STAR, - ACTIONS(381), 1, + ACTIONS(405), 1, anon_sym_SLASH, - ACTIONS(383), 1, + ACTIONS(411), 1, + anon_sym_AMP_AMP, + ACTIONS(413), 1, + anon_sym_PIPE_PIPE, + ACTIONS(415), 1, anon_sym_AMP, - ACTIONS(385), 1, + ACTIONS(421), 1, anon_sym_SLASH_SLASH, - ACTIONS(387), 1, + ACTIONS(423), 1, anon_sym_default, - ACTIONS(365), 2, + ACTIONS(433), 1, + anon_sym_as, + ACTIONS(407), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(367), 4, + ACTIONS(409), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, @@ -6364,50 +5881,14 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - [4744] = 17, + [1452] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(361), 1, + ACTIONS(393), 1, anon_sym_DOT, - ACTIONS(363), 1, + ACTIONS(395), 1, anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(385), 1, - anon_sym_SLASH_SLASH, - ACTIONS(387), 1, - anon_sym_default, - ACTIONS(365), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(367), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(483), 7, - ts_builtin_sym_end, - anon_sym_SEMI, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, - ACTIONS(485), 8, + ACTIONS(485), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6415,38 +5896,65 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_let, anon_sym_match, anon_sym_import, - anon_sym_BANG, - [4813] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(361), 1, - anon_sym_DOT, - ACTIONS(363), 1, - anon_sym_LPAREN, - ACTIONS(369), 1, - anon_sym_DASH, - ACTIONS(371), 1, - anon_sym_PIPE_PIPE, - ACTIONS(373), 1, - anon_sym_AMP_AMP, - ACTIONS(375), 1, - anon_sym_PLUS_PLUS, - ACTIONS(377), 1, - anon_sym_PLUS, - ACTIONS(379), 1, - anon_sym_STAR, - ACTIONS(381), 1, - anon_sym_SLASH, - ACTIONS(383), 1, - anon_sym_AMP, - ACTIONS(385), 1, - anon_sym_SLASH_SLASH, - ACTIONS(387), 1, - anon_sym_default, - ACTIONS(365), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(367), 4, + anon_sym_BANG, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + anon_sym_default, + anon_sym_as, + ACTIONS(483), 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, + [1498] = 18, + 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, @@ -6468,10 +5976,68 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_match, anon_sym_import, anon_sym_BANG, - [4882] = 3, + [1570] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(493), 14, + 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(491), 7, + ts_builtin_sym_end, + anon_sym_SEMI, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + ACTIONS(493), 8, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + [1642] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(393), 1, + anon_sym_DOT, + ACTIONS(395), 1, + anon_sym_LPAREN, + ACTIONS(497), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6486,16 +6052,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, - ACTIONS(491), 19, + anon_sym_as, + ACTIONS(495), 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, @@ -6506,48 +6071,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [4923] = 3, + [1688] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(497), 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_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(495), 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, - [4964] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(501), 14, + ACTIONS(501), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6562,6 +6089,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(499), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6582,10 +6110,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [5005] = 3, + [1730] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(505), 14, + ACTIONS(505), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6600,6 +6128,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(503), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6620,10 +6149,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [5046] = 3, + [1772] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(509), 14, + ACTIONS(509), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6638,6 +6167,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(507), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6658,48 +6188,64 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [5087] = 3, + [1814] = 18, ACTIONS(3), 1, sym_comment, - ACTIONS(513), 14, - anon_sym_true, - anon_sym_false, - sym_integer, - sym_identifier, - anon_sym_let, - anon_sym_match, - anon_sym_import, + 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, - anon_sym_BANG, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - anon_sym_default, - ACTIONS(511), 19, + 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_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, - [5128] = 3, + ACTIONS(513), 8, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + [1886] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(517), 14, + ACTIONS(517), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6714,6 +6260,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(515), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6734,10 +6281,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [5169] = 3, + [1928] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 14, + ACTIONS(521), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6752,6 +6299,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(519), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6772,10 +6320,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [5210] = 3, + [1970] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(525), 14, + ACTIONS(525), 15, anon_sym_true, anon_sym_false, sym_integer, @@ -6790,6 +6338,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_SLASH, anon_sym_AMP, anon_sym_default, + anon_sym_as, ACTIONS(523), 19, ts_builtin_sym_end, anon_sym_SEMI, @@ -6810,25 +6359,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - [5251] = 3, + [2012] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(457), 5, + ACTIONS(529), 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(455), 20, + anon_sym_default, + anon_sym_as, + ACTIONS(527), 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, @@ -6839,69 +6398,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - anon_sym_default, - [5284] = 16, + [2054] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(435), 7, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - [5343] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(525), 5, + ACTIONS(533), 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(523), 20, + anon_sym_default, + anon_sym_as, + ACTIONS(531), 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, @@ -6912,26 +6437,35 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - anon_sym_default, - [5376] = 3, + [2096] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(391), 5, + ACTIONS(537), 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(389), 20, + anon_sym_default, + anon_sym_as, + ACTIONS(535), 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, @@ -6942,37 +6476,285 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS_PLUS, anon_sym_STAR, anon_sym_SLASH_SLASH, - anon_sym_default, - [5409] = 13, + [2138] = 18, 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_AMP, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(531), 2, + anon_sym_as, + ACTIONS(407), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(533), 4, + ACTIONS(409), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(431), 10, + 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, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + [2210] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(545), 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(543), 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, + [2252] = 19, + 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(551), 1, + anon_sym_SEMI, + 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(547), 6, + ts_builtin_sym_end, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + ACTIONS(549), 8, + anon_sym_true, + anon_sym_false, + sym_integer, + sym_identifier, + anon_sym_let, + anon_sym_match, + anon_sym_import, + anon_sym_BANG, + [2326] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(375), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(373), 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, + [2360] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(437), 5, + anon_sym_GT, + anon_sym_LT, + 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, + 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, + [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, @@ -6980,10 +6762,145 @@ static const uint16_t ts_small_parse_table[] = { 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, - [5462] = 3, + 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, @@ -6992,7 +6909,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(507), 20, + ACTIONS(507), 21, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7013,106 +6930,45 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_STAR, anon_sym_SLASH_SLASH, anon_sym_default, - [5495] = 3, + anon_sym_as, + [2688] = 17, 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), 20, - 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, - [5528] = 7, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(433), 4, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_AMP, - ACTIONS(431), 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_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, - [5569] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, 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(531), 2, + ACTIONS(581), 1, + anon_sym_as, + ACTIONS(557), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(533), 4, + ACTIONS(559), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(357), 7, + ACTIONS(539), 7, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7120,37 +6976,194 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_RPAREN, anon_sym_COLON, - [5628] = 16, + [2750] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(531), 2, + ACTIONS(521), 5, anon_sym_GT, anon_sym_LT, - ACTIONS(533), 4, + 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, @@ -7163,67 +7176,39 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_RPAREN, anon_sym_COLON, - [5687] = 3, + [2982] = 17, 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), 20, - 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, - [5720] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, 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(531), 2, + ACTIONS(581), 1, + anon_sym_as, + ACTIONS(557), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(533), 4, + ACTIONS(559), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, @@ -7236,16 +7221,16 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_RPAREN, anon_sym_COLON, - [5779] = 3, + [3044] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(497), 5, + ACTIONS(457), 5, anon_sym_GT, anon_sym_LT, anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(495), 20, + ACTIONS(455), 21, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7266,42 +7251,74 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_STAR, anon_sym_SLASH_SLASH, anon_sym_default, - [5812] = 16, + anon_sym_as, + [3078] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, + ACTIONS(441), 5, + anon_sym_GT, + anon_sym_LT, anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, anon_sym_SLASH, - ACTIONS(549), 1, anon_sym_AMP, - ACTIONS(551), 1, + ACTIONS(439), 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, + [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(531), 2, + ACTIONS(557), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(533), 4, + ACTIONS(559), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(483), 7, + ACTIONS(425), 8, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7309,23 +7326,154 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_RPAREN, anon_sym_COLON, - [5871] = 3, + anon_sym_as, + [3172] = 16, ACTIONS(3), 1, sym_comment, - ACTIONS(477), 5, + 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(475), 20, + ACTIONS(389), 19, 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, @@ -7339,164 +7487,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_STAR, anon_sym_SLASH_SLASH, anon_sym_default, - [5904] = 10, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(433), 3, - anon_sym_GT, - anon_sym_LT, - anon_sym_AMP, - ACTIONS(431), 15, - 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, - [5951] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(425), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(423), 20, - 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, - [5984] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(421), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(419), 20, - 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, - [6017] = 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), 20, - 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, - [6050] = 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), 20, - 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, - [6083] = 3, + anon_sym_as, + [3382] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(445), 5, @@ -7505,7 +7497,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(443), 20, + ACTIONS(443), 21, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7526,16 +7518,17 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_STAR, anon_sym_SLASH_SLASH, anon_sym_default, - [6116] = 3, + anon_sym_as, + [3416] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(473), 5, + ACTIONS(533), 5, anon_sym_GT, anon_sym_LT, anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(471), 20, + ACTIONS(531), 21, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7556,72 +7549,27 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_STAR, anon_sym_SLASH_SLASH, anon_sym_default, - [6149] = 3, + anon_sym_as, + [3450] = 9, ACTIONS(3), 1, sym_comment, - ACTIONS(405), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(403), 20, - 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, - [6182] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, ACTIONS(553), 1, - anon_sym_default, - ACTIONS(531), 2, + 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, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(459), 7, + anon_sym_AMP, + ACTIONS(389), 17, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7629,34 +7577,44 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_RPAREN, anon_sym_COLON, - [6241] = 12, + 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(433), 1, + ACTIONS(391), 1, anon_sym_AMP, - ACTIONS(527), 1, + ACTIONS(553), 1, anon_sym_DOT, - ACTIONS(529), 1, + ACTIONS(555), 1, anon_sym_LPAREN, - ACTIONS(535), 1, + ACTIONS(561), 1, anon_sym_DASH, - ACTIONS(541), 1, + ACTIONS(567), 1, anon_sym_PLUS_PLUS, - ACTIONS(543), 1, + ACTIONS(569), 1, anon_sym_PLUS, - ACTIONS(545), 1, + ACTIONS(571), 1, anon_sym_STAR, - ACTIONS(547), 1, + ACTIONS(573), 1, anon_sym_SLASH, - ACTIONS(531), 2, + ACTIONS(557), 2, anon_sym_GT, anon_sym_LT, - ACTIONS(533), 4, + ACTIONS(559), 4, anon_sym_GT_EQ, anon_sym_LT_EQ, anon_sym_EQ_EQ, anon_sym_BANG_EQ, - ACTIONS(431), 11, + ACTIONS(389), 12, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7668,7 +7626,111 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_SLASH_SLASH, anon_sym_default, - [6292] = 3, + 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, @@ -7677,7 +7739,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(503), 20, + ACTIONS(503), 21, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -7698,1876 +7760,1825 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_STAR, anon_sym_SLASH_SLASH, anon_sym_default, - [6325] = 3, + anon_sym_as, + [3704] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(395), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(393), 20, - 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, - [6358] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, ACTIONS(553), 1, - anon_sym_default, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(407), 7, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - anon_sym_COLON, - [6417] = 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), 20, - 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, - [6450] = 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), 20, - 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, - [6483] = 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), 20, - 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, - [6516] = 14, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(431), 9, - 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, - [6571] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(413), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(411), 20, - 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, - [6604] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(417), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(415), 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_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - [6641] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(429), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(427), 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_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - [6678] = 14, - ACTIONS(3), 1, - sym_comment, - ACTIONS(433), 1, - anon_sym_AMP, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - ACTIONS(431), 9, - 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, - [6733] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(493), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(491), 20, - 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, - [6766] = 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), 20, - 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, - [6799] = 9, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(433), 3, - anon_sym_GT, - anon_sym_LT, - anon_sym_AMP, - ACTIONS(431), 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_PLUS_PLUS, - anon_sym_SLASH_SLASH, - anon_sym_default, - [6844] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(433), 5, - anon_sym_GT, - anon_sym_LT, - anon_sym_PLUS, - anon_sym_SLASH, - anon_sym_AMP, - ACTIONS(431), 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_STAR, - anon_sym_SLASH_SLASH, - anon_sym_default, - [6881] = 18, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, ACTIONS(555), 1, - anon_sym_COMMA, - ACTIONS(557), 1, - anon_sym_RPAREN, - STATE(185), 1, - aux_sym_array_repeat1, - ACTIONS(531), 2, + anon_sym_LPAREN, + ACTIONS(497), 5, anon_sym_GT, anon_sym_LT, - ACTIONS(533), 4, + 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, - [6940] = 18, + 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(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, ACTIONS(553), 1, - anon_sym_default, - ACTIONS(559), 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_RPAREN, - STATE(197), 1, - aux_sym_array_repeat1, - ACTIONS(531), 2, + 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, - ACTIONS(533), 4, + 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, - [6999] = 6, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [3870] = 3, ACTIONS(3), 1, sym_comment, + ACTIONS(383), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(381), 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, + [3904] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(379), 5, + anon_sym_GT, + anon_sym_LT, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(377), 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, + [3938] = 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, + [3972] = 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_COMMA, + 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(511), 7, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RBRACK, anon_sym_RPAREN, - ACTIONS(568), 1, anon_sym_COLON, - ACTIONS(351), 5, + [4034] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(387), 5, anon_sym_GT, anon_sym_LT, anon_sym_PLUS, anon_sym_SLASH, anon_sym_AMP, - ACTIONS(349), 13, - 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, - [7034] = 18, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(570), 1, - anon_sym_COMMA, - ACTIONS(572), 1, - anon_sym_RBRACK, - STATE(207), 1, - aux_sym_array_repeat1, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7093] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(574), 3, - anon_sym_COMMA, - anon_sym_RBRACK, - anon_sym_RPAREN, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7148] = 18, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(576), 1, - anon_sym_COMMA, - ACTIONS(578), 1, - anon_sym_RBRACK, - STATE(194), 1, - aux_sym_array_repeat1, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7207] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(401), 1, + ACTIONS(385), 21, anon_sym_SEMI, - ACTIONS(399), 9, - 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(397), 11, - ts_builtin_sym_end, - sym_string, - sym_float, - sym_regex_literal, anon_sym_LBRACE, - anon_sym_LBRACK, - anon_sym_LPAREN, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_BANG, - [7238] = 17, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, + anon_sym_RBRACE, anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(580), 1, anon_sym_COMMA, - ACTIONS(582), 1, anon_sym_RBRACK, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7294] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(586), 9, - 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(584), 11, - ts_builtin_sym_end, - sym_string, - sym_float, - sym_regex_literal, - anon_sym_LBRACE, - anon_sym_LBRACK, anon_sym_LPAREN, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_DASH, - anon_sym_BANG, - [7322] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(439), 2, - anon_sym_SEMI, - anon_sym_RBRACE, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7376] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(588), 2, - anon_sym_COMMA, anon_sym_RPAREN, - ACTIONS(533), 4, + 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, - [7430] = 16, + anon_sym_PLUS_PLUS, + anon_sym_STAR, + anon_sym_SLASH_SLASH, + anon_sym_default, + anon_sym_as, + [4068] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(531), 2, + ACTIONS(473), 5, anon_sym_GT, anon_sym_LT, - ACTIONS(590), 2, + anon_sym_PLUS, + anon_sym_SLASH, + anon_sym_AMP, + ACTIONS(471), 21, anon_sym_SEMI, + anon_sym_LBRACE, anon_sym_RBRACE, - ACTIONS(533), 4, + 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, + [4102] = 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(583), 1, + anon_sym_COMMA, + ACTIONS(585), 1, + anon_sym_RPAREN, + STATE(200), 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, - [7484] = 17, + [4164] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, + ACTIONS(587), 1, + anon_sym_COMMA, + ACTIONS(589), 1, + anon_sym_RPAREN, ACTIONS(592), 1, - anon_sym_COMMA, - ACTIONS(594), 1, - anon_sym_RBRACK, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7540] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(596), 1, - anon_sym_RPAREN, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7593] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(598), 1, anon_sym_COLON, - ACTIONS(531), 2, + ACTIONS(367), 5, anon_sym_GT, anon_sym_LT, - ACTIONS(533), 4, + 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, + 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, + [4200] = 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(594), 1, + 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, - [7646] = 16, + [4262] = 19, ACTIONS(3), 1, sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, 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, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7699] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(602), 1, - anon_sym_LBRACE, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7752] = 16, - ACTIONS(3), 1, - sym_comment, - ACTIONS(527), 1, - anon_sym_DOT, - ACTIONS(529), 1, - anon_sym_LPAREN, - ACTIONS(535), 1, - anon_sym_DASH, - ACTIONS(537), 1, - anon_sym_PIPE_PIPE, - ACTIONS(539), 1, - anon_sym_AMP_AMP, - ACTIONS(541), 1, - anon_sym_PLUS_PLUS, - ACTIONS(543), 1, - anon_sym_PLUS, - ACTIONS(545), 1, - anon_sym_STAR, - ACTIONS(547), 1, - anon_sym_SLASH, - ACTIONS(549), 1, - anon_sym_AMP, - ACTIONS(551), 1, - anon_sym_SLASH_SLASH, - ACTIONS(553), 1, - anon_sym_default, - ACTIONS(604), 1, - anon_sym_LBRACE, - ACTIONS(531), 2, - anon_sym_GT, - anon_sym_LT, - ACTIONS(533), 4, - anon_sym_GT_EQ, - anon_sym_LT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - [7805] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(606), 1, - sym_identifier, - ACTIONS(609), 1, - anon_sym_in, - STATE(169), 1, - aux_sym_let_expression_repeat1, - STATE(227), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7824] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(611), 1, - sym_identifier, - ACTIONS(613), 1, - anon_sym_in, - STATE(169), 1, - aux_sym_let_expression_repeat1, - STATE(227), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7843] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(611), 1, - sym_identifier, - ACTIONS(615), 1, - anon_sym_in, - STATE(172), 1, - aux_sym_let_expression_repeat1, - STATE(227), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7862] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(611), 1, - sym_identifier, - ACTIONS(617), 1, - anon_sym_in, - STATE(169), 1, - aux_sym_let_expression_repeat1, - STATE(227), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7881] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(611), 1, - sym_identifier, - ACTIONS(619), 1, - anon_sym_in, - STATE(170), 1, - aux_sym_let_expression_repeat1, - STATE(227), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7900] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(621), 1, - sym_identifier, - ACTIONS(623), 1, - anon_sym_RBRACE, STATE(209), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7916] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(621), 1, - sym_identifier, - ACTIONS(625), 1, - anon_sym_RBRACE, - STATE(209), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7932] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(621), 1, - sym_identifier, - ACTIONS(627), 1, - anon_sym_RBRACE, - STATE(209), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7948] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(621), 1, - sym_identifier, - ACTIONS(629), 1, - anon_sym_RBRACE, - STATE(209), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7964] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(621), 1, - sym_identifier, - ACTIONS(631), 1, - anon_sym_RBRACE, - STATE(200), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7980] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(621), 1, - sym_identifier, - ACTIONS(633), 1, - anon_sym_RBRACE, - STATE(190), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [7996] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(635), 1, - anon_sym_COMMA, - STATE(180), 1, aux_sym_array_repeat1, - ACTIONS(574), 2, + 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, + [4324] = 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(602), 1, + anon_sym_COMMA, + ACTIONS(604), 1, + anon_sym_RBRACK, + STATE(213), 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, + [4386] = 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(606), 3, + anon_sym_COMMA, anon_sym_RBRACK, anon_sym_RPAREN, - [8010] = 4, + ACTIONS(559), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [4444] = 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(608), 2, + anon_sym_SEMI, + anon_sym_RBRACE, + ACTIONS(559), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [4501] = 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(610), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + ACTIONS(559), 4, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + [4558] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(551), 1, + anon_sym_SEMI, + ACTIONS(549), 9, + 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(547), 11, + ts_builtin_sym_end, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_BANG, + [4589] = 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_as, + ACTIONS(626), 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, + [4988] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(630), 9, + 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(628), 11, + ts_builtin_sym_end, + sym_string, + sym_float, + sym_regex_literal, + anon_sym_LBRACE, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_GT_EQ, + anon_sym_LT_EQ, + anon_sym_DASH, + anon_sym_BANG, + [5016] = 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, + 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(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, + ACTIONS(3), 1, + sym_comment, + 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(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(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, + anon_sym_RPAREN, + [5363] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(653), 1, + sym_identifier, + ACTIONS(670), 1, + anon_sym_RBRACE, + STATE(222), 1, + sym_field_definition, + STATE(233), 1, + sym_field_path, + [5379] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(653), 1, + sym_identifier, + ACTIONS(672), 1, + anon_sym_RBRACE, + STATE(222), 1, + sym_field_definition, + STATE(233), 1, + sym_field_path, + [5395] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(674), 1, + anon_sym_SEMI, + ACTIONS(677), 1, + anon_sym_RBRACE, + STATE(191), 1, + aux_sym_match_expression_repeat1, + [5408] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(371), 1, + anon_sym_DOT, + ACTIONS(679), 1, + anon_sym_EQ, + STATE(202), 1, + aux_sym_field_path_repeat1, + [5421] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(681), 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, + ACTIONS(3), 1, + sym_comment, + ACTIONS(687), 1, + anon_sym_COMMA, + ACTIONS(690), 1, + anon_sym_RPAREN, + STATE(195), 1, + aux_sym_function_expression_repeat1, + [5460] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(681), 1, + sym_identifier, + ACTIONS(692), 1, + anon_sym_RPAREN, + STATE(224), 1, + sym_parameter, + [5473] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(694), 1, + anon_sym_COMMA, + ACTIONS(696), 1, + anon_sym_RPAREN, + STATE(195), 1, + aux_sym_function_expression_repeat1, + [5486] = 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, + anon_sym_DOT, + STATE(202), 1, + aux_sym_field_path_repeat1, + [5551] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(672), 1, + anon_sym_RBRACE, + ACTIONS(709), 1, + anon_sym_SEMI, + STATE(214), 1, + aux_sym_object_repeat1, + [5564] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(592), 1, + anon_sym_COLON, + ACTIONS(587), 2, + anon_sym_COMMA, + anon_sym_RPAREN, + [5575] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(711), 1, + anon_sym_COMMA, + ACTIONS(713), 1, + anon_sym_RPAREN, + STATE(216), 1, + aux_sym_function_expression_repeat1, + [5588] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(715), 1, + anon_sym_COMMA, + ACTIONS(717), 1, + anon_sym_RPAREN, + STATE(197), 1, + aux_sym_function_expression_repeat1, + [5601] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(117), 1, anon_sym_RBRACE, - ACTIONS(638), 1, + ACTIONS(719), 1, anon_sym_SEMI, - STATE(199), 1, + STATE(191), 1, aux_sym_match_expression_repeat1, - [8023] = 4, + [5614] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(629), 1, - anon_sym_RBRACE, - ACTIONS(640), 1, + ACTIONS(721), 1, anon_sym_SEMI, - STATE(196), 1, + ACTIONS(723), 1, + anon_sym_RBRACE, + STATE(217), 1, aux_sym_object_repeat1, - [8036] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(642), 1, - sym_identifier, - ACTIONS(644), 1, - anon_sym_RPAREN, - STATE(214), 1, - sym_parameter, - [8049] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(621), 1, - sym_identifier, - STATE(209), 1, - sym_field_definition, - STATE(228), 1, - sym_field_path, - [8062] = 4, + [5627] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(167), 1, anon_sym_RPAREN, - ACTIONS(646), 1, + ACTIONS(725), 1, anon_sym_COMMA, - STATE(180), 1, + STATE(188), 1, aux_sym_array_repeat1, - [8075] = 4, + [5640] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(648), 1, + ACTIONS(371), 1, + anon_sym_DOT, + ACTIONS(727), 1, + anon_sym_EQ, + STATE(192), 1, + aux_sym_field_path_repeat1, + [5653] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(729), 1, anon_sym_SEMI, - ACTIONS(650), 1, + ACTIONS(731), 1, anon_sym_RBRACE, - STATE(181), 1, + STATE(207), 1, aux_sym_match_expression_repeat1, - [8088] = 4, + [5666] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(652), 1, - anon_sym_COMMA, - ACTIONS(655), 1, - anon_sym_RPAREN, - STATE(187), 1, - aux_sym_function_expression_repeat1, - [8101] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(642), 1, - sym_identifier, - ACTIONS(657), 1, - anon_sym_RPAREN, - STATE(214), 1, - sym_parameter, - [8114] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(642), 1, - sym_identifier, - ACTIONS(659), 1, - anon_sym_RPAREN, - STATE(214), 1, - sym_parameter, - [8127] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(661), 1, + ACTIONS(733), 1, anon_sym_SEMI, - ACTIONS(663), 1, + ACTIONS(735), 1, anon_sym_RBRACE, - STATE(182), 1, - aux_sym_object_repeat1, - [8140] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(665), 1, - anon_sym_COMMA, - ACTIONS(667), 1, - anon_sym_RPAREN, STATE(203), 1, - aux_sym_function_expression_repeat1, - [8153] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(568), 1, - anon_sym_COLON, - ACTIONS(563), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - [8164] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(642), 1, - sym_identifier, - ACTIONS(669), 1, - anon_sym_RPAREN, - STATE(214), 1, - sym_parameter, - [8177] = 4, + aux_sym_object_repeat1, + [5679] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(153), 1, anon_sym_RBRACK, - ACTIONS(671), 1, + ACTIONS(737), 1, anon_sym_COMMA, - STATE(180), 1, + STATE(188), 1, aux_sym_array_repeat1, - [8190] = 4, + [5692] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(119), 1, - anon_sym_RBRACE, - ACTIONS(673), 1, + ACTIONS(739), 1, anon_sym_SEMI, - STATE(199), 1, - aux_sym_match_expression_repeat1, - [8203] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(675), 1, - anon_sym_SEMI, - ACTIONS(678), 1, - anon_sym_RBRACE, - STATE(196), 1, - aux_sym_object_repeat1, - [8216] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(155), 1, - anon_sym_RPAREN, - ACTIONS(680), 1, - anon_sym_COMMA, - STATE(180), 1, - aux_sym_array_repeat1, - [8229] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(682), 1, - anon_sym_SEMI, - ACTIONS(684), 1, - anon_sym_RBRACE, - STATE(195), 1, - aux_sym_match_expression_repeat1, - [8242] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(686), 1, - anon_sym_SEMI, - ACTIONS(689), 1, - anon_sym_RBRACE, - STATE(199), 1, - aux_sym_match_expression_repeat1, - [8255] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(691), 1, - anon_sym_SEMI, - ACTIONS(693), 1, - anon_sym_RBRACE, - STATE(206), 1, - aux_sym_object_repeat1, - [8268] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(695), 1, - anon_sym_EQ, - ACTIONS(697), 1, - anon_sym_DOT, - STATE(201), 1, - aux_sym_field_path_repeat1, - [8281] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(659), 1, - anon_sym_RPAREN, - ACTIONS(700), 1, - anon_sym_COMMA, - STATE(187), 1, - aux_sym_function_expression_repeat1, - [8294] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(644), 1, - anon_sym_RPAREN, - ACTIONS(702), 1, - anon_sym_COMMA, - STATE(187), 1, - aux_sym_function_expression_repeat1, - [8307] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(355), 1, - anon_sym_DOT, - ACTIONS(704), 1, - anon_sym_EQ, - STATE(208), 1, - aux_sym_field_path_repeat1, - [8320] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(706), 1, - anon_sym_COMMA, - ACTIONS(708), 1, - anon_sym_RPAREN, - STATE(202), 1, - aux_sym_function_expression_repeat1, - [8333] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(625), 1, - anon_sym_RBRACE, - ACTIONS(710), 1, - anon_sym_SEMI, - STATE(196), 1, - aux_sym_object_repeat1, - [8346] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(159), 1, - anon_sym_RBRACK, - ACTIONS(712), 1, - anon_sym_COMMA, - STATE(180), 1, - aux_sym_array_repeat1, - [8359] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(355), 1, - anon_sym_DOT, - ACTIONS(714), 1, - anon_sym_EQ, - STATE(201), 1, - aux_sym_field_path_repeat1, - [8372] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(678), 2, - anon_sym_SEMI, - anon_sym_RBRACE, - [8380] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(695), 2, - anon_sym_EQ, - anon_sym_DOT, - [8388] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(609), 2, - sym_identifier, - anon_sym_in, - [8396] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(642), 1, - sym_identifier, - STATE(214), 1, - sym_parameter, - [8406] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(689), 2, - anon_sym_SEMI, - anon_sym_RBRACE, - [8414] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(655), 2, - anon_sym_COMMA, - anon_sym_RPAREN, - [8422] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(716), 1, - sym_string, - [8429] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(718), 1, - anon_sym_RBRACK, - [8436] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(720), 1, - anon_sym_EQ, - [8443] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(722), 1, - anon_sym_EQ_GT, - [8450] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(724), 1, - anon_sym_EQ_GT, - [8457] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(726), 1, - anon_sym_EQ_GT, - [8464] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(728), 1, - sym_identifier, - [8471] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(730), 1, - anon_sym_EQ_GT, - [8478] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(732), 1, - anon_sym_EQ_GT, - [8485] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(734), 1, - sym_identifier, - [8492] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(736), 1, - ts_builtin_sym_end, - [8499] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(738), 1, - sym_string, - [8506] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(740), 1, - anon_sym_SEMI, - [8513] = 2, - ACTIONS(3), 1, - sym_comment, ACTIONS(742), 1, - anon_sym_EQ, - [8520] = 2, + anon_sym_RBRACE, + 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_RBRACK, - [8527] = 2, - ACTIONS(3), 1, - sym_comment, + anon_sym_RPAREN, ACTIONS(746), 1, - anon_sym_EQ_GT, - [8534] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(598), 1, - anon_sym_COLON, - [8541] = 2, + 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_EQ_GT, - [8548] = 2, + anon_sym_SEMI, + STATE(214), 1, + aux_sym_object_repeat1, + [5744] = 4, ACTIONS(3), 1, sym_comment, + ACTIONS(155), 1, + anon_sym_RBRACK, ACTIONS(750), 1, + anon_sym_COMMA, + STATE(188), 1, + aux_sym_array_repeat1, + [5757] = 2, + 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, - [8555] = 2, + 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, + anon_sym_COMMA, + anon_sym_RPAREN, + [5807] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(752), 1, anon_sym_EQ_GT, + [5814] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(754), 1, + anon_sym_RBRACK, + [5821] = 2, + 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, + anon_sym_SEMI, + [5856] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(764), 1, + anon_sym_EQ_GT, + [5863] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(766), 1, + anon_sym_EQ, + [5870] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(768), 1, + sym_identifier, + [5877] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(770), 1, + anon_sym_EQ, + [5884] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(772), 1, + sym_identifier, + [5891] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(774), 1, + ts_builtin_sym_end, + [5898] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(776), 1, + sym_string, + [5905] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(778), 1, + sym_string, + [5912] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(780), 1, + anon_sym_EQ_GT, + [5919] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(782), 1, + anon_sym_EQ_GT, + [5926] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(784), 1, + anon_sym_EQ_GT, + [5933] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(786), 1, + sym_identifier, + [5940] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(788), 1, + anon_sym_EQ_GT, }; static const uint32_t ts_small_parse_table_map[] = { - [SMALL_STATE(25)] = 0, - [SMALL_STATE(26)] = 72, - [SMALL_STATE(27)] = 144, - [SMALL_STATE(28)] = 216, - [SMALL_STATE(29)] = 288, - [SMALL_STATE(30)] = 360, - [SMALL_STATE(31)] = 432, - [SMALL_STATE(32)] = 504, - [SMALL_STATE(33)] = 576, - [SMALL_STATE(34)] = 648, - [SMALL_STATE(35)] = 720, - [SMALL_STATE(36)] = 792, - [SMALL_STATE(37)] = 864, - [SMALL_STATE(38)] = 936, - [SMALL_STATE(39)] = 1008, - [SMALL_STATE(40)] = 1080, - [SMALL_STATE(41)] = 1152, - [SMALL_STATE(42)] = 1224, - [SMALL_STATE(43)] = 1296, - [SMALL_STATE(44)] = 1368, - [SMALL_STATE(45)] = 1440, - [SMALL_STATE(46)] = 1512, - [SMALL_STATE(47)] = 1584, - [SMALL_STATE(48)] = 1656, - [SMALL_STATE(49)] = 1728, - [SMALL_STATE(50)] = 1800, - [SMALL_STATE(51)] = 1872, - [SMALL_STATE(52)] = 1944, - [SMALL_STATE(53)] = 2016, - [SMALL_STATE(54)] = 2088, - [SMALL_STATE(55)] = 2160, - [SMALL_STATE(56)] = 2232, - [SMALL_STATE(57)] = 2304, - [SMALL_STATE(58)] = 2376, - [SMALL_STATE(59)] = 2448, - [SMALL_STATE(60)] = 2520, - [SMALL_STATE(61)] = 2592, - [SMALL_STATE(62)] = 2664, - [SMALL_STATE(63)] = 2736, - [SMALL_STATE(64)] = 2808, - [SMALL_STATE(65)] = 2880, - [SMALL_STATE(66)] = 2952, - [SMALL_STATE(67)] = 3024, - [SMALL_STATE(68)] = 3096, - [SMALL_STATE(69)] = 3145, - [SMALL_STATE(70)] = 3214, - [SMALL_STATE(71)] = 3255, - [SMALL_STATE(72)] = 3296, - [SMALL_STATE(73)] = 3367, - [SMALL_STATE(74)] = 3408, - [SMALL_STATE(75)] = 3477, - [SMALL_STATE(76)] = 3518, - [SMALL_STATE(77)] = 3563, - [SMALL_STATE(78)] = 3604, - [SMALL_STATE(79)] = 3645, - [SMALL_STATE(80)] = 3690, - [SMALL_STATE(81)] = 3745, - [SMALL_STATE(82)] = 3794, - [SMALL_STATE(83)] = 3855, - [SMALL_STATE(84)] = 3914, - [SMALL_STATE(85)] = 3967, - [SMALL_STATE(86)] = 4012, - [SMALL_STATE(87)] = 4075, - [SMALL_STATE(88)] = 4140, - [SMALL_STATE(89)] = 4209, - [SMALL_STATE(90)] = 4278, - [SMALL_STATE(91)] = 4319, - [SMALL_STATE(92)] = 4360, - [SMALL_STATE(93)] = 4401, - [SMALL_STATE(94)] = 4442, - [SMALL_STATE(95)] = 4511, - [SMALL_STATE(96)] = 4552, - [SMALL_STATE(97)] = 4593, - [SMALL_STATE(98)] = 4634, - [SMALL_STATE(99)] = 4675, - [SMALL_STATE(100)] = 4744, - [SMALL_STATE(101)] = 4813, - [SMALL_STATE(102)] = 4882, - [SMALL_STATE(103)] = 4923, - [SMALL_STATE(104)] = 4964, - [SMALL_STATE(105)] = 5005, - [SMALL_STATE(106)] = 5046, - [SMALL_STATE(107)] = 5087, - [SMALL_STATE(108)] = 5128, - [SMALL_STATE(109)] = 5169, - [SMALL_STATE(110)] = 5210, - [SMALL_STATE(111)] = 5251, - [SMALL_STATE(112)] = 5284, - [SMALL_STATE(113)] = 5343, - [SMALL_STATE(114)] = 5376, - [SMALL_STATE(115)] = 5409, - [SMALL_STATE(116)] = 5462, - [SMALL_STATE(117)] = 5495, - [SMALL_STATE(118)] = 5528, - [SMALL_STATE(119)] = 5569, - [SMALL_STATE(120)] = 5628, - [SMALL_STATE(121)] = 5687, - [SMALL_STATE(122)] = 5720, - [SMALL_STATE(123)] = 5779, - [SMALL_STATE(124)] = 5812, - [SMALL_STATE(125)] = 5871, - [SMALL_STATE(126)] = 5904, - [SMALL_STATE(127)] = 5951, - [SMALL_STATE(128)] = 5984, - [SMALL_STATE(129)] = 6017, - [SMALL_STATE(130)] = 6050, - [SMALL_STATE(131)] = 6083, - [SMALL_STATE(132)] = 6116, - [SMALL_STATE(133)] = 6149, - [SMALL_STATE(134)] = 6182, - [SMALL_STATE(135)] = 6241, - [SMALL_STATE(136)] = 6292, - [SMALL_STATE(137)] = 6325, - [SMALL_STATE(138)] = 6358, - [SMALL_STATE(139)] = 6417, - [SMALL_STATE(140)] = 6450, - [SMALL_STATE(141)] = 6483, - [SMALL_STATE(142)] = 6516, - [SMALL_STATE(143)] = 6571, - [SMALL_STATE(144)] = 6604, - [SMALL_STATE(145)] = 6641, - [SMALL_STATE(146)] = 6678, - [SMALL_STATE(147)] = 6733, - [SMALL_STATE(148)] = 6766, - [SMALL_STATE(149)] = 6799, - [SMALL_STATE(150)] = 6844, - [SMALL_STATE(151)] = 6881, - [SMALL_STATE(152)] = 6940, - [SMALL_STATE(153)] = 6999, - [SMALL_STATE(154)] = 7034, - [SMALL_STATE(155)] = 7093, - [SMALL_STATE(156)] = 7148, - [SMALL_STATE(157)] = 7207, - [SMALL_STATE(158)] = 7238, - [SMALL_STATE(159)] = 7294, - [SMALL_STATE(160)] = 7322, - [SMALL_STATE(161)] = 7376, - [SMALL_STATE(162)] = 7430, - [SMALL_STATE(163)] = 7484, - [SMALL_STATE(164)] = 7540, - [SMALL_STATE(165)] = 7593, - [SMALL_STATE(166)] = 7646, - [SMALL_STATE(167)] = 7699, - [SMALL_STATE(168)] = 7752, - [SMALL_STATE(169)] = 7805, - [SMALL_STATE(170)] = 7824, - [SMALL_STATE(171)] = 7843, - [SMALL_STATE(172)] = 7862, - [SMALL_STATE(173)] = 7881, - [SMALL_STATE(174)] = 7900, - [SMALL_STATE(175)] = 7916, - [SMALL_STATE(176)] = 7932, - [SMALL_STATE(177)] = 7948, - [SMALL_STATE(178)] = 7964, - [SMALL_STATE(179)] = 7980, - [SMALL_STATE(180)] = 7996, - [SMALL_STATE(181)] = 8010, - [SMALL_STATE(182)] = 8023, - [SMALL_STATE(183)] = 8036, - [SMALL_STATE(184)] = 8049, - [SMALL_STATE(185)] = 8062, - [SMALL_STATE(186)] = 8075, - [SMALL_STATE(187)] = 8088, - [SMALL_STATE(188)] = 8101, - [SMALL_STATE(189)] = 8114, - [SMALL_STATE(190)] = 8127, - [SMALL_STATE(191)] = 8140, - [SMALL_STATE(192)] = 8153, - [SMALL_STATE(193)] = 8164, - [SMALL_STATE(194)] = 8177, - [SMALL_STATE(195)] = 8190, - [SMALL_STATE(196)] = 8203, - [SMALL_STATE(197)] = 8216, - [SMALL_STATE(198)] = 8229, - [SMALL_STATE(199)] = 8242, - [SMALL_STATE(200)] = 8255, - [SMALL_STATE(201)] = 8268, - [SMALL_STATE(202)] = 8281, - [SMALL_STATE(203)] = 8294, - [SMALL_STATE(204)] = 8307, - [SMALL_STATE(205)] = 8320, - [SMALL_STATE(206)] = 8333, - [SMALL_STATE(207)] = 8346, - [SMALL_STATE(208)] = 8359, - [SMALL_STATE(209)] = 8372, - [SMALL_STATE(210)] = 8380, - [SMALL_STATE(211)] = 8388, - [SMALL_STATE(212)] = 8396, - [SMALL_STATE(213)] = 8406, - [SMALL_STATE(214)] = 8414, - [SMALL_STATE(215)] = 8422, - [SMALL_STATE(216)] = 8429, - [SMALL_STATE(217)] = 8436, - [SMALL_STATE(218)] = 8443, - [SMALL_STATE(219)] = 8450, - [SMALL_STATE(220)] = 8457, - [SMALL_STATE(221)] = 8464, - [SMALL_STATE(222)] = 8471, - [SMALL_STATE(223)] = 8478, - [SMALL_STATE(224)] = 8485, - [SMALL_STATE(225)] = 8492, - [SMALL_STATE(226)] = 8499, - [SMALL_STATE(227)] = 8506, - [SMALL_STATE(228)] = 8513, - [SMALL_STATE(229)] = 8520, - [SMALL_STATE(230)] = 8527, - [SMALL_STATE(231)] = 8534, - [SMALL_STATE(232)] = 8541, - [SMALL_STATE(233)] = 8548, - [SMALL_STATE(234)] = 8555, + [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, }; static const TSParseActionEntry ts_parse_actions[] = { @@ -9575,369 +9586,387 @@ 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(68), - [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(105), - [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(71), - [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), - [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(171), + [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), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(181), [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), - [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(66), - [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(226), - [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), - [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [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), [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(68), - [42] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(105), - [45] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(71), - [48] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(71), - [51] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(72), - [54] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(179), - [57] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(12), - [60] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(171), + [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), + [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), + [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), [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(66), - [69] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(226), - [72] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(60), - [75] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(60), - [78] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_source_file_repeat1, 2, 0, 0), SHIFT_REPEAT(58), - [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(165), - [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(136), - [85] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(137), - [89] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), - [91] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [93] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [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), [95] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(173), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(183), [99] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), - [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(39), - [103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), - [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(215), - [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(52), - [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), - [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), - [113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), - [121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(153), - [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(156), - [131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), - [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), - [139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), - [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(154), - [143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(155), - [151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), - [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [161] = {.entry = {.count = 1, .reusable = false}}, SHIFT(152), - [163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), - [171] = {.entry = {.count = 1, .reusable = false}}, SHIFT(151), - [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), - [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), - [181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(135), - [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(86), - [187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [189] = {.entry = {.count = 1, .reusable = false}}, SHIFT(122), - [191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(160), - [195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), - [197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112), - [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(142), - [203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(146), - [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), - [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(150), - [211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [213] = {.entry = {.count = 1, .reusable = false}}, SHIFT(149), - [215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [217] = {.entry = {.count = 1, .reusable = false}}, SHIFT(115), - [219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [221] = {.entry = {.count = 1, .reusable = false}}, SHIFT(118), - [223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [225] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), - [227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [229] = {.entry = {.count = 1, .reusable = false}}, SHIFT(138), - [231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [233] = {.entry = {.count = 1, .reusable = false}}, SHIFT(168), - [235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), - [237] = {.entry = {.count = 1, .reusable = false}}, SHIFT(80), - [239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [241] = {.entry = {.count = 1, .reusable = false}}, SHIFT(81), - [243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [245] = {.entry = {.count = 1, .reusable = false}}, SHIFT(82), - [247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [249] = {.entry = {.count = 1, .reusable = false}}, SHIFT(83), - [251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [253] = {.entry = {.count = 1, .reusable = false}}, SHIFT(84), - [255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [257] = {.entry = {.count = 1, .reusable = false}}, SHIFT(85), - [259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [261] = {.entry = {.count = 1, .reusable = false}}, SHIFT(74), - [263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [265] = {.entry = {.count = 1, .reusable = false}}, SHIFT(87), - [267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [269] = {.entry = {.count = 1, .reusable = false}}, SHIFT(88), - [271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [273] = {.entry = {.count = 1, .reusable = false}}, SHIFT(89), - [275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [277] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), - [279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), - [281] = {.entry = {.count = 1, .reusable = false}}, SHIFT(145), - [283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [285] = {.entry = {.count = 1, .reusable = false}}, SHIFT(144), - [287] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [289] = {.entry = {.count = 1, .reusable = false}}, SHIFT(163), - [291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [293] = {.entry = {.count = 1, .reusable = false}}, SHIFT(119), - [295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), - [297] = {.entry = {.count = 1, .reusable = false}}, SHIFT(94), - [299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [301] = {.entry = {.count = 1, .reusable = false}}, SHIFT(124), - [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), - [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(134), - [307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [309] = {.entry = {.count = 1, .reusable = false}}, SHIFT(79), - [311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [313] = {.entry = {.count = 1, .reusable = false}}, SHIFT(162), - [315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), - [317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(76), - [319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [321] = {.entry = {.count = 1, .reusable = false}}, SHIFT(69), - [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(99), - [327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [329] = {.entry = {.count = 1, .reusable = false}}, SHIFT(100), - [331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [333] = {.entry = {.count = 1, .reusable = false}}, SHIFT(161), - [335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), - [337] = {.entry = {.count = 1, .reusable = false}}, SHIFT(101), - [339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), - [341] = {.entry = {.count = 1, .reusable = false}}, SHIFT(167), - [343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), - [345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(158), - [347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [349] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), - [351] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 1, 0, 0), - [353] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_path, 1, 0, 0), - [355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), - [357] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 5, 0, 15), - [359] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 5, 0, 15), - [361] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), - [363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [365] = {.entry = {.count = 1, .reusable = false}}, SHIFT(40), - [367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(41), - [379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(45), - [383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(26), - [385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(48), - [389] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4, 0, 7), - [391] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4, 0, 7), - [393] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_literal, 1, 0, 0), - [395] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_literal, 1, 0, 0), - [397] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1, 0, 0), - [399] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1, 0, 0), - [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), - [403] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), - [405] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 0), - [407] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_expression, 3, 0, 5), - [409] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_expression, 3, 0, 5), - [411] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_import_expression, 2, 0, 2), - [413] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_import_expression, 2, 0, 2), - [415] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_constraint, 2, 0, 3), - [417] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_constraint, 2, 0, 3), - [419] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_path_expression, 3, 0, 6), - [421] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_path_expression, 3, 0, 6), - [423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3, 0, 7), - [425] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3, 0, 7), - [427] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, 0, 4), - [429] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, 0, 4), - [431] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_expression, 3, 0, 8), - [433] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_expression, 3, 0, 8), - [435] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_default_expression, 3, 0, 9), - [437] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_default_expression, 3, 0, 9), - [439] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 3, 0, 10), - [441] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_definition, 3, 0, 10), - [443] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 4, 0, 0), - [445] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 4, 0, 0), - [447] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 3, 0, 0), - [449] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 3, 0, 0), - [451] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 2, 0, 0), - [453] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 2, 0, 0), - [455] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 7, 0, 14), - [457] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 7, 0, 14), - [459] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 7, 0, 18), - [461] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 7, 0, 18), - [463] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_constraint, 4, 0, 11), - [465] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_constraint, 4, 0, 11), - [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 4, 0, 0), - [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 4, 0, 0), - [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 6, 0, 7), - [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 6, 0, 7), - [475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 6, 0, 14), - [477] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 6, 0, 14), - [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_let_expression, 4, 0, 12), - [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_let_expression, 4, 0, 12), - [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 6, 0, 16), - [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 6, 0, 16), - [487] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_expression, 4, 0, 12), - [489] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_expression, 4, 0, 12), - [491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 3, 0, 0), - [493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 3, 0, 0), - [495] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 5, 0, 7), - [497] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 5, 0, 7), - [499] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 5, 0, 14), - [501] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 5, 0, 14), - [503] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean, 1, 0, 0), - [505] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean, 1, 0, 0), - [507] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 5, 0, 0), - [509] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 5, 0, 0), - [511] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 4, 0, 14), - [513] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 4, 0, 14), - [515] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array, 2, 0, 0), - [517] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array, 2, 0, 0), - [519] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_constraint, 5, 0, 11), - [521] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_constraint, 5, 0, 11), - [523] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object, 5, 0, 0), - [525] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object, 5, 0, 0), - [527] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [529] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), - [531] = {.entry = {.count = 1, .reusable = false}}, SHIFT(37), - [533] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [539] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [541] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [543] = {.entry = {.count = 1, .reusable = false}}, SHIFT(36), - [545] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [547] = {.entry = {.count = 1, .reusable = false}}, SHIFT(32), - [549] = {.entry = {.count = 1, .reusable = false}}, SHIFT(31), - [551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), - [557] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), - [561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [563] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 1, 0, 1), - [565] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__expression, 1, 0, 0), REDUCE(sym_parameter, 1, 0, 1), - [568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), - [572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [574] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0), - [576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), - [578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), - [582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 2, 0, 0), - [586] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 2, 0, 0), - [588] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3, 0, 13), - [590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_arm, 3, 0, 17), - [592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), - [594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), - [600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [606] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_let_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(204), - [609] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_let_expression_repeat1, 2, 0, 0), - [611] = {.entry = {.count = 1, .reusable = false}}, SHIFT(204), - [613] = {.entry = {.count = 1, .reusable = false}}, SHIFT(27), - [615] = {.entry = {.count = 1, .reusable = false}}, SHIFT(46), - [617] = {.entry = {.count = 1, .reusable = false}}, SHIFT(62), - [619] = {.entry = {.count = 1, .reusable = false}}, SHIFT(38), - [621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), - [623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), - [625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), - [629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [633] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [635] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_repeat1, 2, 0, 0), SHIFT_REPEAT(34), - [638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), - [640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), - [644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), - [646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), - [650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), - [652] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(212), - [655] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_expression_repeat1, 2, 0, 0), - [657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), - [659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), - [661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), - [667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), - [669] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), - [671] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [675] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_object_repeat1, 2, 0, 0), SHIFT_REPEAT(184), - [678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_repeat1, 2, 0, 0), - [680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), - [684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), - [686] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(10), - [689] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_match_expression_repeat1, 2, 0, 0), - [691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [695] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_path_repeat1, 2, 0, 0), - [697] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_path_repeat1, 2, 0, 0), SHIFT_REPEAT(221), - [700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), - [702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [704] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_path, 1, 0, 0), - [706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), - [710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), - [712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), - [714] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_path, 2, 0, 0), - [716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), - [724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), - [730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [736] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), - [742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), - [750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [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), + [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), + [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), + [245] = {.entry = {.count = 1, .reusable = false}}, SHIFT(77), + [247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [249] = {.entry = {.count = 1, .reusable = false}}, SHIFT(78), + [251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [253] = {.entry = {.count = 1, .reusable = false}}, SHIFT(79), + [255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [257] = {.entry = {.count = 1, .reusable = false}}, SHIFT(80), + [259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [261] = {.entry = {.count = 1, .reusable = false}}, SHIFT(81), + [263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [265] = {.entry = {.count = 1, .reusable = false}}, SHIFT(82), + [267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [269] = {.entry = {.count = 1, .reusable = false}}, SHIFT(83), + [271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [273] = {.entry = {.count = 1, .reusable = false}}, SHIFT(84), + [275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [277] = {.entry = {.count = 1, .reusable = false}}, SHIFT(85), + [279] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [281] = {.entry = {.count = 1, .reusable = false}}, SHIFT(86), + [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), + [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), + [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), + [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), + [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), + [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), + [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), + [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), + [788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), }; #ifdef __cplusplus diff --git a/examples/map-ascription.dcdl b/examples/map-ascription.dcdl new file mode 100644 index 0000000..7823833 --- /dev/null +++ b/examples/map-ascription.dcdl @@ -0,0 +1,15 @@ +let + Service = { + port = Int & >= 1 & <= 65535; + enabled = Bool default true; + }; +in + { + api = { + port = 8080; + }; + worker = { + port = 8081; + enabled = false; + }; + } as {...Service} diff --git a/packages/decodal-codemirror/src/decodal-parser-jsr.js b/packages/decodal-codemirror/src/decodal-parser-jsr.js index df7b840..60a27de 100644 --- a/packages/decodal-codemirror/src/decodal-parser-jsr.js +++ b/packages/decodal-codemirror/src/decodal-parser-jsr.js @@ -1,16 +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} export const parser = LRParser.deserialize({ version: 14, - states: "8fQYQPOOO#nQPO'#CaOOQO'#Cr'#CrO$wQPO'#CyO&UQPO'#DOO&^QQO'#DXO&hQPO'#DYO&pQPO'#CqO$wQPO'#DeO&zQPO'#DjOOQO'#Cq'#CqOOQO'#Cp'#CpO'PQPO'#CoO$wQPO'#CoOOQO'#Cn'#CnO)iQPO'#CmO.[QPO'#ClO0`QPO'#CkOOQO'#Cj'#CjO2WQPO'#CiO3{QPO'#ChO5mQPO'#CgO7XQPO'#CfOOQO'#Ce'#CeO7cQPO'#C`O7hQPO'#C_OOQO'#D|'#D|QYQPOOO8{QPO'#D}O9QQPO,58{OOQO,59e,59eO9YQPO'#CaOOQO,59j,59jO9bQPO,59jO$wQPO,59nOOQO,59s,59sO9jQPO,59sO9rQPO'#EQO9wQPO'#D[O:PQPO,59tO:UQPO'#CqO:cQPO'#D`O:kQQO,59xO:pQPO,59xO:uQPO,59]O:zQPO,5:POOQO,5:U,5:UO;PQPO'#DlOOQO,59[,59[O;WQPO,59[OOQO,59Z,59ZO$wQPO,59YO$wQPO,59XO$wQPO,59WOOQO'#Dt'#DtO$wQPO,59VO$wQPO,59UO$wQPO,59TO$wQPO,59SO$wQPO,59RO$wQPO,59QO$wQPO,58zOOQO,58y,58yOOQO-E7z-E7zOOQO,5:i,5:iOOQO-E7{-E7{O;]QPO1G/UO;eQPO1G/UOOQO1G/U1G/UO;mQPO1G/YO;uQPO1G/_O;|QPO1G/_OOQO1G/_1G/_OOQO,5:l,5:lOOQO-E8O-E8OO$wQPO1G/`O$wQPO,59{O]AN>]OJuQPOAN>]OOQO-E8Q-E8QOOQOG23wG23wPQQPO1G/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, 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!y~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!b~!_!`%R~%WO!j~~%ZWOY%WZr%Wrs%ss#O%W#O#P%x#P;'S%W;'S;=`&t<%lO%W~%xOg~~%{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!m~vw'k~'pO!k~~'uO!R~~'zO!V~~(PO!d~~(UP!f~{|(X~(^O!g~~(cOy~~(hO!c~R(mPVP!O!P(pQ(sP!O!P(vQ({OxQ~)QW!e~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~*[Ol~~*_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!n~~+hQh~!O!P+n!Q![+c~+qP!Q![+t~+yPi~!Q![+t~,RO!U~~,WOt~~,]Pn~!_!`,`~,eOo~~,jQWP!_!`,p!`!a,u~,uO!i~Q,zO!WQ~-PPp~!_!`-S~-XOq~~-^SU~!Q![-X!c!}-X#R#S-X#T#o-X~-oOw~~-tOz~~-{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!o~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~3mSk~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!_~U~!Q![-X!c!}-X#R#S-X#T#o-X~7PS!P~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}~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!Y~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 }) diff --git a/packages/decodal-codemirror/src/decodal-parser.js b/packages/decodal-codemirror/src/decodal-parser.js index 92a0ce5..5b2f800 100644 --- a/packages/decodal-codemirror/src/decodal-parser.js +++ b/packages/decodal-codemirror/src/decodal-parser.js @@ -1,16 +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} export const parser = LRParser.deserialize({ version: 14, - states: "8fQYQPOOO#nQPO'#CaOOQO'#Cr'#CrO$wQPO'#CyO&UQPO'#DOO&^QQO'#DXO&hQPO'#DYO&pQPO'#CqO$wQPO'#DeO&zQPO'#DjOOQO'#Cq'#CqOOQO'#Cp'#CpO'PQPO'#CoO$wQPO'#CoOOQO'#Cn'#CnO)iQPO'#CmO.[QPO'#ClO0`QPO'#CkOOQO'#Cj'#CjO2WQPO'#CiO3{QPO'#ChO5mQPO'#CgO7XQPO'#CfOOQO'#Ce'#CeO7cQPO'#C`O7hQPO'#C_OOQO'#D|'#D|QYQPOOO8{QPO'#D}O9QQPO,58{OOQO,59e,59eO9YQPO'#CaOOQO,59j,59jO9bQPO,59jO$wQPO,59nOOQO,59s,59sO9jQPO,59sO9rQPO'#EQO9wQPO'#D[O:PQPO,59tO:UQPO'#CqO:cQPO'#D`O:kQQO,59xO:pQPO,59xO:uQPO,59]O:zQPO,5:POOQO,5:U,5:UO;PQPO'#DlOOQO,59[,59[O;WQPO,59[OOQO,59Z,59ZO$wQPO,59YO$wQPO,59XO$wQPO,59WOOQO'#Dt'#DtO$wQPO,59VO$wQPO,59UO$wQPO,59TO$wQPO,59SO$wQPO,59RO$wQPO,59QO$wQPO,58zOOQO,58y,58yOOQO-E7z-E7zOOQO,5:i,5:iOOQO-E7{-E7{O;]QPO1G/UO;eQPO1G/UOOQO1G/U1G/UO;mQPO1G/YO;uQPO1G/_O;|QPO1G/_OOQO1G/_1G/_OOQO,5:l,5:lOOQO-E8O-E8OO$wQPO1G/`O$wQPO,59{O]AN>]OJuQPOAN>]OOQO-E8Q-E8QOOQOG23wG23wPQQPO1G/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, 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!y~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!b~!_!`%R~%WO!j~~%ZWOY%WZr%Wrs%ss#O%W#O#P%x#P;'S%W;'S;=`&t<%lO%W~%xOg~~%{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!m~vw'k~'pO!k~~'uO!R~~'zO!V~~(PO!d~~(UP!f~{|(X~(^O!g~~(cOy~~(hO!c~R(mPVP!O!P(pQ(sP!O!P(vQ({OxQ~)QW!e~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~*[Ol~~*_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!n~~+hQh~!O!P+n!Q![+c~+qP!Q![+t~+yPi~!Q![+t~,RO!U~~,WOt~~,]Pn~!_!`,`~,eOo~~,jQWP!_!`,p!`!a,u~,uO!i~Q,zO!WQ~-PPp~!_!`-S~-XOq~~-^SU~!Q![-X!c!}-X#R#S-X#T#o-X~-oOw~~-tOz~~-{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!o~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~3mSk~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!_~U~!Q![-X!c!}-X#R#S-X#T#o-X~7PS!P~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}~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!Y~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 }) diff --git a/packages/decodal-codemirror/src/decodal-parser.terms.js b/packages/decodal-codemirror/src/decodal-parser.terms.js index ac2c5d8..1d20889 100644 --- a/packages/decodal-codemirror/src/decodal-parser.terms.js +++ b/packages/decodal-codemirror/src/decodal-parser.terms.js @@ -9,71 +9,74 @@ export const Dot = 7, Equal = 8, Expression = 9, - DefaultExpression = 10, - PatchExpression = 11, - ComposeExpression = 12, - LogicalOrExpression = 13, - LogicalAndExpression = 14, - ComparisonExpression = 15, - ConcatExpression = 16, - AdditiveExpression = 17, - MultiplicativeExpression = 18, - UnaryExpression = 19, - PostfixExpression = 20, - PrimaryExpression = 21, - Literal = 22, - String = 23, - Integer = 24, - Float = 25, - True = 26, - False = 27, - Regex = 28, - ComparisonConstraint = 29, - Lt = 30, - Lte = 31, - Gt = 32, - Gte = 33, - Object = 34, - LBrace = 35, - Semicolon = 36, - RBrace = 37, - ArrayConstraint = 38, - LBracket = 39, - Ellipsis = 40, - Comma = 41, - RBracket = 42, - Array = 43, - LetExpression = 44, - Let = 45, - FieldDefinitionList = 46, - In = 47, - FunctionExpression = 48, - LParen = 49, - ParameterList = 50, - Parameter = 51, - Colon = 52, - RParen = 53, - Arrow = 54, - MatchExpression = 55, - Match = 56, - MatchArm = 57, - Pattern = 58, - Underscore = 59, - ImportExpression = 60, - Import = 61, - CallSuffix = 62, - ArgumentList = 63, - Bang = 64, - Minus = 65, - Star = 66, - Slash = 67, - Plus = 68, - PlusPlus = 69, - CompareOperator = 70, - EqualEqual = 71, - BangEqual = 72, - AmpAmp = 73, - PipePipe = 74, - Amp = 75, - SlashSlash = 76, - Default = 77 + AsExpression = 10, + DefaultExpression = 11, + PatchExpression = 12, + ComposeExpression = 13, + LogicalOrExpression = 14, + LogicalAndExpression = 15, + ComparisonExpression = 16, + ConcatExpression = 17, + AdditiveExpression = 18, + MultiplicativeExpression = 19, + UnaryExpression = 20, + PostfixExpression = 21, + PrimaryExpression = 22, + Literal = 23, + String = 24, + Integer = 25, + Float = 26, + True = 27, + False = 28, + Regex = 29, + ComparisonConstraint = 30, + Lt = 31, + Lte = 32, + Gt = 33, + Gte = 34, + MapConstraint = 35, + LBrace = 36, + Ellipsis = 37, + 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 diff --git a/packages/decodal-codemirror/src/decodal.js b/packages/decodal-codemirror/src/decodal.js index 37107bf..fb75f34 100644 --- a/packages/decodal-codemirror/src/decodal.js +++ b/packages/decodal-codemirror/src/decodal.js @@ -5,7 +5,7 @@ import { parser } from './decodal-parser.js'; const parserWithMetadata = parser.configure({ props: [ styleTags({ - 'Let In Match Import Default': t.keyword, + 'Let In Match Import Default As': t.keyword, 'True False': t.bool, Identifier: t.variableName, String: t.string, @@ -20,6 +20,7 @@ const parserWithMetadata = parser.configure({ }), indentNodeProp.add({ Object: delimitedIndent({ closing: '}', align: false }), + MapConstraint: delimitedIndent({ closing: '}', align: false }), Array: delimitedIndent({ closing: ']', align: false }), ArrayConstraint: delimitedIndent({ closing: ']', align: false }), MatchExpression: delimitedIndent({ closing: '}', align: false }), @@ -27,6 +28,7 @@ const parserWithMetadata = parser.configure({ }), foldNodeProp.add({ Object: foldDelimited('{', '}'), + MapConstraint: foldDelimited('{', '}'), Array: foldDelimited('[', ']'), ArrayConstraint: foldDelimited('[', ']'), MatchExpression: foldDelimited('{', '}'), diff --git a/packages/decodal-codemirror/src/decodal.test.mjs b/packages/decodal-codemirror/src/decodal.test.mjs index d315f6c..12284bc 100644 --- a/packages/decodal-codemirror/src/decodal.test.mjs +++ b/packages/decodal-codemirror/src/decodal.test.mjs @@ -5,6 +5,16 @@ import { getIndentation, indentUnit } from '@codemirror/language'; import { EditorState } from '@codemirror/state'; import { decodal } from './decodal.js'; +import { parser } from './decodal-parser.js'; + +function parseErrors(source) { + const errors = []; + const cursor = parser.parse(source).cursor(); + do { + if (cursor.type.isError) errors.push({ from: cursor.from, to: cursor.to }); + } while (cursor.next()); + return errors; +} function indentationAt(doc, lineNumber) { const state = EditorState.create({ @@ -33,3 +43,15 @@ test('preserves the surrounding indentation for a nested inline object', () => { assert.equal(indentationAt(doc, 3), 4); assert.equal(indentationAt(doc, 4), 2); }); + +test('parses map constraints and range refinement', () => { + const source = `services = { + api = { port = 8080; }; +} as {...{ port = Int; }};`; + + 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/src/mod.ts b/packages/decodal-codemirror/src/mod.ts index 6ca1b04..7bb198a 100644 --- a/packages/decodal-codemirror/src/mod.ts +++ b/packages/decodal-codemirror/src/mod.ts @@ -15,7 +15,7 @@ import { parser } from './decodal-parser-jsr.js'; const parserWithMetadata = parser.configure({ props: [ styleTags({ - 'Let In Match Import Default': t.keyword, + 'Let In Match Import Default As': t.keyword, 'True False': t.bool, Identifier: t.variableName, String: t.string, @@ -30,6 +30,7 @@ const parserWithMetadata = parser.configure({ }), indentNodeProp.add({ Object: delimitedIndent({ closing: '}', align: false }), + MapConstraint: delimitedIndent({ closing: '}', align: false }), Array: delimitedIndent({ closing: ']', align: false }), ArrayConstraint: delimitedIndent({ closing: ']', align: false }), MatchExpression: delimitedIndent({ closing: '}', align: false }), @@ -37,6 +38,7 @@ const parserWithMetadata = parser.configure({ }), foldNodeProp.add({ Object: foldDelimited('{', '}'), + MapConstraint: foldDelimited('{', '}'), Array: foldDelimited('[', ']'), ArrayConstraint: foldDelimited('[', ']'), MatchExpression: foldDelimited('{', '}'), diff --git a/packages/decodal-codemirror/wasm/decodal_language_tools_bg.wasm b/packages/decodal-codemirror/wasm/decodal_language_tools_bg.wasm index 7e26e8a..3549d43 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 d2fbf0e..bb20a29 100644 --- a/packages/decodal-wasm/README.md +++ b/packages/decodal-wasm/README.md @@ -28,7 +28,7 @@ await init(); const files = { 'main.dcdl': 'let schema = import "./schema.dcdl"; in schema.Server', - 'schema.dcdl': 'Server = App.Server & { port = 8080; };', + 'schema.dcdl': 'Server = { port = 8080; } as App.Server;', }; const service = new DecodalLanguageService({ @@ -64,6 +64,6 @@ 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 and `{ $decodal: 'Array', item: value }` for array schemas. Descriptors also accept `constraints` and `default`. +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`. 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 d691d47..3cd83ce 100644 --- a/packages/decodal-wasm/decodal_wasm.d.ts +++ b/packages/decodal-wasm/decodal_wasm.d.ts @@ -10,6 +10,7 @@ export type DecodalHostValue = | { [field: string]: DecodalHostValue } | DecodalPrimitiveDescriptor | DecodalArrayDescriptor + | DecodalMapDescriptor | DecodalAbstractDescriptor; export type DecodalPrimitiveType = 'String' | 'Int' | 'Float' | 'Bool'; @@ -33,6 +34,13 @@ export interface DecodalArrayDescriptor { default?: DecodalHostValue; } +export interface DecodalMapDescriptor { + $decodal: 'Map'; + value: DecodalHostValue; + constraints?: DecodalConstraint[]; + default?: DecodalHostValue; +} + export interface DecodalAbstractDescriptor { $decodal: 'Abstract'; constraints?: DecodalConstraint[]; diff --git a/packages/decodal-wasm/decodal_wasm_bg.wasm b/packages/decodal-wasm/decodal_wasm_bg.wasm index 5e9fd14..a774ea9 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 cf50ca8..7f4e66d 100644 --- a/packages/decodal-wasm/mod.ts +++ b/packages/decodal-wasm/mod.ts @@ -13,6 +13,7 @@ export { export type { DecodalAbstractDescriptor, DecodalArrayDescriptor, + DecodalMapDescriptor, DecodalConstraint, DecodalEnvironment, DecodalHostValue, diff --git a/site/decodal-site/scripts/prepare-wasm-package.mjs b/site/decodal-site/scripts/prepare-wasm-package.mjs index fd70b05..2116abb 100644 --- a/site/decodal-site/scripts/prepare-wasm-package.mjs +++ b/site/decodal-site/scripts/prepare-wasm-package.mjs @@ -18,6 +18,7 @@ export type DecodalHostValue = | { [field: string]: DecodalHostValue } | DecodalPrimitiveDescriptor | DecodalArrayDescriptor + | DecodalMapDescriptor | DecodalAbstractDescriptor; export type DecodalPrimitiveType = 'String' | 'Int' | 'Float' | 'Bool'; @@ -41,6 +42,13 @@ export interface DecodalArrayDescriptor { default?: DecodalHostValue; } +export interface DecodalMapDescriptor { + $decodal: 'Map'; + value: DecodalHostValue; + constraints?: DecodalConstraint[]; + default?: DecodalHostValue; +} + export interface DecodalAbstractDescriptor { $decodal: 'Abstract'; constraints?: DecodalConstraint[]; @@ -131,7 +139,7 @@ await init(); const files = { 'main.dcdl': 'let schema = import "./schema.dcdl"; in schema.Server', - 'schema.dcdl': 'Server = App.Server & { port = 8080; };', + 'schema.dcdl': 'Server = { port = 8080; } as App.Server;', }; const service = new DecodalLanguageService({ @@ -167,7 +175,7 @@ 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 and \`{ $decodal: 'Array', item: value }\` for array schemas. Descriptors also accept \`constraints\` and \`default\`. +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\`. 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/scripts/playground-runtime.test.mjs b/site/decodal-site/src/scripts/playground-runtime.test.mjs index ecb1965..93cbeae 100644 --- a/site/decodal-site/src/scripts/playground-runtime.test.mjs +++ b/site/decodal-site/src/scripts/playground-runtime.test.mjs @@ -15,6 +15,13 @@ test('injects one JavaScript host environment into evaluation and completion', a globals: { App: { enabled: { $decodal: 'Bool', default: true }, + Services: { + $decodal: 'Map', + value: { + port: { $decodal: 'Int' }, + active: { $decodal: 'Bool', default: true }, + }, + }, }, }, loadImport(_currentKey, specifier) { @@ -39,10 +46,11 @@ 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 = s.Server & { port = 8080; }; enabled = App.enabled; post = import "./post.md"; }', + '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; }; }', )); assert.equal(evaluated.ok, true, evaluated.error); assert.match(evaluated.output, /"port": 8080/); + assert.match(evaluated.output, /"active": true/); assert.match(evaluated.output, /"body": "# Hello"/); const member = JSON.parse(service.complete('main.dcdl', 'App.en', 6, false));