diff --git a/bindings/csharp/Expressif.Syntax.Tests/SyntaxBindingTests.cs b/bindings/csharp/Expressif.Syntax.Tests/SyntaxBindingTests.cs index 776bddd..df1a256 100644 --- a/bindings/csharp/Expressif.Syntax.Tests/SyntaxBindingTests.cs +++ b/bindings/csharp/Expressif.Syntax.Tests/SyntaxBindingTests.cs @@ -269,6 +269,44 @@ public void TupleProjectionCanBeAnArgumentAndPipelineSource() }); } + [Test] + public void ArrayAcceptsInputExpressionsAsElements() + { + const string source = "{ @foo | text-to-func(\"bar\") }"; + var array = (ArrayLiteralSyntax)((ClosedExpressionSyntax)ExpressifSyntax.Parse(source)).Value; + var element = (ClosedExpressionSyntax)array.Values.Single(); + + Assert.Multiple(() => + { + Assert.That(array.Text, Is.EqualTo(source)); + Assert.That(array.Span, Is.EqualTo(new SourceSpan(0, source.Length))); + Assert.That(array.Children, Is.EqualTo(array.Values)); + Assert.That(element.Text, Is.EqualTo("@foo | text-to-func(\"bar\")")); + Assert.That(element.Value, Is.TypeOf() + .With.Property(nameof(SyntaxNode.Text)).EqualTo("@foo")); + Assert.That(element.Pipeline.Single(), Is.TypeOf()); + }); + } + + [Test] + public void TupleProjectionCompositionCanBeAFunctionArgument() + { + const string source = "adjacent($1 | subtract($0) | multiply($1))"; + var root = (OpenExpressionSyntax)ExpressifSyntax.Parse(source); + var call = (FunctionCallSyntax)root.Pipeline.Single(); + var composition = (OpenExpressionSyntax)call.Arguments.Single().Value; + + Assert.Multiple(() => + { + Assert.That(composition.Text, Is.EqualTo("$1 | subtract($0) | multiply($1)")); + Assert.That(composition.Source, Is.TypeOf() + .With.Property(nameof(SyntaxNode.Text)).EqualTo("$1")); + Assert.That(composition.Pipeline, Has.Count.EqualTo(2)); + Assert.That(composition.Children, Has.Count.EqualTo(3)); + Assert.That(composition.Span, Is.EqualTo(new SourceSpan(9, 32))); + }); + } + [Test] public void TupleProjectionCanFollowAFunctionCallInAnOpenPipeline() { @@ -797,6 +835,43 @@ public void IntervalShorthandsMapToFirstClassSemantics( }); } + [TestCase("I(>40)", IntervalBoundKind.Finite, IntervalBoundKind.PositiveInfinity, false, true, "40")] + [TestCase("I(<40)", IntervalBoundKind.NegativeInfinity, IntervalBoundKind.Finite, true, false, "40")] + [TestCase("I(>=40)", IntervalBoundKind.Finite, IntervalBoundKind.PositiveInfinity, true, true, "40")] + [TestCase("I(<=40)", IntervalBoundKind.NegativeInfinity, IntervalBoundKind.Finite, true, true, "40")] + [TestCase("I(positive)", IntervalBoundKind.Finite, IntervalBoundKind.PositiveInfinity, true, true, "0")] + [TestCase("I(negative)", IntervalBoundKind.NegativeInfinity, IntervalBoundKind.Finite, true, true, "0")] + [TestCase("I(absolutely-positive)", IntervalBoundKind.Finite, IntervalBoundKind.PositiveInfinity, false, true, "0")] + [TestCase("I(absolutely-negative)", IntervalBoundKind.NegativeInfinity, IntervalBoundKind.Finite, true, false, "0")] + public void ComparisonAndWordIntervalShorthandsMapToFirstClassSemantics( + string source, + IntervalBoundKind lowerKind, + IntervalBoundKind upperKind, + bool lowerInclusive, + bool upperInclusive, + string finiteText) + { + var interval = (IntervalLiteralSyntax)((ClosedExpressionSyntax)ExpressifSyntax.Parse(source)).Value; + var finite = interval.LowerBound.Value ?? interval.UpperBound.Value; + var authoredValueStart = source.IndexOf(finiteText, StringComparison.Ordinal); + var expectedSpan = authoredValueStart >= 0 + ? new SourceSpan(authoredValueStart, finiteText.Length) + : new SourceSpan(2, 0); + + Assert.Multiple(() => + { + Assert.That(interval.Text, Is.EqualTo(source)); + Assert.That(interval.LowerBound.Kind, Is.EqualTo(lowerKind)); + Assert.That(interval.UpperBound.Kind, Is.EqualTo(upperKind)); + Assert.That(interval.IsLowerInclusive, Is.EqualTo(lowerInclusive)); + Assert.That(interval.IsUpperInclusive, Is.EqualTo(upperInclusive)); + Assert.That(finite, Is.TypeOf() + .With.Property(nameof(SyntaxNode.Text)).EqualTo(finiteText)); + Assert.That(finite!.Span, Is.EqualTo(expectedSpan)); + Assert.That(interval.Children, Is.EqualTo(new[] { finite })); + }); + } + [Test] public void BareDateLookingIntervalBoundsAreRejected() => Assert.Throws(() => ExpressifSyntax.Parse("I[2022-12-10, 2022-12-31]")); diff --git a/bindings/csharp/Expressif.Syntax/ExpressifSyntax.cs b/bindings/csharp/Expressif.Syntax/ExpressifSyntax.cs index a23f329..181efe9 100644 --- a/bindings/csharp/Expressif.Syntax/ExpressifSyntax.cs +++ b/bindings/csharp/Expressif.Syntax/ExpressifSyntax.cs @@ -171,7 +171,7 @@ private static TupleProjectionSyntax BindTupleProjection(TsNode node) "date_literal" => new DateLiteralSyntax(Span(node), node.Text), "date_time_literal" => new DateTimeLiteralSyntax(Span(node), node.Text), "time_literal" => new TimeLiteralSyntax(Span(node), node.Text), - "array_literal" => new ArrayLiteralSyntax(Span(node), node.Text, node.NamedChildren.Select(BindValue).ToArray()), + "array_literal" => new ArrayLiteralSyntax(Span(node), node.Text, node.NamedChildren.Select(BindExpression).ToArray()), "tuple_literal" => new TupleLiteralSyntax(Span(node), node.Text, node.NamedChildren.Select(BindValue).ToArray()), "record_literal" => new RecordLiteralSyntax(Span(node), node.Text, node.NamedChildren.Select(BindRecordEntry).ToArray()), "interval_literal" => BindInterval(node), @@ -215,6 +215,11 @@ private static IntervalLiteralSyntax BindInterval(TsNode node) "(-)" => new(Span(node), node.Text, new(IntervalBoundKind.NegativeInfinity, null), new(IntervalBoundKind.Finite, new NumericLiteralSyntax(new SourceSpan(node.StartIndex + 2, 0), "0")), true, false), + "(positive)" => BindZeroInterval(node, true, true), + "(negative)" => BindZeroInterval(node, false, true), + "(absolutely-positive)" => BindZeroInterval(node, true, false), + "(absolutely-negative)" => BindZeroInterval(node, false, false), + _ when shorthand.Text[1] is '>' or '<' => BindComparisonInterval(node, shorthand.Text), _ => throw Unknown(shorthand), }; } @@ -228,6 +233,31 @@ private static IntervalLiteralSyntax BindInterval(TsNode node) upperDelimiter.Text == "]"); } + private static IntervalLiteralSyntax BindZeroInterval(TsNode node, bool positive, bool inclusive) + { + var zero = new NumericLiteralSyntax(new SourceSpan(node.StartIndex + 2, 0), "0"); + return positive + ? new(Span(node), node.Text, + new(IntervalBoundKind.Finite, zero), new(IntervalBoundKind.PositiveInfinity, null), inclusive, true) + : new(Span(node), node.Text, + new(IntervalBoundKind.NegativeInfinity, null), new(IntervalBoundKind.Finite, zero), true, inclusive); + } + + private static IntervalLiteralSyntax BindComparisonInterval(TsNode node, string shorthand) + { + var operatorLength = shorthand[2] == '=' ? 2 : 1; + var valueOffset = 1 + operatorLength; + var valueText = shorthand[valueOffset..^1]; + var valueStart = node.Text.IndexOf(valueText, StringComparison.Ordinal); + var value = new NumericLiteralSyntax(new SourceSpan(node.StartIndex + valueStart, valueText.Length), valueText); + var inclusive = operatorLength == 2; + return shorthand[1] == '>' + ? new(Span(node), node.Text, + new(IntervalBoundKind.Finite, value), new(IntervalBoundKind.PositiveInfinity, null), inclusive, true) + : new(Span(node), node.Text, + new(IntervalBoundKind.NegativeInfinity, null), new(IntervalBoundKind.Finite, value), true, inclusive); + } + private static IntervalBound BindIntervalBound(TsNode node) { var bound = SingleNamedChild(node, "interval_bound"); diff --git a/bindings/csharp/Expressif.Syntax/SyntaxNodes.cs b/bindings/csharp/Expressif.Syntax/SyntaxNodes.cs index d160b9b..653477d 100644 --- a/bindings/csharp/Expressif.Syntax/SyntaxNodes.cs +++ b/bindings/csharp/Expressif.Syntax/SyntaxNodes.cs @@ -216,10 +216,16 @@ protected SequenceLiteralSyntax(SyntaxKind kind, SourceSpan span, string text, I public IReadOnlyList Values { get; } } -public sealed class ArrayLiteralSyntax : SequenceLiteralSyntax +public sealed class ArrayLiteralSyntax : ValueSyntax { - internal ArrayLiteralSyntax(SourceSpan span, string text, IEnumerable values) - : base(SyntaxKind.ArrayLiteral, span, text, values) { } + internal ArrayLiteralSyntax(SourceSpan span, string text, IEnumerable values) + : this(span, text, values.ToArray()) { } + + private ArrayLiteralSyntax(SourceSpan span, string text, ExpressionSyntax[] values) + : base(SyntaxKind.ArrayLiteral, span, text, values) + => Values = Array.AsReadOnly(values); + + public IReadOnlyList Values { get; } } public sealed class TupleLiteralSyntax : SequenceLiteralSyntax diff --git a/grammar.js b/grammar.js index 4fc0a85..3670995 100644 --- a/grammar.js +++ b/grammar.js @@ -21,6 +21,8 @@ export default grammar({ conflicts: ($) => [ [$.record_spread, $.incoming_value], + [$.expression, $._pipeline_expression], + [$.root_expression, $._parenthesized_pipeline_expression], ], rules: { @@ -157,9 +159,17 @@ export default grammar({ // Parentheses delimit the nested expression, so a function call or // function pipeline can be passed directly as a higher-order argument. - _nested_open_expression: ($) => seq( - $.function_call, - repeat(seq("|", $._pipeline_expression)), + _nested_open_expression: ($) => choice( + seq( + $.function_call, + repeat(seq("|", $._pipeline_expression)), + ), + seq( + $.tuple_projection, + "|", + $._pipeline_expression, + repeat(seq("|", $._pipeline_expression)), + ), ), // A positional argument is already delimited by its function call's @@ -173,13 +183,13 @@ export default grammar({ repeat(seq("|", $._pipeline_expression)), ), - parameterized_expression: ($) => seq( + parameterized_expression: ($) => prec.dynamic(3, seq( "{", field("source", choice($.value, $.tuple_projection)), "|", field("expression", $.open_expression), "}", - ), + )), value: ($) => choice( $.incoming_value, @@ -220,14 +230,41 @@ export default grammar({ infinite_bound: (_) => choice("+INF", "-INF"), - interval_shorthand: (_) => choice("(0+)", "(+)", "(0-)", "(-)"), + interval_shorthand: (_) => choice( + "(0+)", "(+)", "(0-)", "(-)", + "(positive)", "(negative)", + "(absolutely-positive)", "(absolutely-negative)", + /\((?:>=|<=|>|<)-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?\)/, + ), - array_literal: ($) => seq( - "{", - optional(seq($.value, repeat(seq(",", $.value)))), - "}", + array_literal: ($) => prec.dynamic(1, choice( + seq("{", "}"), + prec(1, seq( + "{", + alias($._array_closed_expression, $.closed_expression), + repeat(seq(",", $._array_element)), + "}", + )), + seq( + "{", + $.value, + repeat(seq(",", $._array_element)), + "}", + ), + )), + + _array_element: ($) => choice( + alias($._array_closed_expression, $.closed_expression), + $.value, ), + _array_closed_expression: ($) => prec.right(2, seq( + $.value, + "|", + $._pipeline_expression, + repeat(seq("|", $._pipeline_expression)), + )), + tuple_literal: ($) => seq( "T", "(", @@ -240,7 +277,7 @@ export default grammar({ record_literal: ($) => choice( seq("{", ":", "}"), - prec.dynamic(1, seq( + prec.dynamic(2, seq( "{", $._record_entry, repeat(seq(",", $._record_entry)), diff --git a/src/grammar.json b/src/grammar.json index f03ce65..d0efb28 100644 --- a/src/grammar.json +++ b/src/grammar.json @@ -630,27 +630,65 @@ ] }, "_nested_open_expression": { - "type": "SEQ", + "type": "CHOICE", "members": [ { - "type": "SYMBOL", - "name": "function_call" + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "function_call" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "|" + }, + { + "type": "SYMBOL", + "name": "_pipeline_expression" + } + ] + } + } + ] }, { - "type": "REPEAT", - "content": { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "|" - }, - { - "type": "SYMBOL", - "name": "_pipeline_expression" + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "tuple_projection" + }, + { + "type": "STRING", + "value": "|" + }, + { + "type": "SYMBOL", + "name": "_pipeline_expression" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "|" + }, + { + "type": "SYMBOL", + "name": "_pipeline_expression" + } + ] } - ] - } + } + ] } ] }, @@ -688,46 +726,50 @@ ] }, "parameterized_expression": { - "type": "SEQ", - "members": [ - { - "type": "STRING", - "value": "{" - }, - { - "type": "FIELD", - "name": "source", - "content": { - "type": "CHOICE", - "members": [ - { - "type": "SYMBOL", - "name": "value" - }, - { - "type": "SYMBOL", - "name": "tuple_projection" - } - ] - } - }, - { - "type": "STRING", - "value": "|" - }, - { - "type": "FIELD", - "name": "expression", - "content": { - "type": "SYMBOL", - "name": "open_expression" + "type": "PREC_DYNAMIC", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "FIELD", + "name": "source", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "value" + }, + { + "type": "SYMBOL", + "name": "tuple_projection" + } + ] + } + }, + { + "type": "STRING", + "value": "|" + }, + { + "type": "FIELD", + "name": "expression", + "content": { + "type": "SYMBOL", + "name": "open_expression" + } + }, + { + "type": "STRING", + "value": "}" } - }, - { - "type": "STRING", - "value": "}" - } - ] + ] + } }, "value": { "type": "CHOICE", @@ -923,25 +965,66 @@ { "type": "STRING", "value": "(-)" - } - ] - }, - "array_literal": { - "type": "SEQ", - "members": [ + }, { "type": "STRING", - "value": "{" + "value": "(positive)" }, { - "type": "CHOICE", - "members": [ - { + "type": "STRING", + "value": "(negative)" + }, + { + "type": "STRING", + "value": "(absolutely-positive)" + }, + { + "type": "STRING", + "value": "(absolutely-negative)" + }, + { + "type": "PATTERN", + "value": "\\((?:>=|<=|>|<)-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?\\)" + } + ] + }, + "array_literal": { + "type": "PREC_DYNAMIC", + "value": 1, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + { + "type": "PREC", + "value": 1, + "content": { "type": "SEQ", "members": [ { - "type": "SYMBOL", - "name": "value" + "type": "STRING", + "value": "{" + }, + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_array_closed_expression" + }, + "named": true, + "value": "closed_expression" }, { "type": "REPEAT", @@ -954,24 +1037,109 @@ }, { "type": "SYMBOL", - "name": "value" + "name": "_array_element" } ] } + }, + { + "type": "STRING", + "value": "}" } ] - }, - { - "type": "BLANK" } - ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "value" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "_array_element" + } + ] + } + }, + { + "type": "STRING", + "value": "}" + } + ] + } + ] + } + }, + "_array_element": { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "SYMBOL", + "name": "_array_closed_expression" + }, + "named": true, + "value": "closed_expression" }, { - "type": "STRING", - "value": "}" + "type": "SYMBOL", + "name": "value" } ] }, + "_array_closed_expression": { + "type": "PREC_RIGHT", + "value": 2, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "value" + }, + { + "type": "STRING", + "value": "|" + }, + { + "type": "SYMBOL", + "name": "_pipeline_expression" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "|" + }, + { + "type": "SYMBOL", + "name": "_pipeline_expression" + } + ] + } + } + ] + } + }, "tuple_literal": { "type": "SEQ", "members": [ @@ -1039,7 +1207,7 @@ }, { "type": "PREC_DYNAMIC", - "value": 1, + "value": 2, "content": { "type": "SEQ", "members": [ @@ -1437,6 +1605,14 @@ [ "record_spread", "incoming_value" + ], + [ + "expression", + "_pipeline_expression" + ], + [ + "root_expression", + "_parenthesized_pipeline_expression" ] ], "precedences": [], diff --git a/src/node-types.json b/src/node-types.json index 2a7099e..416b2df 100644 --- a/src/node-types.json +++ b/src/node-types.json @@ -134,6 +134,10 @@ "multiple": true, "required": false, "types": [ + { + "type": "closed_expression", + "named": true + }, { "type": "value", "named": true @@ -805,6 +809,22 @@ "type": "(0-)", "named": false }, + { + "type": "(absolutely-negative)", + "named": false + }, + { + "type": "(absolutely-positive)", + "named": false + }, + { + "type": "(negative)", + "named": false + }, + { + "type": "(positive)", + "named": false + }, { "type": ")", "named": false diff --git a/src/parser.c b/src/parser.c index 0193feb..5a0f405 100644 --- a/src/parser.c +++ b/src/parser.c @@ -7,11 +7,11 @@ #endif #define LANGUAGE_VERSION 15 -#define STATE_COUNT 133 +#define STATE_COUNT 152 #define LARGE_STATE_COUNT 2 -#define SYMBOL_COUNT 96 +#define SYMBOL_COUNT 104 #define ALIAS_COUNT 2 -#define TOKEN_COUNT 45 +#define TOKEN_COUNT 50 #define EXTERNAL_TOKEN_COUNT 0 #define FIELD_COUNT 12 #define MAX_ALIAS_SEQUENCE_LENGTH 7 @@ -41,82 +41,90 @@ enum ts_symbol_identifiers { anon_sym_LPAREN_PLUS_RPAREN = 19, anon_sym_LPAREN0_DASH_RPAREN = 20, anon_sym_LPAREN_DASH_RPAREN = 21, - anon_sym_T = 22, - anon_sym_COLON = 23, - anon_sym_DOT_DOT_DOT = 24, - sym_unquoted_record_field_name = 25, - sym_numeric_literal = 26, - sym_variable = 27, - sym_original_input = 28, - aux_sym_immediate_record_field_selector_token1 = 29, - aux_sym_immediate_record_field_selector_token2 = 30, - aux_sym_original_record_field_selector_token1 = 31, - sym_named_record_field = 32, - sym_positional_record_field = 33, - anon_sym_POUNDtrue = 34, - anon_sym_POUNDfalse = 35, - sym_null_literal = 36, - anon_sym_DQUOTE = 37, - sym_double_quoted_content = 38, - sym_escape_sequence = 39, - anon_sym_BQUOTE = 40, - sym_backtick_quoted_content = 41, - sym_date_literal = 42, - sym_date_time_literal = 43, - sym_time_literal = 44, - sym_source_file = 45, - sym_root_expression = 46, - sym_open_expression = 47, - sym_closed_expression = 48, - sym_map_shorthand = 49, - sym__pipeline_map_shorthand = 50, - sym_expression = 51, - sym__pipeline_expression = 52, - sym__parenthesized_pipeline_expression = 53, - sym__pipeline_open_expression = 54, - sym_parenthesized_expression = 55, - sym_parenthesized_open_expression = 56, - sym_tuple_projection = 57, - sym_function_call = 58, - sym_argument_list = 59, - sym__trailing_argument_list = 60, - sym_positional_argument = 61, - sym_named_argument = 62, - sym__argument_value = 63, - sym__nested_open_expression = 64, - sym__nested_closed_expression = 65, - sym_parameterized_expression = 66, - sym_value = 67, - sym_interval_literal = 68, - sym_interval_bound = 69, - sym_infinite_bound = 70, - sym_interval_shorthand = 71, - sym_array_literal = 72, - sym_tuple_literal = 73, - sym_record_literal = 74, - sym__record_entry = 75, - sym_record_field = 76, - sym_record_spread = 77, - sym_incoming_value = 78, - sym_record_field_name = 79, - sym_record_access = 80, - sym_record_field_selector = 81, - sym_immediate_record_field_selector = 82, - sym_original_record_field_selector = 83, - sym_boolean_literal = 84, - sym_quoted_literal = 85, - sym_double_quoted_literal = 86, - sym_backtick_quoted_literal = 87, - sym_temporal_literal = 88, - aux_sym_open_expression_repeat1 = 89, - aux_sym_closed_expression_repeat1 = 90, - aux_sym_argument_list_repeat1 = 91, - aux_sym_array_literal_repeat1 = 92, - aux_sym_record_literal_repeat1 = 93, - aux_sym_record_access_repeat1 = 94, - aux_sym_double_quoted_literal_repeat1 = 95, - alias_sym_argument_name = 96, - alias_sym_from_start = 97, + anon_sym_LPARENpositive_RPAREN = 22, + anon_sym_LPARENnegative_RPAREN = 23, + anon_sym_LPARENabsolutely_DASHpositive_RPAREN = 24, + anon_sym_LPARENabsolutely_DASHnegative_RPAREN = 25, + aux_sym_interval_shorthand_token1 = 26, + anon_sym_T = 27, + anon_sym_COLON = 28, + anon_sym_DOT_DOT_DOT = 29, + sym_unquoted_record_field_name = 30, + sym_numeric_literal = 31, + sym_variable = 32, + sym_original_input = 33, + aux_sym_immediate_record_field_selector_token1 = 34, + aux_sym_immediate_record_field_selector_token2 = 35, + aux_sym_original_record_field_selector_token1 = 36, + sym_named_record_field = 37, + sym_positional_record_field = 38, + anon_sym_POUNDtrue = 39, + anon_sym_POUNDfalse = 40, + sym_null_literal = 41, + anon_sym_DQUOTE = 42, + sym_double_quoted_content = 43, + sym_escape_sequence = 44, + anon_sym_BQUOTE = 45, + sym_backtick_quoted_content = 46, + sym_date_literal = 47, + sym_date_time_literal = 48, + sym_time_literal = 49, + sym_source_file = 50, + sym_root_expression = 51, + sym_open_expression = 52, + sym_closed_expression = 53, + sym_map_shorthand = 54, + sym__pipeline_map_shorthand = 55, + sym_expression = 56, + sym__pipeline_expression = 57, + sym__parenthesized_pipeline_expression = 58, + sym__pipeline_open_expression = 59, + sym_parenthesized_expression = 60, + sym_parenthesized_open_expression = 61, + sym_tuple_projection = 62, + sym_function_call = 63, + sym_argument_list = 64, + sym__trailing_argument_list = 65, + sym_positional_argument = 66, + sym_named_argument = 67, + sym__argument_value = 68, + sym__nested_open_expression = 69, + sym__nested_closed_expression = 70, + sym_parameterized_expression = 71, + sym_value = 72, + sym_interval_literal = 73, + sym_interval_bound = 74, + sym_infinite_bound = 75, + sym_interval_shorthand = 76, + sym_array_literal = 77, + sym__array_element = 78, + sym__array_closed_expression = 79, + sym_tuple_literal = 80, + sym_record_literal = 81, + sym__record_entry = 82, + sym_record_field = 83, + sym_record_spread = 84, + sym_incoming_value = 85, + sym_record_field_name = 86, + sym_record_access = 87, + sym_record_field_selector = 88, + sym_immediate_record_field_selector = 89, + sym_original_record_field_selector = 90, + sym_boolean_literal = 91, + sym_quoted_literal = 92, + sym_double_quoted_literal = 93, + sym_backtick_quoted_literal = 94, + sym_temporal_literal = 95, + aux_sym_open_expression_repeat1 = 96, + aux_sym_closed_expression_repeat1 = 97, + aux_sym_argument_list_repeat1 = 98, + aux_sym_array_literal_repeat1 = 99, + aux_sym_tuple_literal_repeat1 = 100, + aux_sym_record_literal_repeat1 = 101, + aux_sym_record_access_repeat1 = 102, + aux_sym_double_quoted_literal_repeat1 = 103, + alias_sym_argument_name = 104, + alias_sym_from_start = 105, }; static const char * const ts_symbol_names[] = { @@ -142,6 +150,11 @@ static const char * const ts_symbol_names[] = { [anon_sym_LPAREN_PLUS_RPAREN] = "(+)", [anon_sym_LPAREN0_DASH_RPAREN] = "(0-)", [anon_sym_LPAREN_DASH_RPAREN] = "(-)", + [anon_sym_LPARENpositive_RPAREN] = "(positive)", + [anon_sym_LPARENnegative_RPAREN] = "(negative)", + [anon_sym_LPARENabsolutely_DASHpositive_RPAREN] = "(absolutely-positive)", + [anon_sym_LPARENabsolutely_DASHnegative_RPAREN] = "(absolutely-negative)", + [aux_sym_interval_shorthand_token1] = "interval_shorthand_token1", [anon_sym_T] = "T", [anon_sym_COLON] = ":", [anon_sym_DOT_DOT_DOT] = "...", @@ -193,6 +206,8 @@ static const char * const ts_symbol_names[] = { [sym_infinite_bound] = "infinite_bound", [sym_interval_shorthand] = "interval_shorthand", [sym_array_literal] = "array_literal", + [sym__array_element] = "_array_element", + [sym__array_closed_expression] = "closed_expression", [sym_tuple_literal] = "tuple_literal", [sym_record_literal] = "record_literal", [sym__record_entry] = "_record_entry", @@ -213,6 +228,7 @@ static const char * const ts_symbol_names[] = { [aux_sym_closed_expression_repeat1] = "closed_expression_repeat1", [aux_sym_argument_list_repeat1] = "argument_list_repeat1", [aux_sym_array_literal_repeat1] = "array_literal_repeat1", + [aux_sym_tuple_literal_repeat1] = "tuple_literal_repeat1", [aux_sym_record_literal_repeat1] = "record_literal_repeat1", [aux_sym_record_access_repeat1] = "record_access_repeat1", [aux_sym_double_quoted_literal_repeat1] = "double_quoted_literal_repeat1", @@ -243,6 +259,11 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_LPAREN_PLUS_RPAREN] = anon_sym_LPAREN_PLUS_RPAREN, [anon_sym_LPAREN0_DASH_RPAREN] = anon_sym_LPAREN0_DASH_RPAREN, [anon_sym_LPAREN_DASH_RPAREN] = anon_sym_LPAREN_DASH_RPAREN, + [anon_sym_LPARENpositive_RPAREN] = anon_sym_LPARENpositive_RPAREN, + [anon_sym_LPARENnegative_RPAREN] = anon_sym_LPARENnegative_RPAREN, + [anon_sym_LPARENabsolutely_DASHpositive_RPAREN] = anon_sym_LPARENabsolutely_DASHpositive_RPAREN, + [anon_sym_LPARENabsolutely_DASHnegative_RPAREN] = anon_sym_LPARENabsolutely_DASHnegative_RPAREN, + [aux_sym_interval_shorthand_token1] = aux_sym_interval_shorthand_token1, [anon_sym_T] = anon_sym_T, [anon_sym_COLON] = anon_sym_COLON, [anon_sym_DOT_DOT_DOT] = anon_sym_DOT_DOT_DOT, @@ -294,6 +315,8 @@ static const TSSymbol ts_symbol_map[] = { [sym_infinite_bound] = sym_infinite_bound, [sym_interval_shorthand] = sym_interval_shorthand, [sym_array_literal] = sym_array_literal, + [sym__array_element] = sym__array_element, + [sym__array_closed_expression] = sym_closed_expression, [sym_tuple_literal] = sym_tuple_literal, [sym_record_literal] = sym_record_literal, [sym__record_entry] = sym__record_entry, @@ -314,6 +337,7 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_closed_expression_repeat1] = aux_sym_closed_expression_repeat1, [aux_sym_argument_list_repeat1] = aux_sym_argument_list_repeat1, [aux_sym_array_literal_repeat1] = aux_sym_array_literal_repeat1, + [aux_sym_tuple_literal_repeat1] = aux_sym_tuple_literal_repeat1, [aux_sym_record_literal_repeat1] = aux_sym_record_literal_repeat1, [aux_sym_record_access_repeat1] = aux_sym_record_access_repeat1, [aux_sym_double_quoted_literal_repeat1] = aux_sym_double_quoted_literal_repeat1, @@ -410,6 +434,26 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_LPARENpositive_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_LPARENnegative_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_LPARENabsolutely_DASHpositive_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_LPARENabsolutely_DASHnegative_RPAREN] = { + .visible = true, + .named = false, + }, + [aux_sym_interval_shorthand_token1] = { + .visible = false, + .named = false, + }, [anon_sym_T] = { .visible = true, .named = false, @@ -616,6 +660,14 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym__array_element] = { + .visible = false, + .named = true, + }, + [sym__array_closed_expression] = { + .visible = true, + .named = true, + }, [sym_tuple_literal] = { .visible = true, .named = true, @@ -698,6 +750,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = false, }, + [aux_sym_tuple_literal_repeat1] = { + .visible = false, + .named = false, + }, [aux_sym_record_literal_repeat1] = { .visible = false, .named = false, @@ -967,6 +1023,25 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [130] = 130, [131] = 131, [132] = 132, + [133] = 133, + [134] = 134, + [135] = 135, + [136] = 136, + [137] = 137, + [138] = 138, + [139] = 139, + [140] = 140, + [141] = 141, + [142] = 142, + [143] = 143, + [144] = 144, + [145] = 145, + [146] = 146, + [147] = 147, + [148] = 148, + [149] = 149, + [150] = 150, + [151] = 151, }; static const TSSymbol ts_supertype_symbols[SUPERTYPE_COUNT] = { @@ -1016,80 +1091,80 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (eof) ADVANCE(79); + if (eof) ADVANCE(129); ADVANCE_MAP( - '"', 129, + '"', 184, '#', 4, - '$', 85, - '(', 83, - ')', 84, - '+', 34, - ',', 92, - '-', 22, - '.', 18, - '0', 114, - ':', 111, - '@', 69, - 'I', 96, - 'T', 107, - '[', 99, - '\\', 49, - ']', 100, - '^', 89, - '_', 113, - '`', 133, - '{', 94, - '|', 80, - '}', 95, + '$', 135, + '(', 133, + ')', 134, + '+', 45, + ',', 142, + '-', 32, + '.', 28, + '0', 169, + ':', 166, + '@', 119, + 'I', 146, + 'T', 162, + '[', 149, + '\\', 98, + ']', 150, + '^', 139, + '_', 168, + '`', 188, + '{', 144, + '|', 130, + '}', 145, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || - lookahead == 0xfeff) SKIP(75); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(115); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(90); + lookahead == 0xfeff) SKIP(125); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(170); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(140); END_STATE(); case 1: ADVANCE_MAP( - '"', 129, + '"', 184, '#', 4, - '$', 85, - '-', 23, - '.', 19, - '0', 114, - ':', 110, - '@', 69, - 'I', 97, - 'T', 108, - '^', 20, - '`', 133, - '{', 94, - '}', 95, + '$', 135, + '-', 33, + '.', 29, + '0', 169, + ':', 165, + '@', 119, + 'I', 147, + 'T', 163, + '^', 30, + '`', 188, + '{', 144, + '}', 145, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || lookahead == 0xfeff) SKIP(1); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(115); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(170); if (('A' <= lookahead && lookahead <= 'Z') || - ('_' <= lookahead && lookahead <= 'z')) ADVANCE(113); + ('_' <= lookahead && lookahead <= 'z')) ADVANCE(168); END_STATE(); case 2: - if (lookahead == '"') ADVANCE(129); - if (lookahead == '\\') ADVANCE(49); + if (lookahead == '"') ADVANCE(184); + if (lookahead == '\\') ADVANCE(98); if (lookahead == '\n' || lookahead == '\r') SKIP(3); if (('\t' <= lookahead && lookahead <= '\f') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || - lookahead == 0xfeff) ADVANCE(130); - if (lookahead != 0) ADVANCE(131); + lookahead == 0xfeff) ADVANCE(185); + if (lookahead != 0) ADVANCE(186); END_STATE(); case 3: - if (lookahead == '"') ADVANCE(129); + if (lookahead == '"') ADVANCE(184); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || @@ -1097,633 +1172,816 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 0xfeff) SKIP(3); END_STATE(); case 4: - if (lookahead == '"') ADVANCE(57); - if (lookahead == 'f') ADVANCE(39); - if (lookahead == 'n') ADVANCE(48); - if (lookahead == 't') ADVANCE(45); + if (lookahead == '"') ADVANCE(107); + if (lookahead == 'f') ADVANCE(50); + if (lookahead == 'n') ADVANCE(91); + if (lookahead == 't') ADVANCE(80); END_STATE(); case 5: - if (lookahead == '"') ADVANCE(138); + if (lookahead == '"') ADVANCE(193); END_STATE(); case 6: - if (lookahead == '"') ADVANCE(136); + if (lookahead == '"') ADVANCE(191); if (lookahead == ' ' || - lookahead == 'T') ADVANCE(65); + lookahead == 'T') ADVANCE(115); END_STATE(); case 7: - if (lookahead == '"') ADVANCE(137); + if (lookahead == '"') ADVANCE(192); END_STATE(); case 8: - if (lookahead == '$') ADVANCE(85); - if (lookahead == '(') ADVANCE(82); - if (lookahead == '.') ADVANCE(24); - if (lookahead == '0') ADVANCE(86); - if (lookahead == '^') ADVANCE(20); - if (lookahead == '|') ADVANCE(31); + if (lookahead == '$') ADVANCE(135); + if (lookahead == '(') ADVANCE(132); + if (lookahead == '.') ADVANCE(35); + if (lookahead == '0') ADVANCE(136); + if (lookahead == '^') ADVANCE(30); + if (lookahead == '|') ADVANCE(42); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || lookahead == 0xfeff) SKIP(9); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(87); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(137); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(141); END_STATE(); case 9: - if (lookahead == '$') ADVANCE(85); - if (lookahead == '(') ADVANCE(82); - if (lookahead == '.') ADVANCE(24); - if (lookahead == '^') ADVANCE(20); - if (lookahead == '|') ADVANCE(31); + if (lookahead == '$') ADVANCE(135); + if (lookahead == '(') ADVANCE(132); + if (lookahead == '.') ADVANCE(35); + if (lookahead == '^') ADVANCE(30); + if (lookahead == '|') ADVANCE(42); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || lookahead == 0xfeff) SKIP(9); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(141); END_STATE(); case 10: - if (lookahead == ')') ADVANCE(104); + if (lookahead == ')') ADVANCE(154); END_STATE(); case 11: - if (lookahead == ')') ADVANCE(106); + if (lookahead == ')') ADVANCE(156); END_STATE(); case 12: - if (lookahead == ')') ADVANCE(103); + if (lookahead == ')') ADVANCE(153); END_STATE(); case 13: - if (lookahead == ')') ADVANCE(105); + if (lookahead == ')') ADVANCE(155); END_STATE(); case 14: - if (lookahead == '+') ADVANCE(12); - if (lookahead == '-') ADVANCE(13); + if (lookahead == ')') ADVANCE(161); + if (lookahead == '.') ADVANCE(101); END_STATE(); case 15: - if (lookahead == '-') ADVANCE(64); + if (lookahead == ')') ADVANCE(161); + if (lookahead == '.') ADVANCE(101); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(15); END_STATE(); case 16: - if (lookahead == '-') ADVANCE(60); + if (lookahead == ')') ADVANCE(161); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(16); END_STATE(); case 17: - if (lookahead == '.') ADVANCE(21); + if (lookahead == ')') ADVANCE(158); END_STATE(); case 18: - if (lookahead == '.') ADVANCE(21); - if (lookahead == '0') ADVANCE(120); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(121); - if (('A' <= lookahead && lookahead <= 'Z') || - lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(119); + if (lookahead == ')') ADVANCE(157); END_STATE(); case 19: - if (lookahead == '.') ADVANCE(21); - if (lookahead == '0') ADVANCE(124); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); - if (('A' <= lookahead && lookahead <= 'Z') || - lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(123); + if (lookahead == ')') ADVANCE(160); END_STATE(); case 20: - if (lookahead == '.') ADVANCE(118); + if (lookahead == ')') ADVANCE(159); END_STATE(); case 21: - if (lookahead == '.') ADVANCE(112); + if (lookahead == '+') ADVANCE(12); + if (lookahead == '-') ADVANCE(13); END_STATE(); case 22: - if (lookahead == '0') ADVANCE(114); - if (lookahead == 'I') ADVANCE(36); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(115); + if (lookahead == '-') ADVANCE(34); + if (lookahead == '0') ADVANCE(14); + if (lookahead == '=') ADVANCE(23); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(15); END_STATE(); case 23: - if (lookahead == '0') ADVANCE(114); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(115); + if (lookahead == '-') ADVANCE(34); + if (lookahead == '0') ADVANCE(14); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(15); END_STATE(); case 24: - if (lookahead == '0') ADVANCE(124); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(125); - if (('A' <= lookahead && lookahead <= 'Z') || - lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(123); + if (lookahead == '-') ADVANCE(76); END_STATE(); case 25: - if (lookahead == '0') ADVANCE(86); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(87); - if (('A' <= lookahead && lookahead <= 'Z') || - lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(122); + if (lookahead == '-') ADVANCE(114); END_STATE(); case 26: - if (lookahead == ':') ADVANCE(58); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(52); + if (lookahead == '-') ADVANCE(110); END_STATE(); case 27: - if (lookahead == ':') ADVANCE(59); + if (lookahead == '.') ADVANCE(31); END_STATE(); case 28: - if (lookahead == ':') ADVANCE(61); + if (lookahead == '.') ADVANCE(31); + if (lookahead == '0') ADVANCE(175); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(176); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(174); END_STATE(); case 29: - if (lookahead == ':') ADVANCE(67); + if (lookahead == '.') ADVANCE(31); + if (lookahead == '0') ADVANCE(179); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(180); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(178); END_STATE(); case 30: - if (lookahead == '=') ADVANCE(93); + if (lookahead == '.') ADVANCE(173); END_STATE(); case 31: - if (lookahead == '>') ADVANCE(81); + if (lookahead == '.') ADVANCE(167); END_STATE(); case 32: - if (lookahead == 'F') ADVANCE(101); + if (lookahead == '0') ADVANCE(169); + if (lookahead == 'I') ADVANCE(47); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(170); END_STATE(); case 33: - if (lookahead == 'F') ADVANCE(102); + if (lookahead == '0') ADVANCE(169); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(170); END_STATE(); case 34: - if (lookahead == 'I') ADVANCE(35); + if (lookahead == '0') ADVANCE(14); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(15); END_STATE(); case 35: - if (lookahead == 'N') ADVANCE(32); + if (lookahead == '0') ADVANCE(179); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(180); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(178); END_STATE(); case 36: - if (lookahead == 'N') ADVANCE(33); + if (lookahead == '0') ADVANCE(136); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(137); + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(177); END_STATE(); case 37: - if (lookahead == '`') ADVANCE(133); - if (lookahead == '\n' || - lookahead == '\r') SKIP(38); - if (('\t' <= lookahead && lookahead <= '\f') || - lookahead == ' ' || - lookahead == 0x200b || - lookahead == 0x2060 || - lookahead == 0xfeff) ADVANCE(134); - if (lookahead != 0) ADVANCE(135); + if (lookahead == ':') ADVANCE(108); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(102); END_STATE(); case 38: - if (lookahead == '`') ADVANCE(133); - if (('\t' <= lookahead && lookahead <= '\r') || - lookahead == ' ' || - lookahead == 0x200b || - lookahead == 0x2060 || - lookahead == 0xfeff) SKIP(38); + if (lookahead == ':') ADVANCE(109); END_STATE(); case 39: - if (lookahead == 'a') ADVANCE(42); + if (lookahead == ':') ADVANCE(111); END_STATE(); case 40: - if (lookahead == 'e') ADVANCE(126); + if (lookahead == ':') ADVANCE(117); END_STATE(); case 41: - if (lookahead == 'e') ADVANCE(127); + if (lookahead == '=') ADVANCE(143); END_STATE(); case 42: - if (lookahead == 'l') ADVANCE(46); + if (lookahead == '>') ADVANCE(131); END_STATE(); case 43: - if (lookahead == 'l') ADVANCE(128); + if (lookahead == 'F') ADVANCE(151); END_STATE(); case 44: - if (lookahead == 'l') ADVANCE(43); + if (lookahead == 'F') ADVANCE(152); END_STATE(); case 45: - if (lookahead == 'r') ADVANCE(47); + if (lookahead == 'I') ADVANCE(46); END_STATE(); case 46: - if (lookahead == 's') ADVANCE(41); + if (lookahead == 'N') ADVANCE(43); END_STATE(); case 47: - if (lookahead == 'u') ADVANCE(40); + if (lookahead == 'N') ADVANCE(44); END_STATE(); case 48: - if (lookahead == 'u') ADVANCE(44); + if (lookahead == '`') ADVANCE(188); + if (lookahead == '\n' || + lookahead == '\r') SKIP(49); + if (('\t' <= lookahead && lookahead <= '\f') || + lookahead == ' ' || + lookahead == 0x200b || + lookahead == 0x2060 || + lookahead == 0xfeff) ADVANCE(189); + if (lookahead != 0) ADVANCE(190); END_STATE(); case 49: - if (lookahead == '"' || - lookahead == '\\') ADVANCE(132); + if (lookahead == '`') ADVANCE(188); + if (('\t' <= lookahead && lookahead <= '\r') || + lookahead == ' ' || + lookahead == 0x200b || + lookahead == 0x2060 || + lookahead == 0xfeff) SKIP(49); END_STATE(); case 50: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(116); + if (lookahead == 'a') ADVANCE(75); END_STATE(); case 51: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(26); + if (lookahead == 'a') ADVANCE(85); END_STATE(); case 52: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(15); + if (lookahead == 'a') ADVANCE(88); END_STATE(); case 53: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(27); + if (lookahead == 'b') ADVANCE(82); END_STATE(); case 54: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(5); + if (lookahead == 'e') ADVANCE(63); END_STATE(); case 55: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(6); + if (lookahead == 'e') ADVANCE(181); END_STATE(); case 56: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(7); + if (lookahead == 'e') ADVANCE(182); END_STATE(); case 57: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(51); + if (lookahead == 'e') ADVANCE(17); END_STATE(); case 58: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(53); + if (lookahead == 'e') ADVANCE(72); END_STATE(); case 59: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(54); + if (lookahead == 'e') ADVANCE(18); END_STATE(); case 60: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(55); + if (lookahead == 'e') ADVANCE(19); END_STATE(); case 61: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(56); + if (lookahead == 'e') ADVANCE(20); END_STATE(); case 62: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(16); + if (lookahead == 'e') ADVANCE(64); END_STATE(); case 63: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(29); + if (lookahead == 'g') ADVANCE(51); END_STATE(); case 64: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(62); + if (lookahead == 'g') ADVANCE(52); END_STATE(); case 65: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(63); + if (lookahead == 'i') ADVANCE(93); END_STATE(); case 66: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(28); + if (lookahead == 'i') ADVANCE(94); END_STATE(); case 67: - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(66); + if (lookahead == 'i') ADVANCE(95); END_STATE(); case 68: + if (lookahead == 'i') ADVANCE(96); + END_STATE(); + case 69: + if (lookahead == 'i') ADVANCE(87); + END_STATE(); + case 70: + if (lookahead == 'i') ADVANCE(89); + END_STATE(); + case 71: + if (lookahead == 'l') ADVANCE(183); + END_STATE(); + case 72: + if (lookahead == 'l') ADVANCE(97); + END_STATE(); + case 73: + if (lookahead == 'l') ADVANCE(92); + END_STATE(); + case 74: + if (lookahead == 'l') ADVANCE(71); + END_STATE(); + case 75: + if (lookahead == 'l') ADVANCE(83); + END_STATE(); + case 76: + if (lookahead == 'n') ADVANCE(62); + if (lookahead == 'p') ADVANCE(79); + END_STATE(); + case 77: + if (lookahead == 'o') ADVANCE(81); + END_STATE(); + case 78: + if (lookahead == 'o') ADVANCE(73); + END_STATE(); + case 79: + if (lookahead == 'o') ADVANCE(84); + END_STATE(); + case 80: + if (lookahead == 'r') ADVANCE(90); + END_STATE(); + case 81: + if (lookahead == 's') ADVANCE(69); + END_STATE(); + case 82: + if (lookahead == 's') ADVANCE(78); + END_STATE(); + case 83: + if (lookahead == 's') ADVANCE(56); + END_STATE(); + case 84: + if (lookahead == 's') ADVANCE(70); + END_STATE(); + case 85: + if (lookahead == 't') ADVANCE(65); + END_STATE(); + case 86: + if (lookahead == 't') ADVANCE(58); + END_STATE(); + case 87: + if (lookahead == 't') ADVANCE(66); + END_STATE(); + case 88: + if (lookahead == 't') ADVANCE(67); + END_STATE(); + case 89: + if (lookahead == 't') ADVANCE(68); + END_STATE(); + case 90: + if (lookahead == 'u') ADVANCE(55); + END_STATE(); + case 91: + if (lookahead == 'u') ADVANCE(74); + END_STATE(); + case 92: + if (lookahead == 'u') ADVANCE(86); + END_STATE(); + case 93: + if (lookahead == 'v') ADVANCE(57); + END_STATE(); + case 94: + if (lookahead == 'v') ADVANCE(59); + END_STATE(); + case 95: + if (lookahead == 'v') ADVANCE(60); + END_STATE(); + case 96: + if (lookahead == 'v') ADVANCE(61); + END_STATE(); + case 97: + if (lookahead == 'y') ADVANCE(24); + END_STATE(); + case 98: + if (lookahead == '"' || + lookahead == '\\') ADVANCE(187); + END_STATE(); + case 99: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(171); + END_STATE(); + case 100: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(37); + END_STATE(); + case 101: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(16); + END_STATE(); + case 102: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(25); + END_STATE(); + case 103: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(38); + END_STATE(); + case 104: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(5); + END_STATE(); + case 105: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(6); + END_STATE(); + case 106: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(7); + END_STATE(); + case 107: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(100); + END_STATE(); + case 108: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(103); + END_STATE(); + case 109: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(104); + END_STATE(); + case 110: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(105); + END_STATE(); + case 111: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(106); + END_STATE(); + case 112: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(26); + END_STATE(); + case 113: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(40); + END_STATE(); + case 114: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(112); + END_STATE(); + case 115: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(113); + END_STATE(); + case 116: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(39); + END_STATE(); + case 117: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(116); + END_STATE(); + case 118: if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(113); + lookahead == '_') ADVANCE(168); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(90); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(140); END_STATE(); - case 69: + case 119: if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(117); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(172); END_STATE(); - case 70: + case 120: if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(141); END_STATE(); - case 71: + case 121: if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(113); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(168); END_STATE(); - case 72: + case 122: if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(119); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(174); END_STATE(); - case 73: + case 123: if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(123); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(178); END_STATE(); - case 74: + case 124: if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(122); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(177); END_STATE(); - case 75: - if (eof) ADVANCE(79); + case 125: + if (eof) ADVANCE(129); ADVANCE_MAP( - '"', 129, + '"', 184, '#', 4, - '$', 85, - '(', 83, - ')', 84, - '+', 34, - ',', 92, - '-', 22, - '.', 19, - '0', 114, - ':', 111, - '@', 69, - 'I', 96, - 'T', 107, - '[', 99, - ']', 100, - '^', 20, - '_', 113, - '`', 133, - '{', 94, - '|', 80, - '}', 95, + '$', 135, + '(', 133, + ')', 134, + '+', 45, + ',', 142, + '-', 32, + '.', 29, + '0', 169, + ':', 166, + '@', 119, + 'I', 146, + 'T', 162, + '[', 149, + ']', 150, + '^', 30, + '_', 168, + '`', 188, + '{', 144, + '|', 130, + '}', 145, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || - lookahead == 0xfeff) SKIP(75); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(115); + lookahead == 0xfeff) SKIP(125); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(170); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(90); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(140); END_STATE(); - case 76: - if (eof) ADVANCE(79); + case 126: + if (eof) ADVANCE(129); ADVANCE_MAP( - '"', 129, + '"', 184, '#', 4, - '$', 85, - '(', 82, - ')', 84, - '+', 34, - ',', 92, - '-', 22, - '.', 19, - '0', 114, - ':', 30, - '@', 69, - 'I', 98, - 'T', 109, - '[', 99, - ']', 100, - '^', 20, - '`', 133, - '{', 94, - '|', 80, - '}', 95, + '$', 135, + '(', 132, + ')', 134, + '+', 45, + ',', 142, + '-', 32, + '.', 29, + '0', 169, + ':', 41, + '@', 119, + 'I', 148, + 'T', 164, + '[', 149, + ']', 150, + '^', 30, + '`', 188, + '{', 144, + '|', 130, + '}', 145, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || - lookahead == 0xfeff) SKIP(76); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(115); + lookahead == 0xfeff) SKIP(126); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(170); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(141); END_STATE(); - case 77: - if (eof) ADVANCE(79); + case 127: + if (eof) ADVANCE(129); ADVANCE_MAP( - '"', 129, - ')', 84, - ',', 92, - '.', 18, - '0', 86, - '^', 88, - '`', 133, - '|', 80, - '}', 95, + '"', 184, + ')', 134, + ',', 142, + '.', 28, + '0', 136, + '^', 138, + '`', 188, + '|', 130, + '}', 145, ); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || - lookahead == 0xfeff) SKIP(78); - if (('1' <= lookahead && lookahead <= '9')) ADVANCE(87); + lookahead == 0xfeff) SKIP(128); + if (('1' <= lookahead && lookahead <= '9')) ADVANCE(137); if (('A' <= lookahead && lookahead <= 'Z') || - ('_' <= lookahead && lookahead <= 'z')) ADVANCE(113); + ('_' <= lookahead && lookahead <= 'z')) ADVANCE(168); END_STATE(); - case 78: - if (eof) ADVANCE(79); - if (lookahead == '"') ADVANCE(129); - if (lookahead == ')') ADVANCE(84); - if (lookahead == ',') ADVANCE(92); - if (lookahead == '.') ADVANCE(17); - if (lookahead == '`') ADVANCE(133); - if (lookahead == '|') ADVANCE(80); - if (lookahead == '}') ADVANCE(95); + case 128: + if (eof) ADVANCE(129); + if (lookahead == '"') ADVANCE(184); + if (lookahead == ')') ADVANCE(134); + if (lookahead == ',') ADVANCE(142); + if (lookahead == '.') ADVANCE(27); + if (lookahead == '`') ADVANCE(188); + if (lookahead == '|') ADVANCE(130); + if (lookahead == '}') ADVANCE(145); if (('\t' <= lookahead && lookahead <= '\r') || lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || - lookahead == 0xfeff) SKIP(78); + lookahead == 0xfeff) SKIP(128); if (('A' <= lookahead && lookahead <= 'Z') || - ('_' <= lookahead && lookahead <= 'z')) ADVANCE(113); + ('_' <= lookahead && lookahead <= 'z')) ADVANCE(168); END_STATE(); - case 79: + case 129: ACCEPT_TOKEN(ts_builtin_sym_end); END_STATE(); - case 80: + case 130: ACCEPT_TOKEN(anon_sym_PIPE); - if (lookahead == '>') ADVANCE(81); + if (lookahead == '>') ADVANCE(131); END_STATE(); - case 81: + case 131: ACCEPT_TOKEN(anon_sym_PIPE_GT); END_STATE(); - case 82: + case 132: ACCEPT_TOKEN(anon_sym_LPAREN); END_STATE(); - case 83: + case 133: ACCEPT_TOKEN(anon_sym_LPAREN); - if (lookahead == '+') ADVANCE(10); - if (lookahead == '-') ADVANCE(11); - if (lookahead == '0') ADVANCE(14); + ADVANCE_MAP( + '+', 10, + '-', 11, + '0', 21, + '<', 22, + '>', 22, + 'a', 53, + 'n', 54, + 'p', 77, + ); END_STATE(); - case 84: + case 134: ACCEPT_TOKEN(anon_sym_RPAREN); END_STATE(); - case 85: + case 135: ACCEPT_TOKEN(anon_sym_DOLLAR); END_STATE(); - case 86: + case 136: ACCEPT_TOKEN(aux_sym_tuple_projection_token1); END_STATE(); - case 87: + case 137: ACCEPT_TOKEN(aux_sym_tuple_projection_token1); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(87); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(137); END_STATE(); - case 88: + case 138: ACCEPT_TOKEN(anon_sym_CARET); END_STATE(); - case 89: + case 139: ACCEPT_TOKEN(anon_sym_CARET); - if (lookahead == '.') ADVANCE(118); + if (lookahead == '.') ADVANCE(173); END_STATE(); - case 90: + case 140: ACCEPT_TOKEN(sym_function_name); - if (lookahead == '-') ADVANCE(68); + if (lookahead == '-') ADVANCE(118); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(113); + lookahead == '_') ADVANCE(168); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(90); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(140); END_STATE(); - case 91: + case 141: ACCEPT_TOKEN(sym_function_name); - if (lookahead == '-') ADVANCE(70); + if (lookahead == '-') ADVANCE(120); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(141); END_STATE(); - case 92: + case 142: ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); - case 93: + case 143: ACCEPT_TOKEN(anon_sym_COLON_EQ); END_STATE(); - case 94: + case 144: ACCEPT_TOKEN(anon_sym_LBRACE); END_STATE(); - case 95: + case 145: ACCEPT_TOKEN(anon_sym_RBRACE); END_STATE(); - case 96: + case 146: ACCEPT_TOKEN(anon_sym_I); - if (lookahead == '-') ADVANCE(68); + if (lookahead == '-') ADVANCE(118); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(113); + lookahead == '_') ADVANCE(168); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(90); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(140); END_STATE(); - case 97: + case 147: ACCEPT_TOKEN(anon_sym_I); - if (lookahead == '-') ADVANCE(71); + if (lookahead == '-') ADVANCE(121); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(113); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(168); END_STATE(); - case 98: + case 148: ACCEPT_TOKEN(anon_sym_I); - if (lookahead == '-') ADVANCE(70); + if (lookahead == '-') ADVANCE(120); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(141); END_STATE(); - case 99: + case 149: ACCEPT_TOKEN(anon_sym_LBRACK); END_STATE(); - case 100: + case 150: ACCEPT_TOKEN(anon_sym_RBRACK); END_STATE(); - case 101: + case 151: ACCEPT_TOKEN(anon_sym_PLUSINF); END_STATE(); - case 102: + case 152: ACCEPT_TOKEN(anon_sym_DASHINF); END_STATE(); - case 103: + case 153: ACCEPT_TOKEN(anon_sym_LPAREN0_PLUS_RPAREN); END_STATE(); - case 104: + case 154: ACCEPT_TOKEN(anon_sym_LPAREN_PLUS_RPAREN); END_STATE(); - case 105: + case 155: ACCEPT_TOKEN(anon_sym_LPAREN0_DASH_RPAREN); END_STATE(); - case 106: + case 156: ACCEPT_TOKEN(anon_sym_LPAREN_DASH_RPAREN); END_STATE(); - case 107: + case 157: + ACCEPT_TOKEN(anon_sym_LPARENpositive_RPAREN); + END_STATE(); + case 158: + ACCEPT_TOKEN(anon_sym_LPARENnegative_RPAREN); + END_STATE(); + case 159: + ACCEPT_TOKEN(anon_sym_LPARENabsolutely_DASHpositive_RPAREN); + END_STATE(); + case 160: + ACCEPT_TOKEN(anon_sym_LPARENabsolutely_DASHnegative_RPAREN); + END_STATE(); + case 161: + ACCEPT_TOKEN(aux_sym_interval_shorthand_token1); + END_STATE(); + case 162: ACCEPT_TOKEN(anon_sym_T); - if (lookahead == '-') ADVANCE(68); + if (lookahead == '-') ADVANCE(118); if (('0' <= lookahead && lookahead <= '9') || - lookahead == '_') ADVANCE(113); + lookahead == '_') ADVANCE(168); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(90); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(140); END_STATE(); - case 108: + case 163: ACCEPT_TOKEN(anon_sym_T); - if (lookahead == '-') ADVANCE(71); + if (lookahead == '-') ADVANCE(121); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(113); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(168); END_STATE(); - case 109: + case 164: ACCEPT_TOKEN(anon_sym_T); - if (lookahead == '-') ADVANCE(70); + if (lookahead == '-') ADVANCE(120); if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(91); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(141); END_STATE(); - case 110: + case 165: ACCEPT_TOKEN(anon_sym_COLON); END_STATE(); - case 111: + case 166: ACCEPT_TOKEN(anon_sym_COLON); - if (lookahead == '=') ADVANCE(93); + if (lookahead == '=') ADVANCE(143); END_STATE(); - case 112: + case 167: ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); END_STATE(); - case 113: + case 168: ACCEPT_TOKEN(sym_unquoted_record_field_name); - if (lookahead == '-') ADVANCE(71); + if (lookahead == '-') ADVANCE(121); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(113); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(168); END_STATE(); - case 114: + case 169: ACCEPT_TOKEN(sym_numeric_literal); - if (lookahead == '.') ADVANCE(50); + if (lookahead == '.') ADVANCE(99); END_STATE(); - case 115: + case 170: ACCEPT_TOKEN(sym_numeric_literal); - if (lookahead == '.') ADVANCE(50); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(115); + if (lookahead == '.') ADVANCE(99); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(170); END_STATE(); - case 116: + case 171: ACCEPT_TOKEN(sym_numeric_literal); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(116); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(171); END_STATE(); - case 117: + case 172: ACCEPT_TOKEN(sym_variable); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(117); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(172); END_STATE(); - case 118: + case 173: ACCEPT_TOKEN(sym_original_input); END_STATE(); - case 119: + case 174: ACCEPT_TOKEN(aux_sym_immediate_record_field_selector_token1); - if (lookahead == '-') ADVANCE(72); + if (lookahead == '-') ADVANCE(122); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(119); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(174); END_STATE(); - case 120: + case 175: ACCEPT_TOKEN(aux_sym_immediate_record_field_selector_token2); END_STATE(); - case 121: + case 176: ACCEPT_TOKEN(aux_sym_immediate_record_field_selector_token2); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(121); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(176); END_STATE(); - case 122: + case 177: ACCEPT_TOKEN(aux_sym_original_record_field_selector_token1); - if (lookahead == '-') ADVANCE(74); + if (lookahead == '-') ADVANCE(124); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(122); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(177); END_STATE(); - case 123: + case 178: ACCEPT_TOKEN(sym_named_record_field); - if (lookahead == '-') ADVANCE(73); + if (lookahead == '-') ADVANCE(123); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(123); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(178); END_STATE(); - case 124: + case 179: ACCEPT_TOKEN(sym_positional_record_field); END_STATE(); - case 125: + case 180: ACCEPT_TOKEN(sym_positional_record_field); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(125); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(180); END_STATE(); - case 126: + case 181: ACCEPT_TOKEN(anon_sym_POUNDtrue); END_STATE(); - case 127: + case 182: ACCEPT_TOKEN(anon_sym_POUNDfalse); END_STATE(); - case 128: + case 183: ACCEPT_TOKEN(sym_null_literal); END_STATE(); - case 129: + case 184: ACCEPT_TOKEN(anon_sym_DQUOTE); END_STATE(); - case 130: + case 185: ACCEPT_TOKEN(sym_double_quoted_content); if (lookahead == '\t' || lookahead == 0x0b || @@ -1731,27 +1989,27 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || - lookahead == 0xfeff) ADVANCE(130); + lookahead == 0xfeff) ADVANCE(185); if (lookahead != 0 && (lookahead < '\t' || '\r' < lookahead) && lookahead != '"' && - lookahead != '\\') ADVANCE(131); + lookahead != '\\') ADVANCE(186); END_STATE(); - case 131: + case 186: ACCEPT_TOKEN(sym_double_quoted_content); if (lookahead != 0 && lookahead != '\n' && lookahead != '\r' && lookahead != '"' && - lookahead != '\\') ADVANCE(131); + lookahead != '\\') ADVANCE(186); END_STATE(); - case 132: + case 187: ACCEPT_TOKEN(sym_escape_sequence); END_STATE(); - case 133: + case 188: ACCEPT_TOKEN(anon_sym_BQUOTE); END_STATE(); - case 134: + case 189: ACCEPT_TOKEN(sym_backtick_quoted_content); if (lookahead == '\t' || lookahead == 0x0b || @@ -1759,25 +2017,25 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 0x200b || lookahead == 0x2060 || - lookahead == 0xfeff) ADVANCE(134); + lookahead == 0xfeff) ADVANCE(189); if (lookahead != 0 && (lookahead < '\t' || '\r' < lookahead) && - lookahead != '`') ADVANCE(135); + lookahead != '`') ADVANCE(190); END_STATE(); - case 135: + case 190: ACCEPT_TOKEN(sym_backtick_quoted_content); if (lookahead != 0 && lookahead != '\n' && lookahead != '\r' && - lookahead != '`') ADVANCE(135); + lookahead != '`') ADVANCE(190); END_STATE(); - case 136: + case 191: ACCEPT_TOKEN(sym_date_literal); END_STATE(); - case 137: + case 192: ACCEPT_TOKEN(sym_date_time_literal); END_STATE(); - case 138: + case 193: ACCEPT_TOKEN(sym_time_literal); END_STATE(); default: @@ -1787,53 +2045,53 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [0] = {.lex_state = 0}, - [1] = {.lex_state = 76}, - [2] = {.lex_state = 76}, - [3] = {.lex_state = 76}, - [4] = {.lex_state = 76}, - [5] = {.lex_state = 76}, - [6] = {.lex_state = 76}, - [7] = {.lex_state = 76}, + [1] = {.lex_state = 126}, + [2] = {.lex_state = 126}, + [3] = {.lex_state = 126}, + [4] = {.lex_state = 126}, + [5] = {.lex_state = 126}, + [6] = {.lex_state = 126}, + [7] = {.lex_state = 126}, [8] = {.lex_state = 1}, - [9] = {.lex_state = 76}, - [10] = {.lex_state = 1}, - [11] = {.lex_state = 76}, - [12] = {.lex_state = 76}, - [13] = {.lex_state = 76}, - [14] = {.lex_state = 76}, - [15] = {.lex_state = 76}, - [16] = {.lex_state = 76}, + [9] = {.lex_state = 126}, + [10] = {.lex_state = 126}, + [11] = {.lex_state = 1}, + [12] = {.lex_state = 126}, + [13] = {.lex_state = 126}, + [14] = {.lex_state = 126}, + [15] = {.lex_state = 126}, + [16] = {.lex_state = 126}, [17] = {.lex_state = 8}, - [18] = {.lex_state = 8}, - [19] = {.lex_state = 8}, - [20] = {.lex_state = 8}, - [21] = {.lex_state = 77}, - [22] = {.lex_state = 77}, - [23] = {.lex_state = 77}, - [24] = {.lex_state = 77}, - [25] = {.lex_state = 77}, - [26] = {.lex_state = 8}, - [27] = {.lex_state = 77}, - [28] = {.lex_state = 76}, - [29] = {.lex_state = 8}, - [30] = {.lex_state = 76}, - [31] = {.lex_state = 76}, - [32] = {.lex_state = 76}, - [33] = {.lex_state = 77}, - [34] = {.lex_state = 77}, - [35] = {.lex_state = 0}, - [36] = {.lex_state = 0}, - [37] = {.lex_state = 0}, - [38] = {.lex_state = 0}, - [39] = {.lex_state = 77}, - [40] = {.lex_state = 77}, - [41] = {.lex_state = 77}, - [42] = {.lex_state = 76}, - [43] = {.lex_state = 0}, + [18] = {.lex_state = 126}, + [19] = {.lex_state = 126}, + [20] = {.lex_state = 0}, + [21] = {.lex_state = 8}, + [22] = {.lex_state = 8}, + [23] = {.lex_state = 8}, + [24] = {.lex_state = 8}, + [25] = {.lex_state = 8}, + [26] = {.lex_state = 127}, + [27] = {.lex_state = 8}, + [28] = {.lex_state = 127}, + [29] = {.lex_state = 127}, + [30] = {.lex_state = 127}, + [31] = {.lex_state = 127}, + [32] = {.lex_state = 127}, + [33] = {.lex_state = 8}, + [34] = {.lex_state = 126}, + [35] = {.lex_state = 126}, + [36] = {.lex_state = 8}, + [37] = {.lex_state = 126}, + [38] = {.lex_state = 126}, + [39] = {.lex_state = 127}, + [40] = {.lex_state = 127}, + [41] = {.lex_state = 127}, + [42] = {.lex_state = 0}, + [43] = {.lex_state = 127}, [44] = {.lex_state = 0}, - [45] = {.lex_state = 0}, + [45] = {.lex_state = 127}, [46] = {.lex_state = 0}, - [47] = {.lex_state = 0}, + [47] = {.lex_state = 126}, [48] = {.lex_state = 0}, [49] = {.lex_state = 0}, [50] = {.lex_state = 0}, @@ -1858,26 +2116,26 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [69] = {.lex_state = 0}, [70] = {.lex_state = 0}, [71] = {.lex_state = 0}, - [72] = {.lex_state = 76}, - [73] = {.lex_state = 2}, + [72] = {.lex_state = 0}, + [73] = {.lex_state = 0}, [74] = {.lex_state = 0}, [75] = {.lex_state = 0}, [76] = {.lex_state = 0}, - [77] = {.lex_state = 2}, + [77] = {.lex_state = 126}, [78] = {.lex_state = 0}, - [79] = {.lex_state = 76}, + [79] = {.lex_state = 0}, [80] = {.lex_state = 0}, - [81] = {.lex_state = 0}, + [81] = {.lex_state = 2}, [82] = {.lex_state = 0}, - [83] = {.lex_state = 0}, - [84] = {.lex_state = 0}, + [83] = {.lex_state = 2}, + [84] = {.lex_state = 126}, [85] = {.lex_state = 0}, [86] = {.lex_state = 0}, [87] = {.lex_state = 0}, [88] = {.lex_state = 0}, - [89] = {.lex_state = 2}, + [89] = {.lex_state = 0}, [90] = {.lex_state = 0}, - [91] = {.lex_state = 0}, + [91] = {.lex_state = 2}, [92] = {.lex_state = 0}, [93] = {.lex_state = 0}, [94] = {.lex_state = 0}, @@ -1893,13 +2151,13 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [104] = {.lex_state = 0}, [105] = {.lex_state = 0}, [106] = {.lex_state = 0}, - [107] = {.lex_state = 25}, + [107] = {.lex_state = 0}, [108] = {.lex_state = 0}, - [109] = {.lex_state = 37}, + [109] = {.lex_state = 0}, [110] = {.lex_state = 0}, - [111] = {.lex_state = 0}, + [111] = {.lex_state = 36}, [112] = {.lex_state = 0}, - [113] = {.lex_state = 77}, + [113] = {.lex_state = 0}, [114] = {.lex_state = 0}, [115] = {.lex_state = 0}, [116] = {.lex_state = 0}, @@ -1909,16 +2167,35 @@ static const TSLexerMode ts_lex_modes[STATE_COUNT] = { [120] = {.lex_state = 0}, [121] = {.lex_state = 0}, [122] = {.lex_state = 0}, - [123] = {.lex_state = 8}, - [124] = {.lex_state = 0}, + [123] = {.lex_state = 0}, + [124] = {.lex_state = 127}, [125] = {.lex_state = 0}, - [126] = {.lex_state = 76}, + [126] = {.lex_state = 0}, [127] = {.lex_state = 0}, - [128] = {.lex_state = 76}, + [128] = {.lex_state = 0}, [129] = {.lex_state = 0}, [130] = {.lex_state = 0}, - [131] = {.lex_state = 76}, + [131] = {.lex_state = 0}, [132] = {.lex_state = 0}, + [133] = {.lex_state = 48}, + [134] = {.lex_state = 0}, + [135] = {.lex_state = 0}, + [136] = {.lex_state = 126}, + [137] = {.lex_state = 0}, + [138] = {.lex_state = 0}, + [139] = {.lex_state = 0}, + [140] = {.lex_state = 0}, + [141] = {.lex_state = 126}, + [142] = {.lex_state = 0}, + [143] = {.lex_state = 0}, + [144] = {.lex_state = 0}, + [145] = {.lex_state = 0}, + [146] = {.lex_state = 8}, + [147] = {.lex_state = 0}, + [148] = {.lex_state = 0}, + [149] = {.lex_state = 0}, + [150] = {.lex_state = 0}, + [151] = {.lex_state = 126}, }; static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -1945,6 +2222,11 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_LPAREN_PLUS_RPAREN] = ACTIONS(1), [anon_sym_LPAREN0_DASH_RPAREN] = ACTIONS(1), [anon_sym_LPAREN_DASH_RPAREN] = ACTIONS(1), + [anon_sym_LPARENpositive_RPAREN] = ACTIONS(1), + [anon_sym_LPARENnegative_RPAREN] = ACTIONS(1), + [anon_sym_LPARENabsolutely_DASHpositive_RPAREN] = ACTIONS(1), + [anon_sym_LPARENabsolutely_DASHnegative_RPAREN] = ACTIONS(1), + [aux_sym_interval_shorthand_token1] = ACTIONS(1), [anon_sym_T] = ACTIONS(1), [anon_sym_COLON] = ACTIONS(1), [anon_sym_DOT_DOT_DOT] = ACTIONS(1), @@ -1968,28 +2250,28 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_time_literal] = ACTIONS(1), }, [STATE(1)] = { - [sym_source_file] = STATE(120), - [sym_root_expression] = STATE(121), - [sym_open_expression] = STATE(110), - [sym_closed_expression] = STATE(110), - [sym_map_shorthand] = STATE(70), - [sym_expression] = STATE(67), - [sym_parenthesized_expression] = STATE(70), - [sym_tuple_projection] = STATE(70), - [sym_function_call] = STATE(70), - [sym_value] = STATE(55), - [sym_interval_literal] = STATE(64), - [sym_array_literal] = STATE(64), - [sym_tuple_literal] = STATE(64), - [sym_record_literal] = STATE(64), - [sym_incoming_value] = STATE(64), - [sym_record_access] = STATE(64), - [sym_record_field_selector] = STATE(23), - [sym_boolean_literal] = STATE(64), - [sym_quoted_literal] = STATE(64), - [sym_double_quoted_literal] = STATE(38), - [sym_backtick_quoted_literal] = STATE(38), - [sym_temporal_literal] = STATE(64), + [sym_source_file] = STATE(142), + [sym_root_expression] = STATE(138), + [sym_open_expression] = STATE(129), + [sym_closed_expression] = STATE(129), + [sym_map_shorthand] = STATE(74), + [sym_expression] = STATE(75), + [sym_parenthesized_expression] = STATE(74), + [sym_tuple_projection] = STATE(74), + [sym_function_call] = STATE(74), + [sym_value] = STATE(49), + [sym_interval_literal] = STATE(55), + [sym_array_literal] = STATE(55), + [sym_tuple_literal] = STATE(55), + [sym_record_literal] = STATE(55), + [sym_incoming_value] = STATE(55), + [sym_record_access] = STATE(55), + [sym_record_field_selector] = STATE(26), + [sym_boolean_literal] = STATE(55), + [sym_quoted_literal] = STATE(55), + [sym_double_quoted_literal] = STATE(42), + [sym_backtick_quoted_literal] = STATE(42), + [sym_temporal_literal] = STATE(55), [anon_sym_PIPE_GT] = ACTIONS(3), [anon_sym_LPAREN] = ACTIONS(5), [anon_sym_DOLLAR] = ACTIONS(7), @@ -2015,7 +2297,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }; static const uint16_t ts_small_parse_table[] = { - [0] = 23, + [0] = 24, ACTIONS(5), 1, anon_sym_LPAREN, ACTIONS(7), 1, @@ -2038,11 +2320,13 @@ static const uint16_t ts_small_parse_table[] = { sym_function_name, ACTIONS(37), 1, anon_sym_LBRACE, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(86), 1, + STATE(96), 1, sym_function_call, - STATE(100), 1, + STATE(114), 1, + sym_tuple_projection, + STATE(118), 1, sym_value, ACTIONS(23), 2, sym_named_record_field, @@ -2050,13 +2334,13 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, - STATE(97), 2, + STATE(116), 2, sym_positional_argument, sym_named_argument, - STATE(130), 2, + STATE(139), 2, sym_argument_list, sym__trailing_argument_list, ACTIONS(19), 3, @@ -2067,14 +2351,13 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(108), 6, + STATE(130), 5, sym_parenthesized_expression, - sym_tuple_projection, sym__argument_value, sym__nested_open_expression, sym__nested_closed_expression, sym_parameterized_expression, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2084,11 +2367,15 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [92] = 22, - ACTIONS(5), 1, - anon_sym_LPAREN, + [94] = 29, + ACTIONS(3), 1, + anon_sym_PIPE_GT, ACTIONS(7), 1, anon_sym_DOLLAR, + ACTIONS(9), 1, + sym_function_name, + ACTIONS(11), 1, + anon_sym_LBRACE, ACTIONS(13), 1, anon_sym_I, ACTIONS(15), 1, @@ -2101,30 +2388,43 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(35), 1, - sym_function_name, - ACTIONS(37), 1, - anon_sym_LBRACE, ACTIONS(39), 1, - anon_sym_RPAREN, - STATE(23), 1, + anon_sym_LPAREN, + STATE(26), 1, sym_record_field_selector, - STATE(86), 1, - sym_function_call, - STATE(100), 1, + STATE(49), 1, sym_value, + STATE(51), 1, + sym__parenthesized_pipeline_expression, + STATE(75), 1, + sym_expression, + STATE(109), 1, + sym__pipeline_expression, + STATE(110), 1, + sym_record_access, + STATE(129), 1, + sym_open_expression, + STATE(147), 1, + sym_root_expression, + STATE(149), 1, + sym_closed_expression, + STATE(150), 1, + sym__pipeline_open_expression, ACTIONS(23), 2, sym_named_record_field, sym_positional_record_field, ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, - STATE(111), 2, - sym_positional_argument, - sym_named_argument, + STATE(74), 2, + sym_map_shorthand, + sym_parenthesized_expression, + STATE(94), 2, + sym_tuple_projection, + sym_function_call, ACTIONS(19), 3, sym_numeric_literal, sym_variable, @@ -2133,24 +2433,16 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(108), 6, - sym_parenthesized_expression, - sym_tuple_projection, - sym__argument_value, - sym__nested_open_expression, - sym__nested_closed_expression, - sym_parameterized_expression, - STATE(64), 9, + STATE(55), 8, sym_interval_literal, sym_array_literal, sym_tuple_literal, sym_record_literal, sym_incoming_value, - sym_record_access, sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [180] = 22, + [198] = 23, ACTIONS(5), 1, anon_sym_LPAREN, ACTIONS(7), 1, @@ -2173,11 +2465,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_LBRACE, ACTIONS(41), 1, anon_sym_RPAREN, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(86), 1, + STATE(96), 1, sym_function_call, - STATE(100), 1, + STATE(114), 1, + sym_tuple_projection, + STATE(118), 1, sym_value, ACTIONS(23), 2, sym_named_record_field, @@ -2185,10 +2479,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, - STATE(111), 2, + STATE(128), 2, sym_positional_argument, sym_named_argument, ACTIONS(19), 3, @@ -2199,14 +2493,13 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(108), 6, + STATE(130), 5, sym_parenthesized_expression, - sym_tuple_projection, sym__argument_value, sym__nested_open_expression, sym__nested_closed_expression, sym_parameterized_expression, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2216,17 +2509,11 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [268] = 23, - ACTIONS(3), 1, - anon_sym_PIPE_GT, + [288] = 23, ACTIONS(5), 1, anon_sym_LPAREN, ACTIONS(7), 1, anon_sym_DOLLAR, - ACTIONS(9), 1, - sym_function_name, - ACTIONS(11), 1, - anon_sym_LBRACE, ACTIONS(13), 1, anon_sym_I, ACTIONS(15), 1, @@ -2239,26 +2526,32 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - STATE(23), 1, + ACTIONS(35), 1, + sym_function_name, + ACTIONS(37), 1, + anon_sym_LBRACE, + ACTIONS(43), 1, + anon_sym_RPAREN, + STATE(26), 1, sym_record_field_selector, - STATE(55), 1, + STATE(96), 1, + sym_function_call, + STATE(114), 1, + sym_tuple_projection, + STATE(118), 1, sym_value, - STATE(67), 1, - sym_expression, - STATE(122), 1, - sym_root_expression, ACTIONS(23), 2, sym_named_record_field, sym_positional_record_field, ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, - STATE(110), 2, - sym_open_expression, - sym_closed_expression, + STATE(128), 2, + sym_positional_argument, + sym_named_argument, ACTIONS(19), 3, sym_numeric_literal, sym_variable, @@ -2267,12 +2560,13 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(70), 4, - sym_map_shorthand, + STATE(130), 5, sym_parenthesized_expression, - sym_tuple_projection, - sym_function_call, - STATE(64), 9, + sym__argument_value, + sym__nested_open_expression, + sym__nested_closed_expression, + sym_parameterized_expression, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2282,7 +2576,7 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [357] = 21, + [378] = 22, ACTIONS(5), 1, anon_sym_LPAREN, ACTIONS(7), 1, @@ -2303,11 +2597,13 @@ static const uint16_t ts_small_parse_table[] = { sym_function_name, ACTIONS(37), 1, anon_sym_LBRACE, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(86), 1, + STATE(96), 1, sym_function_call, - STATE(100), 1, + STATE(114), 1, + sym_tuple_projection, + STATE(118), 1, sym_value, ACTIONS(23), 2, sym_named_record_field, @@ -2315,10 +2611,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, - STATE(111), 2, + STATE(128), 2, sym_positional_argument, sym_named_argument, ACTIONS(19), 3, @@ -2329,14 +2625,13 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(108), 6, + STATE(130), 5, sym_parenthesized_expression, - sym_tuple_projection, sym__argument_value, sym__nested_open_expression, sym__nested_closed_expression, sym_parameterized_expression, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2346,13 +2641,17 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [442] = 20, + [465] = 23, + ACTIONS(3), 1, + anon_sym_PIPE_GT, ACTIONS(5), 1, anon_sym_LPAREN, ACTIONS(7), 1, anon_sym_DOLLAR, ACTIONS(9), 1, sym_function_name, + ACTIONS(11), 1, + anon_sym_LBRACE, ACTIONS(13), 1, anon_sym_I, ACTIONS(15), 1, @@ -2365,23 +2664,26 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(37), 1, - anon_sym_LBRACE, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(86), 1, - sym_function_call, - STATE(100), 1, + STATE(49), 1, sym_value, + STATE(75), 1, + sym_expression, + STATE(147), 1, + sym_root_expression, ACTIONS(23), 2, sym_named_record_field, sym_positional_record_field, ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, + STATE(129), 2, + sym_open_expression, + sym_closed_expression, ACTIONS(19), 3, sym_numeric_literal, sym_variable, @@ -2390,14 +2692,12 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(112), 6, + STATE(74), 4, + sym_map_shorthand, sym_parenthesized_expression, sym_tuple_projection, - sym__argument_value, - sym__nested_open_expression, - sym__nested_closed_expression, - sym_parameterized_expression, - STATE(64), 9, + sym_function_call, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2407,7 +2707,7 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [523] = 22, + [554] = 23, ACTIONS(7), 1, anon_sym_DOLLAR, ACTIONS(11), 1, @@ -2422,21 +2722,23 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(43), 1, - anon_sym_RBRACE, ACTIONS(45), 1, - anon_sym_COLON, + anon_sym_RBRACE, ACTIONS(47), 1, - anon_sym_DOT_DOT_DOT, + anon_sym_COLON, ACTIONS(49), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(51), 1, sym_unquoted_record_field_name, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(84), 1, + STATE(99), 1, sym_value, - STATE(124), 1, + STATE(119), 1, + sym__array_closed_expression, + STATE(145), 1, sym_tuple_projection, - STATE(131), 1, + STATE(151), 1, sym_record_field_name, ACTIONS(23), 2, sym_named_record_field, @@ -2444,7 +2746,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(79), 2, + STATE(84), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, ACTIONS(19), 3, @@ -2455,11 +2757,11 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(92), 3, + STATE(120), 3, sym__record_entry, sym_record_field, sym_record_spread, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2469,7 +2771,69 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [607] = 22, + [641] = 21, + ACTIONS(5), 1, + anon_sym_LPAREN, + ACTIONS(7), 1, + anon_sym_DOLLAR, + ACTIONS(9), 1, + sym_function_name, + ACTIONS(13), 1, + anon_sym_I, + ACTIONS(15), 1, + anon_sym_T, + ACTIONS(17), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(21), 1, + sym_original_input, + ACTIONS(27), 1, + anon_sym_DQUOTE, + ACTIONS(29), 1, + anon_sym_BQUOTE, + ACTIONS(37), 1, + anon_sym_LBRACE, + STATE(26), 1, + sym_record_field_selector, + STATE(96), 1, + sym_function_call, + STATE(114), 1, + sym_tuple_projection, + STATE(118), 1, + sym_value, + ACTIONS(23), 2, + sym_named_record_field, + sym_positional_record_field, + ACTIONS(25), 2, + anon_sym_POUNDtrue, + anon_sym_POUNDfalse, + STATE(42), 2, + sym_double_quoted_literal, + sym_backtick_quoted_literal, + ACTIONS(19), 3, + sym_numeric_literal, + sym_variable, + sym_null_literal, + ACTIONS(31), 3, + sym_date_literal, + sym_date_time_literal, + sym_time_literal, + STATE(135), 5, + sym_parenthesized_expression, + sym__argument_value, + sym__nested_open_expression, + sym__nested_closed_expression, + sym_parameterized_expression, + STATE(55), 9, + sym_interval_literal, + sym_array_literal, + sym_tuple_literal, + sym_record_literal, + sym_incoming_value, + sym_record_access, + sym_boolean_literal, + sym_quoted_literal, + sym_temporal_literal, + [724] = 22, ACTIONS(7), 1, anon_sym_DOLLAR, ACTIONS(9), 1, @@ -2488,15 +2852,15 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(51), 1, + ACTIONS(53), 1, anon_sym_LPAREN, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, + STATE(49), 1, + sym_value, STATE(51), 1, sym__parenthesized_pipeline_expression, - STATE(55), 1, - sym_value, - STATE(99), 1, + STATE(110), 1, sym_record_access, ACTIONS(23), 2, sym_named_record_field, @@ -2504,10 +2868,10 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, - STATE(118), 2, + STATE(150), 2, sym_closed_expression, sym__pipeline_open_expression, ACTIONS(19), 3, @@ -2518,11 +2882,11 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(98), 3, + STATE(109), 3, sym__pipeline_expression, sym_tuple_projection, sym_function_call, - STATE(64), 8, + STATE(55), 8, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2531,7 +2895,7 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [691] = 20, + [808] = 21, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(13), 1, @@ -2544,19 +2908,21 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(43), 1, - anon_sym_RBRACE, ACTIONS(45), 1, - anon_sym_COLON, + anon_sym_RBRACE, ACTIONS(47), 1, - anon_sym_DOT_DOT_DOT, + anon_sym_COLON, ACTIONS(49), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(51), 1, sym_unquoted_record_field_name, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(105), 1, + STATE(85), 1, sym_value, - STATE(131), 1, + STATE(119), 1, + sym__array_closed_expression, + STATE(151), 1, sym_record_field_name, ACTIONS(23), 2, sym_named_record_field, @@ -2564,7 +2930,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(79), 2, + STATE(84), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, ACTIONS(19), 3, @@ -2575,11 +2941,11 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(92), 3, + STATE(120), 3, sym__record_entry, sym_record_field, sym_record_spread, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2589,7 +2955,7 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [769] = 15, + [889] = 16, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(17), 1, @@ -2600,13 +2966,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(53), 1, - anon_sym_I, ACTIONS(55), 1, + anon_sym_I, + ACTIONS(57), 1, anon_sym_T, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(129), 1, + STATE(106), 1, sym_value, ACTIONS(23), 2, sym_named_record_field, @@ -2614,9 +2980,12 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, + STATE(134), 2, + sym__array_element, + sym__array_closed_expression, ACTIONS(19), 3, sym_numeric_literal, sym_variable, @@ -2625,7 +2994,7 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2635,7 +3004,7 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [830] = 15, + [954] = 15, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(17), 1, @@ -2646,13 +3015,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(53), 1, - anon_sym_I, ACTIONS(55), 1, + anon_sym_I, + ACTIONS(57), 1, anon_sym_T, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(94), 1, + STATE(115), 1, sym_value, ACTIONS(23), 2, sym_named_record_field, @@ -2660,7 +3029,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, ACTIONS(19), 3, @@ -2671,7 +3040,7 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2681,7 +3050,7 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [891] = 15, + [1015] = 15, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(17), 1, @@ -2692,13 +3061,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(53), 1, - anon_sym_I, ACTIONS(55), 1, + anon_sym_I, + ACTIONS(57), 1, anon_sym_T, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(116), 1, + STATE(144), 1, sym_value, ACTIONS(23), 2, sym_named_record_field, @@ -2706,7 +3075,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, ACTIONS(19), 3, @@ -2717,7 +3086,7 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2727,7 +3096,7 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [952] = 15, + [1076] = 15, ACTIONS(11), 1, anon_sym_LBRACE, ACTIONS(17), 1, @@ -2738,13 +3107,13 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(53), 1, - anon_sym_I, ACTIONS(55), 1, + anon_sym_I, + ACTIONS(57), 1, anon_sym_T, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, - STATE(103), 1, + STATE(132), 1, sym_value, ACTIONS(23), 2, sym_named_record_field, @@ -2752,7 +3121,7 @@ static const uint16_t ts_small_parse_table[] = { ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, ACTIONS(19), 3, @@ -2763,7 +3132,7 @@ static const uint16_t ts_small_parse_table[] = { sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(64), 9, + STATE(55), 9, sym_interval_literal, sym_array_literal, sym_tuple_literal, @@ -2773,262 +3142,411 @@ static const uint16_t ts_small_parse_table[] = { sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [1013] = 9, + [1137] = 15, + ACTIONS(11), 1, + anon_sym_LBRACE, + ACTIONS(17), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(21), 1, + sym_original_input, ACTIONS(27), 1, anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(59), 1, - sym_numeric_literal, - STATE(125), 1, - sym_interval_bound, + ACTIONS(55), 1, + anon_sym_I, + ACTIONS(57), 1, + anon_sym_T, + STATE(26), 1, + sym_record_field_selector, + STATE(127), 1, + sym_value, + ACTIONS(23), 2, + sym_named_record_field, + sym_positional_record_field, ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - ACTIONS(57), 2, - anon_sym_PLUSINF, - anon_sym_DASHINF, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, + ACTIONS(19), 3, + sym_numeric_literal, + sym_variable, + sym_null_literal, ACTIONS(31), 3, sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(76), 4, - sym_infinite_bound, + STATE(55), 9, + sym_interval_literal, + sym_array_literal, + sym_tuple_literal, + sym_record_literal, + sym_incoming_value, + sym_record_access, sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [1049] = 9, - ACTIONS(27), 1, - anon_sym_DQUOTE, - ACTIONS(29), 1, - anon_sym_BQUOTE, + [1198] = 13, + ACTIONS(3), 1, + anon_sym_PIPE_GT, + ACTIONS(7), 1, + anon_sym_DOLLAR, + ACTIONS(21), 1, + sym_original_input, + ACTIONS(39), 1, + anon_sym_LPAREN, ACTIONS(59), 1, + sym_function_name, + STATE(26), 1, + sym_record_field_selector, + STATE(51), 1, + sym__parenthesized_pipeline_expression, + STATE(75), 1, + sym_expression, + STATE(143), 1, + sym_open_expression, + ACTIONS(23), 2, + sym_named_record_field, + sym_positional_record_field, + STATE(74), 2, + sym_map_shorthand, + sym_parenthesized_expression, + STATE(80), 2, + sym__pipeline_expression, + sym_record_access, + STATE(94), 2, + sym_tuple_projection, + sym_function_call, + [1242] = 9, + ACTIONS(27), 1, + anon_sym_DQUOTE, + ACTIONS(29), 1, + anon_sym_BQUOTE, + ACTIONS(63), 1, + sym_numeric_literal, + STATE(140), 1, + sym_interval_bound, + ACTIONS(25), 2, + anon_sym_POUNDtrue, + anon_sym_POUNDfalse, + ACTIONS(61), 2, + anon_sym_PLUSINF, + anon_sym_DASHINF, + STATE(42), 2, + sym_double_quoted_literal, + sym_backtick_quoted_literal, + ACTIONS(31), 3, + sym_date_literal, + sym_date_time_literal, + sym_time_literal, + STATE(100), 4, + sym_infinite_bound, + sym_boolean_literal, + sym_quoted_literal, + sym_temporal_literal, + [1278] = 9, + ACTIONS(27), 1, + anon_sym_DQUOTE, + ACTIONS(29), 1, + anon_sym_BQUOTE, + ACTIONS(63), 1, sym_numeric_literal, STATE(102), 1, sym_interval_bound, ACTIONS(25), 2, anon_sym_POUNDtrue, anon_sym_POUNDfalse, - ACTIONS(57), 2, + ACTIONS(61), 2, anon_sym_PLUSINF, anon_sym_DASHINF, - STATE(38), 2, + STATE(42), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, ACTIONS(31), 3, sym_date_literal, sym_date_time_literal, sym_time_literal, - STATE(76), 4, + STATE(100), 4, sym_infinite_bound, sym_boolean_literal, sym_quoted_literal, sym_temporal_literal, - [1085] = 8, + [1314] = 4, + ACTIONS(65), 1, + anon_sym_LPAREN, + STATE(67), 1, + sym_interval_shorthand, + ACTIONS(67), 2, + anon_sym_LBRACK, + anon_sym_RBRACK, + ACTIONS(69), 9, + anon_sym_LPAREN0_PLUS_RPAREN, + anon_sym_LPAREN_PLUS_RPAREN, + anon_sym_LPAREN0_DASH_RPAREN, + anon_sym_LPAREN_DASH_RPAREN, + anon_sym_LPARENpositive_RPAREN, + anon_sym_LPARENnegative_RPAREN, + anon_sym_LPARENabsolutely_DASHpositive_RPAREN, + anon_sym_LPARENabsolutely_DASHnegative_RPAREN, + aux_sym_interval_shorthand_token1, + [1336] = 8, ACTIONS(7), 1, anon_sym_DOLLAR, ACTIONS(21), 1, sym_original_input, - ACTIONS(51), 1, + ACTIONS(53), 1, anon_sym_LPAREN, - ACTIONS(61), 1, + ACTIONS(59), 1, sym_function_name, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, STATE(51), 1, sym__parenthesized_pipeline_expression, ACTIONS(23), 2, sym_named_record_field, sym_positional_record_field, - STATE(80), 4, + STATE(89), 4, sym__pipeline_expression, sym_tuple_projection, sym_function_call, sym_record_access, - [1114] = 8, + [1365] = 8, ACTIONS(7), 1, anon_sym_DOLLAR, ACTIONS(21), 1, sym_original_input, - ACTIONS(51), 1, + ACTIONS(53), 1, anon_sym_LPAREN, - ACTIONS(61), 1, + ACTIONS(59), 1, sym_function_name, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, STATE(51), 1, sym__parenthesized_pipeline_expression, ACTIONS(23), 2, sym_named_record_field, sym_positional_record_field, - STATE(68), 4, + STATE(78), 4, sym__pipeline_expression, sym_tuple_projection, sym_function_call, sym_record_access, - [1143] = 8, + [1394] = 8, ACTIONS(7), 1, anon_sym_DOLLAR, ACTIONS(21), 1, sym_original_input, - ACTIONS(51), 1, + ACTIONS(53), 1, anon_sym_LPAREN, - ACTIONS(61), 1, + ACTIONS(59), 1, sym_function_name, - STATE(23), 1, + STATE(26), 1, sym_record_field_selector, STATE(51), 1, sym__parenthesized_pipeline_expression, ACTIONS(23), 2, sym_named_record_field, sym_positional_record_field, - STATE(88), 4, + STATE(80), 4, sym__pipeline_expression, sym_tuple_projection, sym_function_call, sym_record_access, - [1172] = 8, - ACTIONS(3), 1, - anon_sym_PIPE_GT, - ACTIONS(5), 1, + [1423] = 8, + ACTIONS(7), 1, + anon_sym_DOLLAR, + ACTIONS(21), 1, + sym_original_input, + ACTIONS(53), 1, anon_sym_LPAREN, + ACTIONS(59), 1, + sym_function_name, + STATE(26), 1, + sym_record_field_selector, + STATE(51), 1, + sym__parenthesized_pipeline_expression, + ACTIONS(23), 2, + sym_named_record_field, + sym_positional_record_field, + STATE(86), 4, + sym__pipeline_expression, + sym_tuple_projection, + sym_function_call, + sym_record_access, + [1452] = 8, ACTIONS(7), 1, anon_sym_DOLLAR, - ACTIONS(61), 1, + ACTIONS(21), 1, + sym_original_input, + ACTIONS(53), 1, + anon_sym_LPAREN, + ACTIONS(59), 1, sym_function_name, - STATE(81), 1, - sym_expression, - STATE(82), 1, - sym_parenthesized_expression, - STATE(83), 1, - sym_parenthesized_open_expression, - STATE(70), 3, - sym_map_shorthand, + STATE(26), 1, + sym_record_field_selector, + STATE(51), 1, + sym__parenthesized_pipeline_expression, + ACTIONS(23), 2, + sym_named_record_field, + sym_positional_record_field, + STATE(88), 4, + sym__pipeline_expression, sym_tuple_projection, sym_function_call, - [1199] = 5, - ACTIONS(65), 1, + sym_record_access, + [1481] = 5, + ACTIONS(73), 1, anon_sym_PIPE, - STATE(27), 1, + STATE(30), 1, aux_sym_record_access_repeat1, - STATE(34), 1, + STATE(40), 1, sym_immediate_record_field_selector, - ACTIONS(67), 2, + ACTIONS(75), 2, aux_sym_immediate_record_field_selector_token1, aux_sym_immediate_record_field_selector_token2, - ACTIONS(63), 5, + ACTIONS(71), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1220] = 7, + [1502] = 8, + ACTIONS(3), 1, + anon_sym_PIPE_GT, + ACTIONS(5), 1, + anon_sym_LPAREN, + ACTIONS(7), 1, + anon_sym_DOLLAR, + ACTIONS(59), 1, + sym_function_name, + STATE(87), 1, + sym_expression, + STATE(92), 1, + sym_parenthesized_open_expression, + STATE(93), 1, + sym_parenthesized_expression, + STATE(74), 3, + sym_map_shorthand, + sym_tuple_projection, + sym_function_call, + [1529] = 7, ACTIONS(27), 1, anon_sym_DQUOTE, ACTIONS(29), 1, anon_sym_BQUOTE, - ACTIONS(69), 1, + ACTIONS(77), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(71), 1, + ACTIONS(79), 1, sym_unquoted_record_field_name, - STATE(131), 1, + STATE(151), 1, sym_record_field_name, - STATE(126), 2, + STATE(141), 2, sym_double_quoted_literal, sym_backtick_quoted_literal, - STATE(115), 3, + STATE(126), 3, sym__record_entry, sym_record_field, sym_record_spread, - [1245] = 5, - ACTIONS(75), 1, + [1554] = 5, + ACTIONS(83), 1, anon_sym_PIPE, - STATE(21), 1, + STATE(31), 1, aux_sym_record_access_repeat1, - STATE(34), 1, + STATE(40), 1, sym_immediate_record_field_selector, - ACTIONS(67), 2, + ACTIONS(75), 2, aux_sym_immediate_record_field_selector_token1, aux_sym_immediate_record_field_selector_token2, - ACTIONS(73), 5, + ACTIONS(81), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1266] = 5, - ACTIONS(79), 1, + [1575] = 5, + ACTIONS(87), 1, anon_sym_PIPE, - STATE(27), 1, + STATE(31), 1, aux_sym_record_access_repeat1, - STATE(34), 1, + STATE(40), 1, sym_immediate_record_field_selector, - ACTIONS(67), 2, + ACTIONS(75), 2, aux_sym_immediate_record_field_selector_token1, aux_sym_immediate_record_field_selector_token2, - ACTIONS(77), 5, + ACTIONS(85), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1287] = 5, - ACTIONS(83), 1, + [1596] = 5, + ACTIONS(91), 1, anon_sym_PIPE, - STATE(24), 1, + STATE(31), 1, aux_sym_record_access_repeat1, - STATE(34), 1, + STATE(40), 1, sym_immediate_record_field_selector, - ACTIONS(67), 2, + ACTIONS(93), 2, aux_sym_immediate_record_field_selector_token1, aux_sym_immediate_record_field_selector_token2, - ACTIONS(81), 5, + ACTIONS(89), 5, + ts_builtin_sym_end, + anon_sym_PIPE_GT, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_RBRACE, + [1617] = 5, + ACTIONS(98), 1, + anon_sym_PIPE, + STATE(29), 1, + aux_sym_record_access_repeat1, + STATE(40), 1, + sym_immediate_record_field_selector, + ACTIONS(75), 2, + aux_sym_immediate_record_field_selector_token1, + aux_sym_immediate_record_field_selector_token2, + ACTIONS(96), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1308] = 7, + [1638] = 7, ACTIONS(3), 1, anon_sym_PIPE_GT, ACTIONS(5), 1, anon_sym_LPAREN, ACTIONS(7), 1, anon_sym_DOLLAR, - ACTIONS(61), 1, + ACTIONS(59), 1, sym_function_name, - STATE(67), 1, + STATE(75), 1, sym_expression, - STATE(127), 1, + STATE(143), 1, sym_open_expression, - STATE(70), 4, + STATE(74), 4, sym_map_shorthand, sym_parenthesized_expression, sym_tuple_projection, sym_function_call, - [1333] = 5, - ACTIONS(87), 1, + [1663] = 2, + ACTIONS(102), 1, anon_sym_PIPE, - STATE(27), 1, - aux_sym_record_access_repeat1, - STATE(34), 1, - sym_immediate_record_field_selector, - ACTIONS(89), 2, - aux_sym_immediate_record_field_selector_token1, - aux_sym_immediate_record_field_selector_token2, - ACTIONS(85), 5, + ACTIONS(100), 8, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, + anon_sym_COLON_EQ, anon_sym_RBRACE, - [1354] = 2, - ACTIONS(94), 1, + anon_sym_LBRACK, + anon_sym_RBRACK, + [1677] = 2, + ACTIONS(106), 1, anon_sym_PIPE, - ACTIONS(92), 8, + ACTIONS(104), 8, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, @@ -3037,26 +3555,26 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, anon_sym_LBRACK, anon_sym_RBRACK, - [1368] = 6, + [1691] = 6, ACTIONS(3), 1, anon_sym_PIPE_GT, ACTIONS(5), 1, anon_sym_LPAREN, ACTIONS(7), 1, anon_sym_DOLLAR, - ACTIONS(61), 1, + ACTIONS(59), 1, sym_function_name, - STATE(71), 1, + STATE(79), 1, sym_expression, - STATE(70), 4, + STATE(74), 4, sym_map_shorthand, sym_parenthesized_expression, sym_tuple_projection, sym_function_call, - [1390] = 2, - ACTIONS(98), 1, + [1713] = 2, + ACTIONS(110), 1, anon_sym_PIPE, - ACTIONS(96), 8, + ACTIONS(108), 8, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, @@ -3065,10 +3583,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, anon_sym_LBRACK, anon_sym_RBRACK, - [1404] = 2, - ACTIONS(102), 1, + [1727] = 2, + ACTIONS(114), 1, anon_sym_PIPE, - ACTIONS(100), 8, + ACTIONS(112), 8, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, @@ -3077,22 +3595,21 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, anon_sym_LBRACK, anon_sym_RBRACK, - [1418] = 2, - ACTIONS(106), 1, + [1741] = 2, + ACTIONS(118), 1, anon_sym_PIPE, - ACTIONS(104), 8, + ACTIONS(116), 7, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, - anon_sym_COLON_EQ, anon_sym_RBRACE, - anon_sym_LBRACK, - anon_sym_RBRACK, - [1432] = 2, - ACTIONS(110), 1, + aux_sym_immediate_record_field_selector_token1, + aux_sym_immediate_record_field_selector_token2, + [1754] = 2, + ACTIONS(122), 1, anon_sym_PIPE, - ACTIONS(108), 7, + ACTIONS(120), 7, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, @@ -3100,10 +3617,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, aux_sym_immediate_record_field_selector_token1, aux_sym_immediate_record_field_selector_token2, - [1445] = 2, - ACTIONS(114), 1, + [1767] = 2, + ACTIONS(126), 1, anon_sym_PIPE, - ACTIONS(112), 7, + ACTIONS(124), 7, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, @@ -3111,10 +3628,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, aux_sym_immediate_record_field_selector_token1, aux_sym_immediate_record_field_selector_token2, - [1458] = 2, - ACTIONS(118), 1, + [1780] = 2, + ACTIONS(130), 1, anon_sym_PIPE, - ACTIONS(116), 7, + ACTIONS(128), 7, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, @@ -3122,34 +3639,21 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, anon_sym_LBRACK, anon_sym_RBRACK, - [1471] = 4, - ACTIONS(120), 1, - anon_sym_LPAREN, - STATE(53), 1, - sym_interval_shorthand, - ACTIONS(122), 2, - anon_sym_LBRACK, - anon_sym_RBRACK, - ACTIONS(124), 4, - anon_sym_LPAREN0_PLUS_RPAREN, - anon_sym_LPAREN_PLUS_RPAREN, - anon_sym_LPAREN0_DASH_RPAREN, - anon_sym_LPAREN_DASH_RPAREN, - [1488] = 2, - ACTIONS(128), 1, + [1793] = 2, + ACTIONS(134), 1, anon_sym_PIPE, - ACTIONS(126), 7, + ACTIONS(132), 7, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - anon_sym_LBRACK, - anon_sym_RBRACK, - [1501] = 2, - ACTIONS(132), 1, + aux_sym_immediate_record_field_selector_token1, + aux_sym_immediate_record_field_selector_token2, + [1806] = 2, + ACTIONS(138), 1, anon_sym_PIPE, - ACTIONS(130), 7, + ACTIONS(136), 7, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, @@ -3157,21 +3661,10 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, anon_sym_LBRACK, anon_sym_RBRACK, - [1514] = 2, - ACTIONS(136), 1, - anon_sym_PIPE, - ACTIONS(134), 7, - ts_builtin_sym_end, - anon_sym_PIPE_GT, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - aux_sym_immediate_record_field_selector_token1, - aux_sym_immediate_record_field_selector_token2, - [1527] = 2, - ACTIONS(140), 1, + [1819] = 2, + ACTIONS(142), 1, anon_sym_PIPE, - ACTIONS(138), 7, + ACTIONS(140), 7, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, @@ -3179,50 +3672,50 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RBRACE, aux_sym_immediate_record_field_selector_token1, aux_sym_immediate_record_field_selector_token2, - [1540] = 2, - ACTIONS(144), 1, + [1832] = 2, + ACTIONS(146), 1, anon_sym_PIPE, - ACTIONS(142), 7, + ACTIONS(144), 7, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - aux_sym_immediate_record_field_selector_token1, - aux_sym_immediate_record_field_selector_token2, - [1553] = 3, - ACTIONS(148), 1, - anon_sym_PIPE, + anon_sym_LBRACK, + anon_sym_RBRACK, + [1845] = 3, ACTIONS(150), 1, + anon_sym_PIPE, + ACTIONS(152), 1, anon_sym_LPAREN, - ACTIONS(146), 5, + ACTIONS(148), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1567] = 2, - ACTIONS(154), 1, + [1859] = 2, + ACTIONS(156), 1, anon_sym_PIPE, - ACTIONS(152), 5, + ACTIONS(154), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1578] = 5, - ACTIONS(158), 1, + [1870] = 5, + ACTIONS(160), 1, anon_sym_PIPE, - ACTIONS(161), 1, + ACTIONS(162), 1, anon_sym_PIPE_GT, - STATE(44), 1, + STATE(58), 1, aux_sym_closed_expression_repeat1, - STATE(78), 1, + STATE(82), 1, sym__pipeline_map_shorthand, - ACTIONS(156), 2, + ACTIONS(158), 2, ts_builtin_sym_end, anon_sym_RPAREN, - [1595] = 2, + [1887] = 2, ACTIONS(166), 1, anon_sym_PIPE, ACTIONS(164), 5, @@ -3231,7 +3724,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1606] = 2, + [1898] = 2, ACTIONS(170), 1, anon_sym_PIPE, ACTIONS(168), 5, @@ -3240,35 +3733,29 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1617] = 2, + [1909] = 3, ACTIONS(174), 1, anon_sym_PIPE, - ACTIONS(172), 5, - ts_builtin_sym_end, - anon_sym_PIPE_GT, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - [1628] = 3, - ACTIONS(178), 1, - anon_sym_PIPE, - STATE(48), 1, + STATE(52), 1, aux_sym_open_expression_repeat1, - ACTIONS(176), 4, + ACTIONS(172), 4, ts_builtin_sym_end, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1641] = 2, - ACTIONS(183), 1, + [1922] = 5, + ACTIONS(179), 1, anon_sym_PIPE, - ACTIONS(181), 5, - ts_builtin_sym_end, + ACTIONS(182), 1, anon_sym_PIPE_GT, + STATE(53), 1, + aux_sym_closed_expression_repeat1, + STATE(82), 1, + sym__pipeline_map_shorthand, + ACTIONS(177), 2, + ts_builtin_sym_end, anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_RBRACE, - [1652] = 2, + [1939] = 2, ACTIONS(187), 1, anon_sym_PIPE, ACTIONS(185), 5, @@ -3277,7 +3764,7 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1663] = 2, + [1950] = 2, ACTIONS(191), 1, anon_sym_PIPE, ACTIONS(189), 5, @@ -3286,873 +3773,1011 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1674] = 5, + [1961] = 2, ACTIONS(195), 1, anon_sym_PIPE, - ACTIONS(197), 1, - anon_sym_PIPE_GT, - STATE(44), 1, - aux_sym_closed_expression_repeat1, - STATE(78), 1, - sym__pipeline_map_shorthand, - ACTIONS(193), 2, - ts_builtin_sym_end, - anon_sym_RPAREN, - [1691] = 2, - ACTIONS(201), 1, - anon_sym_PIPE, - ACTIONS(199), 5, + ACTIONS(193), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1702] = 2, - ACTIONS(205), 1, + [1972] = 2, + ACTIONS(199), 1, anon_sym_PIPE, - ACTIONS(203), 5, + ACTIONS(197), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1713] = 5, - ACTIONS(195), 1, + [1983] = 5, + ACTIONS(160), 1, anon_sym_PIPE, - ACTIONS(197), 1, + ACTIONS(162), 1, anon_sym_PIPE_GT, - STATE(52), 1, + STATE(53), 1, aux_sym_closed_expression_repeat1, - STATE(78), 1, + STATE(82), 1, sym__pipeline_map_shorthand, - ACTIONS(207), 2, + ACTIONS(201), 2, ts_builtin_sym_end, anon_sym_RPAREN, - [1730] = 2, - ACTIONS(211), 1, + [2000] = 2, + ACTIONS(205), 1, anon_sym_PIPE, - ACTIONS(209), 5, + ACTIONS(203), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1741] = 2, - ACTIONS(215), 1, + [2011] = 2, + ACTIONS(156), 1, anon_sym_PIPE, - ACTIONS(213), 5, + ACTIONS(154), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1752] = 2, - ACTIONS(219), 1, + [2022] = 2, + ACTIONS(209), 1, anon_sym_PIPE, - ACTIONS(217), 5, + ACTIONS(207), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1763] = 2, - ACTIONS(223), 1, + [2033] = 2, + ACTIONS(213), 1, anon_sym_PIPE, - ACTIONS(221), 5, + ACTIONS(211), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1774] = 2, - ACTIONS(227), 1, + [2044] = 2, + ACTIONS(217), 1, anon_sym_PIPE, - ACTIONS(225), 5, + ACTIONS(215), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1785] = 2, - ACTIONS(231), 1, + [2055] = 2, + ACTIONS(217), 1, anon_sym_PIPE, - ACTIONS(229), 5, + ACTIONS(215), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1796] = 2, - ACTIONS(235), 1, + [2066] = 2, + ACTIONS(221), 1, anon_sym_PIPE, - ACTIONS(233), 5, + ACTIONS(219), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1807] = 2, - ACTIONS(239), 1, + [2077] = 2, + ACTIONS(225), 1, anon_sym_PIPE, - ACTIONS(237), 5, + ACTIONS(223), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1818] = 2, - ACTIONS(243), 1, + [2088] = 2, + ACTIONS(229), 1, anon_sym_PIPE, - ACTIONS(241), 5, + ACTIONS(227), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1829] = 2, - ACTIONS(247), 1, + [2099] = 2, + ACTIONS(233), 1, anon_sym_PIPE, - ACTIONS(245), 5, + ACTIONS(231), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1840] = 2, - ACTIONS(251), 1, + [2110] = 2, + ACTIONS(237), 1, anon_sym_PIPE, - ACTIONS(249), 5, + ACTIONS(235), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1851] = 3, - ACTIONS(255), 1, + [2121] = 2, + ACTIONS(241), 1, anon_sym_PIPE, - STATE(69), 1, - aux_sym_open_expression_repeat1, - ACTIONS(253), 3, + ACTIONS(239), 5, ts_builtin_sym_end, + anon_sym_PIPE_GT, anon_sym_RPAREN, + anon_sym_COMMA, anon_sym_RBRACE, - [1863] = 1, - ACTIONS(176), 5, - ts_builtin_sym_end, + [2132] = 2, + ACTIONS(245), 1, anon_sym_PIPE, + ACTIONS(243), 5, + ts_builtin_sym_end, + anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_COMMA, anon_sym_RBRACE, - [1871] = 3, - ACTIONS(255), 1, + [2143] = 2, + ACTIONS(249), 1, anon_sym_PIPE, - STATE(48), 1, - aux_sym_open_expression_repeat1, - ACTIONS(257), 3, + ACTIONS(247), 5, ts_builtin_sym_end, + anon_sym_PIPE_GT, anon_sym_RPAREN, + anon_sym_COMMA, anon_sym_RBRACE, - [1883] = 2, - ACTIONS(261), 1, + [2154] = 2, + ACTIONS(253), 1, anon_sym_PIPE, - ACTIONS(259), 4, + ACTIONS(251), 5, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, + anon_sym_COMMA, anon_sym_RBRACE, - [1893] = 2, - ACTIONS(265), 1, + [2165] = 2, + ACTIONS(257), 1, anon_sym_PIPE, - ACTIONS(263), 4, + ACTIONS(255), 4, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, anon_sym_RBRACE, - [1903] = 3, - ACTIONS(150), 1, - anon_sym_LPAREN, - ACTIONS(267), 1, - anon_sym_COLON_EQ, - ACTIONS(146), 3, + [2175] = 3, + ACTIONS(261), 1, anon_sym_PIPE, + STATE(76), 1, + aux_sym_open_expression_repeat1, + ACTIONS(259), 3, + ts_builtin_sym_end, anon_sym_RPAREN, - anon_sym_COMMA, - [1915] = 3, - ACTIONS(269), 1, - anon_sym_DQUOTE, - STATE(89), 1, - aux_sym_double_quoted_literal_repeat1, - ACTIONS(271), 2, - sym_double_quoted_content, - sym_escape_sequence, - [1926] = 3, - ACTIONS(255), 1, + anon_sym_RBRACE, + [2187] = 3, + ACTIONS(261), 1, anon_sym_PIPE, - STATE(48), 1, + STATE(52), 1, aux_sym_open_expression_repeat1, - ACTIONS(273), 2, + ACTIONS(263), 3, + ts_builtin_sym_end, + anon_sym_RPAREN, + anon_sym_RBRACE, + [2199] = 3, + ACTIONS(152), 1, + anon_sym_LPAREN, + ACTIONS(265), 1, + anon_sym_COLON_EQ, + ACTIONS(148), 3, + anon_sym_PIPE, anon_sym_RPAREN, anon_sym_COMMA, - [1937] = 1, - ACTIONS(275), 4, + [2211] = 1, + ACTIONS(172), 5, + ts_builtin_sym_end, + anon_sym_PIPE, anon_sym_RPAREN, anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - [1944] = 1, - ACTIONS(277), 4, + anon_sym_RBRACE, + [2219] = 2, + ACTIONS(269), 1, + anon_sym_PIPE, + ACTIONS(267), 4, + ts_builtin_sym_end, + anon_sym_PIPE_GT, anon_sym_RPAREN, + anon_sym_RBRACE, + [2229] = 3, + ACTIONS(261), 1, + anon_sym_PIPE, + STATE(90), 1, + aux_sym_open_expression_repeat1, + ACTIONS(271), 2, anon_sym_COMMA, - anon_sym_LBRACK, - anon_sym_RBRACK, - [1951] = 3, - ACTIONS(279), 1, + anon_sym_RBRACE, + [2240] = 3, + ACTIONS(273), 1, anon_sym_DQUOTE, - STATE(77), 1, + STATE(83), 1, aux_sym_double_quoted_literal_repeat1, - ACTIONS(281), 2, + ACTIONS(275), 2, sym_double_quoted_content, sym_escape_sequence, - [1962] = 2, - ACTIONS(286), 1, + [2251] = 2, + ACTIONS(279), 1, anon_sym_PIPE, - ACTIONS(284), 3, + ACTIONS(277), 3, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, - [1971] = 2, - ACTIONS(288), 1, + [2260] = 3, + ACTIONS(281), 1, + anon_sym_DQUOTE, + STATE(83), 1, + aux_sym_double_quoted_literal_repeat1, + ACTIONS(283), 2, + sym_double_quoted_content, + sym_escape_sequence, + [2271] = 2, + ACTIONS(286), 1, anon_sym_COLON_EQ, - ACTIONS(130), 3, + ACTIONS(128), 3, anon_sym_PIPE, anon_sym_COMMA, anon_sym_RBRACE, - [1980] = 2, + [2280] = 4, + ACTIONS(288), 1, + anon_sym_PIPE, ACTIONS(290), 1, + anon_sym_COMMA, + ACTIONS(292), 1, + anon_sym_RBRACE, + STATE(121), 1, + aux_sym_array_literal_repeat1, + [2293] = 2, + ACTIONS(294), 1, anon_sym_PIPE, - ACTIONS(156), 3, + ACTIONS(177), 3, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, - [1989] = 2, - ACTIONS(294), 1, + [2302] = 2, + ACTIONS(298), 1, anon_sym_PIPE, - ACTIONS(292), 3, + ACTIONS(296), 3, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, - [1998] = 2, + [2311] = 3, + ACTIONS(261), 1, + anon_sym_PIPE, + STATE(95), 1, + aux_sym_open_expression_repeat1, + ACTIONS(300), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + [2322] = 3, + ACTIONS(261), 1, + anon_sym_PIPE, + STATE(97), 1, + aux_sym_open_expression_repeat1, + ACTIONS(302), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + [2333] = 3, + ACTIONS(261), 1, + anon_sym_PIPE, + STATE(52), 1, + aux_sym_open_expression_repeat1, + ACTIONS(304), 2, + anon_sym_COMMA, + anon_sym_RBRACE, + [2344] = 3, + ACTIONS(306), 1, + anon_sym_DQUOTE, + STATE(81), 1, + aux_sym_double_quoted_literal_repeat1, + ACTIONS(308), 2, + sym_double_quoted_content, + sym_escape_sequence, + [2355] = 2, ACTIONS(298), 1, anon_sym_PIPE, ACTIONS(296), 3, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, - [2007] = 2, - ACTIONS(294), 1, + [2364] = 2, + ACTIONS(312), 1, anon_sym_PIPE, - ACTIONS(292), 3, + ACTIONS(310), 3, ts_builtin_sym_end, anon_sym_PIPE_GT, anon_sym_RPAREN, - [2016] = 4, - ACTIONS(300), 1, - anon_sym_PIPE, - ACTIONS(302), 1, + [2373] = 2, + ACTIONS(317), 1, anon_sym_COMMA, - ACTIONS(304), 1, + ACTIONS(314), 3, + anon_sym_PIPE, + anon_sym_RPAREN, anon_sym_RBRACE, - STATE(106), 1, - aux_sym_array_literal_repeat1, - [2029] = 3, - ACTIONS(255), 1, + [2382] = 3, + ACTIONS(261), 1, anon_sym_PIPE, - STATE(48), 1, + STATE(52), 1, aux_sym_open_expression_repeat1, - ACTIONS(306), 2, + ACTIONS(319), 2, anon_sym_RPAREN, anon_sym_COMMA, - [2040] = 3, - ACTIONS(255), 1, + [2393] = 3, + ACTIONS(261), 1, anon_sym_PIPE, - STATE(85), 1, + STATE(101), 1, aux_sym_open_expression_repeat1, - ACTIONS(308), 2, + ACTIONS(321), 2, anon_sym_RPAREN, anon_sym_COMMA, - [2051] = 3, - ACTIONS(312), 1, - anon_sym_COMMA, - STATE(87), 1, - aux_sym_array_literal_repeat1, - ACTIONS(310), 2, - anon_sym_RPAREN, - anon_sym_RBRACE, - [2062] = 3, - ACTIONS(255), 1, + [2404] = 3, + ACTIONS(261), 1, anon_sym_PIPE, - STATE(74), 1, + STATE(52), 1, aux_sym_open_expression_repeat1, - ACTIONS(315), 2, + ACTIONS(323), 2, anon_sym_RPAREN, anon_sym_COMMA, - [2073] = 3, - ACTIONS(317), 1, - anon_sym_DQUOTE, - STATE(77), 1, - aux_sym_double_quoted_literal_repeat1, - ACTIONS(319), 2, - sym_double_quoted_content, - sym_escape_sequence, - [2084] = 3, - ACTIONS(321), 1, + [2415] = 1, + ACTIONS(325), 4, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_LBRACK, + anon_sym_RBRACK, + [2422] = 4, + ACTIONS(290), 1, anon_sym_COMMA, - ACTIONS(323), 1, + ACTIONS(292), 1, anon_sym_RBRACE, - STATE(96), 1, - aux_sym_record_literal_repeat1, - [2094] = 3, - ACTIONS(302), 1, + ACTIONS(327), 1, + anon_sym_PIPE, + STATE(121), 1, + aux_sym_array_literal_repeat1, + [2435] = 1, + ACTIONS(329), 4, + anon_sym_RPAREN, anon_sym_COMMA, - ACTIONS(325), 1, + anon_sym_LBRACK, + anon_sym_RBRACK, + [2442] = 3, + ACTIONS(261), 1, + anon_sym_PIPE, + STATE(52), 1, + aux_sym_open_expression_repeat1, + ACTIONS(331), 2, anon_sym_RPAREN, - STATE(87), 1, - aux_sym_array_literal_repeat1, - [2104] = 3, - ACTIONS(321), 1, anon_sym_COMMA, - ACTIONS(327), 1, - anon_sym_RBRACE, - STATE(90), 1, - aux_sym_record_literal_repeat1, - [2114] = 3, - ACTIONS(329), 1, + [2453] = 1, + ACTIONS(333), 3, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + [2459] = 3, + ACTIONS(335), 1, anon_sym_RPAREN, - ACTIONS(331), 1, + ACTIONS(337), 1, anon_sym_COMMA, - STATE(101), 1, - aux_sym_argument_list_repeat1, - [2124] = 1, - ACTIONS(310), 3, + STATE(103), 1, + aux_sym_tuple_literal_repeat1, + [2469] = 3, + ACTIONS(340), 1, anon_sym_RPAREN, + ACTIONS(342), 1, anon_sym_COMMA, + STATE(113), 1, + aux_sym_argument_list_repeat1, + [2479] = 3, + ACTIONS(344), 1, + anon_sym_COMMA, + ACTIONS(346), 1, anon_sym_RBRACE, - [2130] = 2, - ACTIONS(209), 1, + STATE(108), 1, + aux_sym_record_literal_repeat1, + [2489] = 2, + ACTIONS(288), 1, anon_sym_PIPE, - ACTIONS(333), 2, + ACTIONS(348), 2, anon_sym_COMMA, anon_sym_RBRACE, - [2138] = 3, - ACTIONS(336), 1, + [2497] = 3, + ACTIONS(350), 1, anon_sym_COMMA, - ACTIONS(339), 1, + ACTIONS(353), 1, anon_sym_RBRACE, - STATE(96), 1, - aux_sym_record_literal_repeat1, - [2148] = 3, - ACTIONS(341), 1, - anon_sym_RPAREN, - ACTIONS(343), 1, + STATE(107), 1, + aux_sym_array_literal_repeat1, + [2507] = 3, + ACTIONS(355), 1, anon_sym_COMMA, - STATE(93), 1, - aux_sym_argument_list_repeat1, - [2158] = 3, - ACTIONS(255), 1, + ACTIONS(358), 1, + anon_sym_RBRACE, + STATE(108), 1, + aux_sym_record_literal_repeat1, + [2517] = 3, + ACTIONS(261), 1, anon_sym_PIPE, - ACTIONS(345), 1, + ACTIONS(360), 1, anon_sym_RPAREN, - STATE(104), 1, + STATE(117), 1, aux_sym_open_expression_repeat1, - [2168] = 3, - ACTIONS(241), 1, + [2527] = 3, + ACTIONS(189), 1, anon_sym_PIPE_GT, - ACTIONS(347), 1, - anon_sym_PIPE, - ACTIONS(349), 1, + ACTIONS(317), 1, anon_sym_RPAREN, - [2178] = 2, - ACTIONS(351), 1, + ACTIONS(362), 1, anon_sym_PIPE, - ACTIONS(353), 2, - anon_sym_RPAREN, + [2537] = 3, + ACTIONS(364), 1, + aux_sym_tuple_projection_token1, + ACTIONS(366), 1, + aux_sym_original_record_field_selector_token1, + STATE(32), 1, + sym_original_record_field_selector, + [2547] = 2, + ACTIONS(164), 1, + anon_sym_PIPE, + ACTIONS(368), 2, anon_sym_COMMA, - [2186] = 3, - ACTIONS(355), 1, + anon_sym_RBRACE, + [2555] = 3, + ACTIONS(371), 1, anon_sym_RPAREN, - ACTIONS(357), 1, + ACTIONS(373), 1, anon_sym_COMMA, - STATE(101), 1, + STATE(113), 1, aux_sym_argument_list_repeat1, - [2196] = 1, - ACTIONS(360), 3, + [2565] = 2, + ACTIONS(376), 1, + anon_sym_PIPE, + ACTIONS(378), 2, anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - [2202] = 3, - ACTIONS(302), 1, anon_sym_COMMA, - ACTIONS(362), 1, + [2573] = 3, + ACTIONS(380), 1, anon_sym_RPAREN, - STATE(91), 1, - aux_sym_array_literal_repeat1, - [2212] = 3, - ACTIONS(255), 1, + ACTIONS(382), 1, + anon_sym_COMMA, + STATE(122), 1, + aux_sym_tuple_literal_repeat1, + [2583] = 3, + ACTIONS(384), 1, + anon_sym_RPAREN, + ACTIONS(386), 1, + anon_sym_COMMA, + STATE(104), 1, + aux_sym_argument_list_repeat1, + [2593] = 3, + ACTIONS(261), 1, anon_sym_PIPE, - ACTIONS(364), 1, + ACTIONS(388), 1, anon_sym_RPAREN, - STATE(48), 1, + STATE(52), 1, aux_sym_open_expression_repeat1, - [2222] = 3, - ACTIONS(302), 1, + [2603] = 2, + ACTIONS(390), 1, + anon_sym_PIPE, + ACTIONS(378), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + [2611] = 3, + ACTIONS(290), 1, anon_sym_COMMA, - ACTIONS(304), 1, + ACTIONS(392), 1, anon_sym_RBRACE, - STATE(106), 1, + STATE(123), 1, aux_sym_array_literal_repeat1, - [2232] = 3, - ACTIONS(302), 1, + [2621] = 3, + ACTIONS(344), 1, anon_sym_COMMA, - ACTIONS(366), 1, + ACTIONS(394), 1, anon_sym_RBRACE, - STATE(87), 1, - aux_sym_array_literal_repeat1, - [2242] = 3, - ACTIONS(368), 1, - aux_sym_tuple_projection_token1, - ACTIONS(370), 1, - aux_sym_original_record_field_selector_token1, - STATE(25), 1, - sym_original_record_field_selector, - [2252] = 1, - ACTIONS(372), 2, - anon_sym_RPAREN, + STATE(105), 1, + aux_sym_record_literal_repeat1, + [2631] = 3, + ACTIONS(290), 1, anon_sym_COMMA, - [2257] = 2, - ACTIONS(374), 1, - anon_sym_BQUOTE, - ACTIONS(376), 1, - sym_backtick_quoted_content, - [2264] = 1, - ACTIONS(378), 2, - ts_builtin_sym_end, - anon_sym_RPAREN, - [2269] = 1, - ACTIONS(355), 2, - anon_sym_RPAREN, + ACTIONS(396), 1, + anon_sym_RBRACE, + STATE(107), 1, + aux_sym_array_literal_repeat1, + [2641] = 3, + ACTIONS(382), 1, anon_sym_COMMA, - [2274] = 1, - ACTIONS(380), 2, + ACTIONS(398), 1, anon_sym_RPAREN, + STATE(103), 1, + aux_sym_tuple_literal_repeat1, + [2651] = 3, + ACTIONS(290), 1, anon_sym_COMMA, - [2279] = 2, - ACTIONS(382), 1, + ACTIONS(400), 1, + anon_sym_RBRACE, + STATE(107), 1, + aux_sym_array_literal_repeat1, + [2661] = 2, + ACTIONS(402), 1, aux_sym_tuple_projection_token1, - ACTIONS(384), 1, + ACTIONS(404), 1, anon_sym_CARET, - [2286] = 1, - ACTIONS(386), 2, + [2668] = 1, + ACTIONS(406), 2, anon_sym_COMMA, anon_sym_RBRACE, - [2291] = 1, - ACTIONS(339), 2, + [2673] = 1, + ACTIONS(358), 2, anon_sym_COMMA, anon_sym_RBRACE, - [2296] = 1, - ACTIONS(388), 2, + [2678] = 1, + ACTIONS(408), 2, anon_sym_COMMA, anon_sym_RBRACE, - [2301] = 1, - ACTIONS(390), 2, + [2683] = 1, + ACTIONS(371), 2, anon_sym_RPAREN, anon_sym_COMMA, - [2306] = 1, - ACTIONS(392), 1, + [2688] = 1, + ACTIONS(410), 2, + ts_builtin_sym_end, anon_sym_RPAREN, - [2310] = 1, - ACTIONS(394), 1, + [2693] = 1, + ACTIONS(412), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + [2698] = 1, + ACTIONS(414), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + [2703] = 1, + ACTIONS(335), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + [2708] = 2, + ACTIONS(416), 1, + anon_sym_BQUOTE, + ACTIONS(418), 1, + sym_backtick_quoted_content, + [2715] = 1, + ACTIONS(353), 2, + anon_sym_COMMA, anon_sym_RBRACE, - [2314] = 1, - ACTIONS(396), 1, - ts_builtin_sym_end, - [2318] = 1, - ACTIONS(398), 1, + [2720] = 1, + ACTIONS(420), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + [2725] = 1, + ACTIONS(422), 1, + anon_sym_LPAREN, + [2729] = 1, + ACTIONS(424), 1, + anon_sym_RBRACE, + [2733] = 1, + ACTIONS(426), 1, ts_builtin_sym_end, - [2322] = 1, - ACTIONS(400), 1, + [2737] = 1, + ACTIONS(428), 1, anon_sym_RPAREN, - [2326] = 1, - ACTIONS(402), 1, - aux_sym_tuple_projection_token1, - [2330] = 1, - ACTIONS(300), 1, - anon_sym_PIPE, - [2334] = 1, - ACTIONS(404), 1, + [2741] = 1, + ACTIONS(430), 1, anon_sym_COMMA, - [2338] = 1, - ACTIONS(288), 1, + [2745] = 1, + ACTIONS(286), 1, anon_sym_COLON_EQ, - [2342] = 1, - ACTIONS(406), 1, + [2749] = 1, + ACTIONS(432), 1, + ts_builtin_sym_end, + [2753] = 1, + ACTIONS(434), 1, anon_sym_RBRACE, - [2346] = 1, - ACTIONS(408), 1, - anon_sym_LPAREN, - [2350] = 1, - ACTIONS(410), 1, + [2757] = 1, + ACTIONS(436), 1, anon_sym_COMMA, - [2354] = 1, - ACTIONS(412), 1, + [2761] = 1, + ACTIONS(438), 1, + anon_sym_PIPE, + [2765] = 1, + ACTIONS(440), 1, + aux_sym_tuple_projection_token1, + [2769] = 1, + ACTIONS(442), 1, anon_sym_RPAREN, - [2358] = 1, - ACTIONS(414), 1, - anon_sym_COLON_EQ, - [2362] = 1, - ACTIONS(416), 1, + [2773] = 1, + ACTIONS(444), 1, anon_sym_BQUOTE, + [2777] = 1, + ACTIONS(446), 1, + anon_sym_RPAREN, + [2781] = 1, + ACTIONS(449), 1, + anon_sym_RPAREN, + [2785] = 1, + ACTIONS(451), 1, + anon_sym_COLON_EQ, }; static const uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(2)] = 0, - [SMALL_STATE(3)] = 92, - [SMALL_STATE(4)] = 180, - [SMALL_STATE(5)] = 268, - [SMALL_STATE(6)] = 357, - [SMALL_STATE(7)] = 442, - [SMALL_STATE(8)] = 523, - [SMALL_STATE(9)] = 607, - [SMALL_STATE(10)] = 691, - [SMALL_STATE(11)] = 769, - [SMALL_STATE(12)] = 830, - [SMALL_STATE(13)] = 891, - [SMALL_STATE(14)] = 952, - [SMALL_STATE(15)] = 1013, - [SMALL_STATE(16)] = 1049, - [SMALL_STATE(17)] = 1085, - [SMALL_STATE(18)] = 1114, - [SMALL_STATE(19)] = 1143, - [SMALL_STATE(20)] = 1172, - [SMALL_STATE(21)] = 1199, - [SMALL_STATE(22)] = 1220, - [SMALL_STATE(23)] = 1245, - [SMALL_STATE(24)] = 1266, - [SMALL_STATE(25)] = 1287, - [SMALL_STATE(26)] = 1308, - [SMALL_STATE(27)] = 1333, - [SMALL_STATE(28)] = 1354, - [SMALL_STATE(29)] = 1368, - [SMALL_STATE(30)] = 1390, - [SMALL_STATE(31)] = 1404, - [SMALL_STATE(32)] = 1418, - [SMALL_STATE(33)] = 1432, - [SMALL_STATE(34)] = 1445, - [SMALL_STATE(35)] = 1458, - [SMALL_STATE(36)] = 1471, - [SMALL_STATE(37)] = 1488, - [SMALL_STATE(38)] = 1501, - [SMALL_STATE(39)] = 1514, - [SMALL_STATE(40)] = 1527, - [SMALL_STATE(41)] = 1540, - [SMALL_STATE(42)] = 1553, - [SMALL_STATE(43)] = 1567, - [SMALL_STATE(44)] = 1578, - [SMALL_STATE(45)] = 1595, - [SMALL_STATE(46)] = 1606, - [SMALL_STATE(47)] = 1617, - [SMALL_STATE(48)] = 1628, - [SMALL_STATE(49)] = 1641, - [SMALL_STATE(50)] = 1652, - [SMALL_STATE(51)] = 1663, - [SMALL_STATE(52)] = 1674, - [SMALL_STATE(53)] = 1691, - [SMALL_STATE(54)] = 1702, - [SMALL_STATE(55)] = 1713, - [SMALL_STATE(56)] = 1730, - [SMALL_STATE(57)] = 1741, - [SMALL_STATE(58)] = 1752, - [SMALL_STATE(59)] = 1763, - [SMALL_STATE(60)] = 1774, - [SMALL_STATE(61)] = 1785, - [SMALL_STATE(62)] = 1796, - [SMALL_STATE(63)] = 1807, - [SMALL_STATE(64)] = 1818, - [SMALL_STATE(65)] = 1829, - [SMALL_STATE(66)] = 1840, - [SMALL_STATE(67)] = 1851, - [SMALL_STATE(68)] = 1863, - [SMALL_STATE(69)] = 1871, - [SMALL_STATE(70)] = 1883, - [SMALL_STATE(71)] = 1893, - [SMALL_STATE(72)] = 1903, - [SMALL_STATE(73)] = 1915, - [SMALL_STATE(74)] = 1926, - [SMALL_STATE(75)] = 1937, - [SMALL_STATE(76)] = 1944, - [SMALL_STATE(77)] = 1951, - [SMALL_STATE(78)] = 1962, - [SMALL_STATE(79)] = 1971, - [SMALL_STATE(80)] = 1980, - [SMALL_STATE(81)] = 1989, - [SMALL_STATE(82)] = 1998, - [SMALL_STATE(83)] = 2007, - [SMALL_STATE(84)] = 2016, - [SMALL_STATE(85)] = 2029, - [SMALL_STATE(86)] = 2040, - [SMALL_STATE(87)] = 2051, - [SMALL_STATE(88)] = 2062, - [SMALL_STATE(89)] = 2073, - [SMALL_STATE(90)] = 2084, - [SMALL_STATE(91)] = 2094, - [SMALL_STATE(92)] = 2104, - [SMALL_STATE(93)] = 2114, - [SMALL_STATE(94)] = 2124, - [SMALL_STATE(95)] = 2130, - [SMALL_STATE(96)] = 2138, - [SMALL_STATE(97)] = 2148, - [SMALL_STATE(98)] = 2158, - [SMALL_STATE(99)] = 2168, - [SMALL_STATE(100)] = 2178, - [SMALL_STATE(101)] = 2186, - [SMALL_STATE(102)] = 2196, - [SMALL_STATE(103)] = 2202, - [SMALL_STATE(104)] = 2212, - [SMALL_STATE(105)] = 2222, - [SMALL_STATE(106)] = 2232, - [SMALL_STATE(107)] = 2242, - [SMALL_STATE(108)] = 2252, - [SMALL_STATE(109)] = 2257, - [SMALL_STATE(110)] = 2264, - [SMALL_STATE(111)] = 2269, - [SMALL_STATE(112)] = 2274, - [SMALL_STATE(113)] = 2279, - [SMALL_STATE(114)] = 2286, - [SMALL_STATE(115)] = 2291, - [SMALL_STATE(116)] = 2296, - [SMALL_STATE(117)] = 2301, - [SMALL_STATE(118)] = 2306, - [SMALL_STATE(119)] = 2310, - [SMALL_STATE(120)] = 2314, - [SMALL_STATE(121)] = 2318, - [SMALL_STATE(122)] = 2322, - [SMALL_STATE(123)] = 2326, - [SMALL_STATE(124)] = 2330, - [SMALL_STATE(125)] = 2334, - [SMALL_STATE(126)] = 2338, - [SMALL_STATE(127)] = 2342, - [SMALL_STATE(128)] = 2346, - [SMALL_STATE(129)] = 2350, - [SMALL_STATE(130)] = 2354, - [SMALL_STATE(131)] = 2358, - [SMALL_STATE(132)] = 2362, + [SMALL_STATE(3)] = 94, + [SMALL_STATE(4)] = 198, + [SMALL_STATE(5)] = 288, + [SMALL_STATE(6)] = 378, + [SMALL_STATE(7)] = 465, + [SMALL_STATE(8)] = 554, + [SMALL_STATE(9)] = 641, + [SMALL_STATE(10)] = 724, + [SMALL_STATE(11)] = 808, + [SMALL_STATE(12)] = 889, + [SMALL_STATE(13)] = 954, + [SMALL_STATE(14)] = 1015, + [SMALL_STATE(15)] = 1076, + [SMALL_STATE(16)] = 1137, + [SMALL_STATE(17)] = 1198, + [SMALL_STATE(18)] = 1242, + [SMALL_STATE(19)] = 1278, + [SMALL_STATE(20)] = 1314, + [SMALL_STATE(21)] = 1336, + [SMALL_STATE(22)] = 1365, + [SMALL_STATE(23)] = 1394, + [SMALL_STATE(24)] = 1423, + [SMALL_STATE(25)] = 1452, + [SMALL_STATE(26)] = 1481, + [SMALL_STATE(27)] = 1502, + [SMALL_STATE(28)] = 1529, + [SMALL_STATE(29)] = 1554, + [SMALL_STATE(30)] = 1575, + [SMALL_STATE(31)] = 1596, + [SMALL_STATE(32)] = 1617, + [SMALL_STATE(33)] = 1638, + [SMALL_STATE(34)] = 1663, + [SMALL_STATE(35)] = 1677, + [SMALL_STATE(36)] = 1691, + [SMALL_STATE(37)] = 1713, + [SMALL_STATE(38)] = 1727, + [SMALL_STATE(39)] = 1741, + [SMALL_STATE(40)] = 1754, + [SMALL_STATE(41)] = 1767, + [SMALL_STATE(42)] = 1780, + [SMALL_STATE(43)] = 1793, + [SMALL_STATE(44)] = 1806, + [SMALL_STATE(45)] = 1819, + [SMALL_STATE(46)] = 1832, + [SMALL_STATE(47)] = 1845, + [SMALL_STATE(48)] = 1859, + [SMALL_STATE(49)] = 1870, + [SMALL_STATE(50)] = 1887, + [SMALL_STATE(51)] = 1898, + [SMALL_STATE(52)] = 1909, + [SMALL_STATE(53)] = 1922, + [SMALL_STATE(54)] = 1939, + [SMALL_STATE(55)] = 1950, + [SMALL_STATE(56)] = 1961, + [SMALL_STATE(57)] = 1972, + [SMALL_STATE(58)] = 1983, + [SMALL_STATE(59)] = 2000, + [SMALL_STATE(60)] = 2011, + [SMALL_STATE(61)] = 2022, + [SMALL_STATE(62)] = 2033, + [SMALL_STATE(63)] = 2044, + [SMALL_STATE(64)] = 2055, + [SMALL_STATE(65)] = 2066, + [SMALL_STATE(66)] = 2077, + [SMALL_STATE(67)] = 2088, + [SMALL_STATE(68)] = 2099, + [SMALL_STATE(69)] = 2110, + [SMALL_STATE(70)] = 2121, + [SMALL_STATE(71)] = 2132, + [SMALL_STATE(72)] = 2143, + [SMALL_STATE(73)] = 2154, + [SMALL_STATE(74)] = 2165, + [SMALL_STATE(75)] = 2175, + [SMALL_STATE(76)] = 2187, + [SMALL_STATE(77)] = 2199, + [SMALL_STATE(78)] = 2211, + [SMALL_STATE(79)] = 2219, + [SMALL_STATE(80)] = 2229, + [SMALL_STATE(81)] = 2240, + [SMALL_STATE(82)] = 2251, + [SMALL_STATE(83)] = 2260, + [SMALL_STATE(84)] = 2271, + [SMALL_STATE(85)] = 2280, + [SMALL_STATE(86)] = 2293, + [SMALL_STATE(87)] = 2302, + [SMALL_STATE(88)] = 2311, + [SMALL_STATE(89)] = 2322, + [SMALL_STATE(90)] = 2333, + [SMALL_STATE(91)] = 2344, + [SMALL_STATE(92)] = 2355, + [SMALL_STATE(93)] = 2364, + [SMALL_STATE(94)] = 2373, + [SMALL_STATE(95)] = 2382, + [SMALL_STATE(96)] = 2393, + [SMALL_STATE(97)] = 2404, + [SMALL_STATE(98)] = 2415, + [SMALL_STATE(99)] = 2422, + [SMALL_STATE(100)] = 2435, + [SMALL_STATE(101)] = 2442, + [SMALL_STATE(102)] = 2453, + [SMALL_STATE(103)] = 2459, + [SMALL_STATE(104)] = 2469, + [SMALL_STATE(105)] = 2479, + [SMALL_STATE(106)] = 2489, + [SMALL_STATE(107)] = 2497, + [SMALL_STATE(108)] = 2507, + [SMALL_STATE(109)] = 2517, + [SMALL_STATE(110)] = 2527, + [SMALL_STATE(111)] = 2537, + [SMALL_STATE(112)] = 2547, + [SMALL_STATE(113)] = 2555, + [SMALL_STATE(114)] = 2565, + [SMALL_STATE(115)] = 2573, + [SMALL_STATE(116)] = 2583, + [SMALL_STATE(117)] = 2593, + [SMALL_STATE(118)] = 2603, + [SMALL_STATE(119)] = 2611, + [SMALL_STATE(120)] = 2621, + [SMALL_STATE(121)] = 2631, + [SMALL_STATE(122)] = 2641, + [SMALL_STATE(123)] = 2651, + [SMALL_STATE(124)] = 2661, + [SMALL_STATE(125)] = 2668, + [SMALL_STATE(126)] = 2673, + [SMALL_STATE(127)] = 2678, + [SMALL_STATE(128)] = 2683, + [SMALL_STATE(129)] = 2688, + [SMALL_STATE(130)] = 2693, + [SMALL_STATE(131)] = 2698, + [SMALL_STATE(132)] = 2703, + [SMALL_STATE(133)] = 2708, + [SMALL_STATE(134)] = 2715, + [SMALL_STATE(135)] = 2720, + [SMALL_STATE(136)] = 2725, + [SMALL_STATE(137)] = 2729, + [SMALL_STATE(138)] = 2733, + [SMALL_STATE(139)] = 2737, + [SMALL_STATE(140)] = 2741, + [SMALL_STATE(141)] = 2745, + [SMALL_STATE(142)] = 2749, + [SMALL_STATE(143)] = 2753, + [SMALL_STATE(144)] = 2757, + [SMALL_STATE(145)] = 2761, + [SMALL_STATE(146)] = 2765, + [SMALL_STATE(147)] = 2769, + [SMALL_STATE(148)] = 2773, + [SMALL_STATE(149)] = 2777, + [SMALL_STATE(150)] = 2781, + [SMALL_STATE(151)] = 2785, }; static const TSParseActionEntry ts_parse_actions[] = { [0] = {.entry = {.count = 0, .reusable = false}}, [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), - [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), - [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(42), - [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(36), - [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(128), - [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), - [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(72), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [9] = {.entry = {.count = 1, .reusable = false}}, SHIFT(47), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(20), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(136), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(77), [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), - [39] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__trailing_argument_list, 2, 0, 0), - [41] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__trailing_argument_list, 3, 0, 0), - [43] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), - [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), - [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [53] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [63] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_access, 2, 0, 8), - [65] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_access, 2, 0, 8), - [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [69] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [71] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [73] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_access, 1, 0, 2), - [75] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_access, 1, 0, 2), - [77] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_access, 3, 0, 11), - [79] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_access, 3, 0, 11), - [81] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_access, 2, 0, 6), - [83] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_access, 2, 0, 6), - [85] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_access_repeat1, 2, 0, 12), - [87] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_record_access_repeat1, 2, 0, 12), - [89] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_record_access_repeat1, 2, 0, 12), SHIFT_REPEAT(33), - [92] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_backtick_quoted_literal, 2, 0, 0), - [94] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_backtick_quoted_literal, 2, 0, 0), - [96] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_backtick_quoted_literal, 3, 0, 0), - [98] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_backtick_quoted_literal, 3, 0, 0), + [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), + [41] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__trailing_argument_list, 2, 0, 0), + [43] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__trailing_argument_list, 3, 0, 0), + [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [49] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(141), + [53] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(18), + [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [69] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [71] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_access, 1, 0, 2), + [73] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_access, 1, 0, 2), + [75] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [77] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [79] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [81] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_access, 3, 0, 11), + [83] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_access, 3, 0, 11), + [85] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_access, 2, 0, 8), + [87] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_access, 2, 0, 8), + [89] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_access_repeat1, 2, 0, 12), + [91] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_record_access_repeat1, 2, 0, 12), + [93] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_record_access_repeat1, 2, 0, 12), SHIFT_REPEAT(39), + [96] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_access, 2, 0, 6), + [98] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_access, 2, 0, 6), [100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_double_quoted_literal, 3, 0, 0), [102] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_double_quoted_literal, 3, 0, 0), - [104] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_double_quoted_literal, 2, 0, 0), - [106] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_double_quoted_literal, 2, 0, 0), - [108] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_immediate_record_field_selector, 1, 0, 0), - [110] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_immediate_record_field_selector, 1, 0, 0), - [112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_access_repeat1, 1, 0, 2), - [114] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_record_access_repeat1, 1, 0, 2), - [116] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temporal_literal, 1, 0, 0), - [118] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temporal_literal, 1, 0, 0), - [120] = {.entry = {.count = 1, .reusable = false}}, SHIFT(15), - [122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), - [124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean_literal, 1, 0, 0), - [128] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean_literal, 1, 0, 0), - [130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_quoted_literal, 1, 0, 0), - [132] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_quoted_literal, 1, 0, 0), - [134] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_original_record_field_selector, 1, 0, 0), - [136] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_original_record_field_selector, 1, 0, 0), - [138] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_original_record_field_selector, 1, 0, 5), - [140] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_original_record_field_selector, 1, 0, 5), - [142] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_field_selector, 1, 0, 0), - [144] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_field_selector, 1, 0, 0), - [146] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 1, 0, 1), - [148] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 1, 0, 1), - [150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), - [152] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interval_literal, 6, 0, 15), - [154] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interval_literal, 6, 0, 15), - [156] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_closed_expression_repeat1, 2, 0, 0), - [158] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_closed_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(17), - [161] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_closed_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(20), - [164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 3, 0, 0), - [166] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 3, 0, 0), - [168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_projection, 2, 0, 4), - [170] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_projection, 2, 0, 4), - [172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_literal, 3, 1, 0), - [174] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_literal, 3, 1, 0), - [176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_open_expression_repeat1, 2, 0, 0), - [178] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_open_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(18), - [181] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 2, 0, 0), - [183] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 2, 0, 0), - [185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interval_shorthand, 1, 0, 0), - [187] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interval_shorthand, 1, 0, 0), - [189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_expression, 1, 0, 7), - [191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__pipeline_expression, 1, 0, 7), - [193] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_closed_expression, 2, 0, 0), - [195] = {.entry = {.count = 1, .reusable = false}}, SHIFT(17), - [197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), - [199] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interval_literal, 2, 0, 0), - [201] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interval_literal, 2, 0, 0), - [203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4, 0, 1), - [205] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4, 0, 1), - [207] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_closed_expression, 1, 0, 0), - [209] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_incoming_value, 1, 0, 0), - [211] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_incoming_value, 1, 0, 0), - [213] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 4, 0, 0), - [215] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 4, 0, 0), - [217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_literal, 4, 1, 0), - [219] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_literal, 4, 1, 0), - [221] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 9), - [223] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 9), - [225] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_projection, 3, 0, 10), - [227] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_projection, 3, 0, 10), - [229] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3, 0, 1), - [231] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3, 0, 1), - [233] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parenthesized_pipeline_expression, 3, 0, 9), - [235] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__parenthesized_pipeline_expression, 3, 0, 9), - [237] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_literal, 3, 0, 0), - [239] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_literal, 3, 0, 0), - [241] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_value, 1, 0, 0), - [243] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_value, 1, 0, 0), - [245] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_literal, 6, 0, 0), - [247] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_literal, 6, 0, 0), - [249] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_literal, 7, 0, 0), - [251] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_literal, 7, 0, 0), - [253] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_open_expression, 1, 0, 0), - [255] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), - [257] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_open_expression, 2, 0, 0), - [259] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), - [261] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), - [263] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_shorthand, 2, 0, 3), - [265] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_shorthand, 2, 0, 3), - [267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), - [269] = {.entry = {.count = 1, .reusable = false}}, SHIFT(32), - [271] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [273] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_closed_expression, 4, 0, 0), - [275] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_infinite_bound, 1, 0, 0), - [277] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interval_bound, 1, 0, 0), - [279] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_double_quoted_literal_repeat1, 2, 0, 0), - [281] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_double_quoted_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(77), - [284] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_closed_expression_repeat1, 1, 0, 7), - [286] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_closed_expression_repeat1, 1, 0, 7), - [288] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_field_name, 1, 0, 0), - [290] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_closed_expression_repeat1, 2, 0, 0), - [292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_map_shorthand, 2, 0, 3), - [294] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__pipeline_map_shorthand, 2, 0, 3), - [296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_open_expression, 1, 0, 0), - [298] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_open_expression, 1, 0, 0), - [300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), - [304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [306] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_open_expression, 2, 0, 0), - [308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_open_expression, 1, 0, 0), - [310] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_literal_repeat1, 2, 0, 0), - [312] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(12), - [315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_closed_expression, 3, 0, 0), - [317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(31), - [319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), - [331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [333] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_record_spread, 1, 0, 0), REDUCE(sym_incoming_value, 1, 0, 0), - [336] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_record_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(22), - [339] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_literal_repeat1, 2, 0, 0), - [341] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), - [343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), - [345] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_open_expression, 1, 0, 0), - [347] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__pipeline_expression, 1, 0, 0), - [349] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_expression, 1, 0, 0), - [351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), - [353] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__argument_value, 1, 0, 0), - [355] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), - [357] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(6), - [360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), - [364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_open_expression, 2, 0, 0), - [366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [372] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_argument, 1, 0, 0), - [374] = {.entry = {.count = 1, .reusable = false}}, SHIFT(28), - [376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_root_expression, 1, 0, 0), - [380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 14), - [382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_spread, 1, 0, 0), - [388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_field, 3, 0, 13), - [390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameterized_expression, 5, 0, 16), - [392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [396] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), - [400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), - [402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), - [406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), - [410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), - [416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [104] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_backtick_quoted_literal, 2, 0, 0), + [106] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_backtick_quoted_literal, 2, 0, 0), + [108] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_backtick_quoted_literal, 3, 0, 0), + [110] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_backtick_quoted_literal, 3, 0, 0), + [112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_double_quoted_literal, 2, 0, 0), + [114] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_double_quoted_literal, 2, 0, 0), + [116] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_immediate_record_field_selector, 1, 0, 0), + [118] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_immediate_record_field_selector, 1, 0, 0), + [120] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_access_repeat1, 1, 0, 2), + [122] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_record_access_repeat1, 1, 0, 2), + [124] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_original_record_field_selector, 1, 0, 5), + [126] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_original_record_field_selector, 1, 0, 5), + [128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_quoted_literal, 1, 0, 0), + [130] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_quoted_literal, 1, 0, 0), + [132] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_original_record_field_selector, 1, 0, 0), + [134] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_original_record_field_selector, 1, 0, 0), + [136] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean_literal, 1, 0, 0), + [138] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean_literal, 1, 0, 0), + [140] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_field_selector, 1, 0, 0), + [142] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_field_selector, 1, 0, 0), + [144] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temporal_literal, 1, 0, 0), + [146] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temporal_literal, 1, 0, 0), + [148] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 1, 0, 1), + [150] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 1, 0, 1), + [152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [154] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 4, 1, 0), + [156] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 4, 1, 0), + [158] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_closed_expression, 1, 0, 0), + [160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(24), + [162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_incoming_value, 1, 0, 0), + [166] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_incoming_value, 1, 0, 0), + [168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_expression, 1, 0, 7), + [170] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__pipeline_expression, 1, 0, 7), + [172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_open_expression_repeat1, 2, 0, 0), + [174] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_open_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(22), + [177] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_closed_expression_repeat1, 2, 0, 0), + [179] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_closed_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(24), + [182] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_closed_expression_repeat1, 2, 0, 0), SHIFT_REPEAT(27), + [185] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 2, 1, 0), + [187] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 2, 1, 0), + [189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_value, 1, 0, 0), + [191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_value, 1, 0, 0), + [193] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_literal, 3, 0, 0), + [195] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_literal, 3, 0, 0), + [197] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4, 0, 1), + [199] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4, 0, 1), + [201] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_closed_expression, 2, 0, 0), + [203] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_projection, 2, 0, 4), + [205] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_projection, 2, 0, 4), + [207] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_literal, 7, 0, 0), + [209] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_literal, 7, 0, 0), + [211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_literal, 4, 2, 0), + [213] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_literal, 4, 2, 0), + [215] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 3, 1, 0), + [217] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 3, 1, 0), + [219] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interval_shorthand, 1, 0, 0), + [221] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interval_shorthand, 1, 0, 0), + [223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_literal, 3, 2, 0), + [225] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_record_literal, 3, 2, 0), + [227] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interval_literal, 2, 0, 0), + [229] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interval_literal, 2, 0, 0), + [231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__parenthesized_pipeline_expression, 3, 0, 9), + [233] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__parenthesized_pipeline_expression, 3, 0, 9), + [235] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3, 0, 9), + [237] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3, 0, 9), + [239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_projection, 3, 0, 10), + [241] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_projection, 3, 0, 10), + [243] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interval_literal, 6, 0, 15), + [245] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interval_literal, 6, 0, 15), + [247] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_literal, 6, 0, 0), + [249] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_literal, 6, 0, 0), + [251] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3, 0, 1), + [253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3, 0, 1), + [255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), + [257] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1, 0, 0), + [259] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_open_expression, 1, 0, 0), + [261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [263] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_open_expression, 2, 0, 0), + [265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [267] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_map_shorthand, 2, 0, 3), + [269] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_map_shorthand, 2, 0, 3), + [271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__array_closed_expression, 3, 0, 0), + [273] = {.entry = {.count = 1, .reusable = false}}, SHIFT(34), + [275] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [277] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_closed_expression_repeat1, 1, 0, 7), + [279] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_closed_expression_repeat1, 1, 0, 7), + [281] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_double_quoted_literal_repeat1, 2, 0, 0), + [283] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_double_quoted_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(83), + [286] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_field_name, 1, 0, 0), + [288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [294] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_closed_expression_repeat1, 2, 0, 0), + [296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_map_shorthand, 2, 0, 3), + [298] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__pipeline_map_shorthand, 2, 0, 3), + [300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_open_expression, 3, 0, 0), + [302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_closed_expression, 3, 0, 0), + [304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__array_closed_expression, 4, 0, 0), + [306] = {.entry = {.count = 1, .reusable = false}}, SHIFT(38), + [308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [310] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_open_expression, 1, 0, 0), + [312] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_open_expression, 1, 0, 0), + [314] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression, 1, 0, 0), REDUCE(sym__pipeline_expression, 1, 0, 0), + [317] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_expression, 1, 0, 0), + [319] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_open_expression, 4, 0, 0), + [321] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_open_expression, 1, 0, 0), + [323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_closed_expression, 4, 0, 0), + [325] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_infinite_bound, 1, 0, 0), + [327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interval_bound, 1, 0, 0), + [331] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__nested_open_expression, 2, 0, 0), + [333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [335] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tuple_literal_repeat1, 2, 0, 0), + [337] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tuple_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(15), + [340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2, 0, 0), + [342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__array_element, 1, 0, 0), + [350] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_array_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(12), + [353] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_array_literal_repeat1, 2, 0, 0), + [355] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_record_literal_repeat1, 2, 0, 0), SHIFT_REPEAT(28), + [358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_record_literal_repeat1, 2, 0, 0), + [360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_open_expression, 1, 0, 0), + [362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__pipeline_expression, 1, 0, 0), + [364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [368] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_record_spread, 1, 0, 0), REDUCE(sym_incoming_value, 1, 0, 0), + [371] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), + [373] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_argument_list_repeat1, 2, 0, 0), SHIFT_REPEAT(6), + [376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__argument_value, 1, 0, 0), + [380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1, 0, 0), + [386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pipeline_open_expression, 2, 0, 0), + [390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_spread, 1, 0, 0), + [408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_record_field, 3, 0, 13), + [410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_root_expression, 1, 0, 0), + [412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_positional_argument, 1, 0, 0), + [414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameterized_expression, 5, 3, 16), + [416] = {.entry = {.count = 1, .reusable = false}}, SHIFT(35), + [418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_argument, 3, 0, 14), + [422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_file, 1, 0, 0), + [428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [432] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [446] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_root_expression, 1, 0, 0), SHIFT(68), + [449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), }; #ifdef __cplusplus diff --git a/test/corpus/compound_values.txt b/test/corpus/compound_values.txt index dc3ec8a..b71bc77 100644 --- a/test/corpus/compound_values.txt +++ b/test/corpus/compound_values.txt @@ -53,6 +53,27 @@ Array values and whitespace root: (original_input) field: (original_record_field_selector (positional_record_field))))))) +================== +Input expressions as array elements +================== + +{ @foo | text-to-func("bar") } + +--- + +(source_file + (root_expression + (closed_expression + (array_literal + (closed_expression + (variable) + (function_call + name: (function_name) + (argument_list + (positional_argument + (double_quoted_literal + (double_quoted_content)))))))))) + ================== Nested and single-element arrays ================== diff --git a/test/corpus/interval_literals.txt b/test/corpus/interval_literals.txt index fe398c1..a8401ea 100644 --- a/test/corpus/interval_literals.txt +++ b/test/corpus/interval_literals.txt @@ -105,6 +105,35 @@ Sign-oriented interval shorthands (interval_literal (interval_shorthand)))))) +================== +Comparison and word interval shorthands +================== + +{I(>40), I(<40), I(>=40), I(<=40), I(positive), I(negative), I(absolutely-positive), I(absolutely-negative)} + +--- + +(source_file + (root_expression + (closed_expression + (array_literal + (interval_literal + (interval_shorthand)) + (interval_literal + (interval_shorthand)) + (interval_literal + (interval_shorthand)) + (interval_literal + (interval_shorthand)) + (interval_literal + (interval_shorthand)) + (interval_literal + (interval_shorthand)) + (interval_literal + (interval_shorthand)) + (interval_literal + (interval_shorthand)))))) + ================== Canonical temporal interval bounds ================== diff --git a/test/corpus/parameterized_expressions.txt b/test/corpus/parameterized_expressions.txt index 3a127de..26b92c6 100644 --- a/test/corpus/parameterized_expressions.txt +++ b/test/corpus/parameterized_expressions.txt @@ -171,7 +171,7 @@ foo({1,2,3}, {name := "Alice"}, {@foo | lower}) name: (function_name)))))))))) ================== -Top-level braces do not form a parameterized expression +Top-level braces form an array with an input expression ================== {@foo | lower} @@ -182,14 +182,13 @@ Top-level braces do not form a parameterized expression (root_expression (closed_expression (array_literal - (variable) - (MISSING "}")) - (function_call - (function_name)))) - (ERROR)) + (closed_expression + (variable) + (function_call + (function_name))))))) ================== -Nested braces recover as a positional parameterized expression, not an array element +Nested braces form an array argument containing an input expression ================== foo({{@foo | lower}}) @@ -203,14 +202,12 @@ foo({{@foo | lower}}) (function_name) (argument_list (positional_argument - (parameterized_expression + (array_literal (array_literal - (variable) - (MISSING "}")) - (open_expression - (function_call - (function_name)))))) - (ERROR))))) + (closed_expression + (variable) + (function_call + (function_name))))))))))) ================== Missing source recovery snapshot rejects the parameterized expression diff --git a/test/corpus/tuple_projection.txt b/test/corpus/tuple_projection.txt index 076427e..8831978 100644 --- a/test/corpus/tuple_projection.txt +++ b/test/corpus/tuple_projection.txt @@ -101,6 +101,40 @@ foo($0, $^0) direction: (from_end) index: (tuple_index)))))))) +================== +Tuple projection compositions as function arguments +================== + +adjacent($1 | subtract($0) | multiply($1)) + +--- + +(source_file + (root_expression + (open_expression + (function_call + name: (function_name) + (argument_list + (positional_argument + (open_expression + (tuple_projection + direction: (from_start) + index: (tuple_index)) + (function_call + name: (function_name) + (argument_list + (positional_argument + (tuple_projection + direction: (from_start) + index: (tuple_index))))) + (function_call + name: (function_name) + (argument_list + (positional_argument + (tuple_projection + direction: (from_start) + index: (tuple_index)))))))))))) + ================== Tuple projection is distinct from field access ==================